From bcdbc4f05275d78c221d98c9174e19c89169c0d8 Mon Sep 17 00:00:00 2001 From: Jan Hoffmann Date: Tue, 31 Jan 2017 16:02:17 +0100 Subject: [PATCH 1/4] Added method for listing all starred gists --- lib/User.js | 20 ++++++++++++++++++++ 1 file changed, 20 insertions(+) diff --git a/lib/User.js b/lib/User.js index 3f3b4bb6..9141a0c8 100644 --- a/lib/User.js +++ b/lib/User.js @@ -91,6 +91,26 @@ class User extends Requestable { return this._request('GET', this.__getScopedUrl('gists'), null, cb); } + /** + * List the user's starred gists + * @see https://developer.github.com/v3/gists/#list-starred-gists + * @param {Requestable.callback} [cb] - will receive the list of gists + * @return {Promise} - the promise for the http request + */ + listStarredGists(cb) { + return this._request('GET', this.__getScopedUrl('gists/starred'), null, cb); + } + + /** + * List the user's gists + * @see https://developer.github.com/v3/gists/#list-a-users-gists + * @param {Requestable.callback} [cb] - will receive the list of gists + * @return {Promise} - the promise for the http request + */ + listStarredGists(cb) { + return this._request('GET', this.__getScopedUrl('gists'), null, cb); + } + /** * List the user's notifications * @see https://developer.github.com/v3/activity/notifications/#list-your-notifications From fd2feb36bc2be6fc6731bc67fea3b160aeeb4c35 Mon Sep 17 00:00:00 2001 From: Jan Hoffmann Date: Tue, 31 Jan 2017 16:34:24 +0100 Subject: [PATCH 2/4] 3.1.1 --- package.json | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/package.json b/package.json index 2ea2eb9a..24f80a47 100644 --- a/package.json +++ b/package.json @@ -1,6 +1,6 @@ { "name": "github-api", - "version": "3.1.0", + "version": "3.1.1", "license": "BSD-3-Clause-Clear", "description": "A higher-level wrapper around the Github API.", "main": "dist/components/GitHub.js", From 0d87d9f40b7c332d7425ce83341fd85266c9e3a8 Mon Sep 17 00:00:00 2001 From: Jan Hoffmann Date: Tue, 31 Jan 2017 16:40:40 +0100 Subject: [PATCH 3/4] Added dist for my own purposes --- .gitignore | 1 - dist/GitHub.bundle.js | 8093 +++++++++++++++++++++++++++ dist/GitHub.bundle.js.map | 1 + dist/GitHub.bundle.min.js | 4 + dist/GitHub.bundle.min.js.map | 1 + dist/GitHub.js | 3531 ++++++++++++ dist/GitHub.js.map | 1 + dist/GitHub.min.js | 3 + dist/GitHub.min.js.map | 1 + dist/components/Gist.js | 258 + dist/components/Gist.js.map | 1 + dist/components/GitHub.js | 221 + dist/components/GitHub.js.map | 1 + dist/components/Issue.js | 335 ++ dist/components/Issue.js.map | 1 + dist/components/Markdown.js | 64 + dist/components/Markdown.js.map | 1 + dist/components/Organization.js | 169 + dist/components/Organization.js.map | 1 + dist/components/Project.js | 306 + dist/components/Project.js.map | 1 + dist/components/RateLimit.js | 60 + dist/components/RateLimit.js.map | 1 + dist/components/Repository.js | 1089 ++++ dist/components/Repository.js.map | 1 + dist/components/Requestable.js | 388 ++ dist/components/Requestable.js.map | 1 + dist/components/Search.js | 151 + dist/components/Search.js.map | 1 + dist/components/Team.js | 219 + dist/components/Team.js.map | 1 + dist/components/User.js | 264 + dist/components/User.js.map | 1 + 33 files changed, 15171 insertions(+), 1 deletion(-) create mode 100644 dist/GitHub.bundle.js create mode 100644 dist/GitHub.bundle.js.map create mode 100644 dist/GitHub.bundle.min.js create mode 100644 dist/GitHub.bundle.min.js.map create mode 100644 dist/GitHub.js create mode 100644 dist/GitHub.js.map create mode 100644 dist/GitHub.min.js create mode 100644 dist/GitHub.min.js.map create mode 100644 dist/components/Gist.js create mode 100644 dist/components/Gist.js.map create mode 100644 dist/components/GitHub.js create mode 100644 dist/components/GitHub.js.map create mode 100644 dist/components/Issue.js create mode 100644 dist/components/Issue.js.map create mode 100644 dist/components/Markdown.js create mode 100644 dist/components/Markdown.js.map create mode 100644 dist/components/Organization.js create mode 100644 dist/components/Organization.js.map create mode 100644 dist/components/Project.js create mode 100644 dist/components/Project.js.map create mode 100644 dist/components/RateLimit.js create mode 100644 dist/components/RateLimit.js.map create mode 100644 dist/components/Repository.js create mode 100644 dist/components/Repository.js.map create mode 100644 dist/components/Requestable.js create mode 100644 dist/components/Requestable.js.map create mode 100644 dist/components/Search.js create mode 100644 dist/components/Search.js.map create mode 100644 dist/components/Team.js create mode 100644 dist/components/Team.js.map create mode 100644 dist/components/User.js create mode 100644 dist/components/User.js.map diff --git a/.gitignore b/.gitignore index db3cda2f..26c78fb9 100644 --- a/.gitignore +++ b/.gitignore @@ -1,7 +1,6 @@ .sass-cache/ _site/ docs/ -dist/ coverage/ node_modules/ .nyc_output/ diff --git a/dist/GitHub.bundle.js b/dist/GitHub.bundle.js new file mode 100644 index 00000000..eb0857b6 --- /dev/null +++ b/dist/GitHub.bundle.js @@ -0,0 +1,8093 @@ +(function(f){if(typeof exports==="object"&&typeof module!=="undefined"){module.exports=f()}else if(typeof define==="function"&&define.amd){define([],f)}else{var g;if(typeof window!=="undefined"){g=window}else if(typeof global!=="undefined"){g=global}else if(typeof self!=="undefined"){g=self}else{g=this}g.GitHub = f()}})(function(){var define,module,exports;return (function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o 1 && arguments[1] !== undefined ? arguments[1] : 'https://api.github.com'; + + _classCallCheck(this, GitHub); + + this.__apiBase = apiBase; + this.__auth = auth || {}; + } + + /** + * Create a new Gist wrapper + * @param {number} [id] - the id for the gist, leave undefined when creating a new gist + * @return {Gist} + */ + + + _createClass(GitHub, [{ + key: 'getGist', + value: function getGist(id) { + return new _Gist2.default(id, this.__auth, this.__apiBase); + } + + /** + * Create a new User wrapper + * @param {string} [user] - the name of the user to get information about + * leave undefined for the authenticated user + * @return {User} + */ + + }, { + key: 'getUser', + value: function getUser(user) { + return new _User2.default(user, this.__auth, this.__apiBase); + } + + /** + * Create a new Organization wrapper + * @param {string} organization - the name of the organization + * @return {Organization} + */ + + }, { + key: 'getOrganization', + value: function getOrganization(organization) { + return new _Organization2.default(organization, this.__auth, this.__apiBase); + } + + /** + * create a new Team wrapper + * @param {string} teamId - the name of the team + * @return {team} + */ + + }, { + key: 'getTeam', + value: function getTeam(teamId) { + return new _Team2.default(teamId, this.__auth, this.__apiBase); + } + + /** + * Create a new Repository wrapper + * @param {string} user - the user who owns the respository + * @param {string} repo - the name of the repository + * @return {Repository} + */ + + }, { + key: 'getRepo', + value: function getRepo(user, repo) { + return new _Repository2.default(this._getFullName(user, repo), this.__auth, this.__apiBase); + } + + /** + * Create a new Issue wrapper + * @param {string} user - the user who owns the respository + * @param {string} repo - the name of the repository + * @return {Issue} + */ + + }, { + key: 'getIssues', + value: function getIssues(user, repo) { + return new _Issue2.default(this._getFullName(user, repo), this.__auth, this.__apiBase); + } + + /** + * Create a new Search wrapper + * @param {string} query - the query to search for + * @return {Search} + */ + + }, { + key: 'search', + value: function search(query) { + return new _Search2.default(query, this.__auth, this.__apiBase); + } + + /** + * Create a new RateLimit wrapper + * @return {RateLimit} + */ + + }, { + key: 'getRateLimit', + value: function getRateLimit() { + return new _RateLimit2.default(this.__auth, this.__apiBase); + } + + /** + * Create a new Markdown wrapper + * @return {Markdown} + */ + + }, { + key: 'getMarkdown', + value: function getMarkdown() { + return new _Markdown2.default(this.__auth, this.__apiBase); + } + + /** + * Create a new Project wrapper + * @param {string} id - the id of the project + * @return {Markdown} + */ + + }, { + key: 'getProject', + value: function getProject(id) { + return new _Project2.default(id, this.__auth, this.__apiBase); + } + + /** + * Computes the full repository name + * @param {string} user - the username (or the full name) + * @param {string} repo - the repository name, must not be passed if `user` is the full name + * @return {string} the repository's full name + */ + + }, { + key: '_getFullName', + value: function _getFullName(user, repo) { + var fullname = user; + + if (repo) { + fullname = user + '/' + repo; + } + + return fullname; + } + }]); + + return GitHub; +}(); + +module.exports = GitHub; + +},{"./Gist":1,"./Issue":3,"./Markdown":4,"./Organization":5,"./Project":6,"./RateLimit":7,"./Repository":8,"./Search":10,"./Team":11,"./User":12}],3:[function(require,module,exports){ +'use strict'; + +var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); + +var _Requestable2 = require('./Requestable'); + +var _Requestable3 = _interopRequireDefault(_Requestable2); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } + +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } /** + * @file + * @copyright 2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc. + * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}. + * Github.js is freely distributable. + */ + +/** + * Issue wraps the functionality to get issues for repositories + */ +var Issue = function (_Requestable) { + _inherits(Issue, _Requestable); + + /** + * Create a new Issue + * @param {string} repository - the full name of the repository (`:user/:repo`) to get issues for + * @param {Requestable.auth} [auth] - information required to authenticate to Github + * @param {string} [apiBase=https://api.github.com] - the base Github API URL + */ + function Issue(repository, auth, apiBase) { + _classCallCheck(this, Issue); + + var _this = _possibleConstructorReturn(this, (Issue.__proto__ || Object.getPrototypeOf(Issue)).call(this, auth, apiBase)); + + _this.__repository = repository; + return _this; + } + + /** + * Create a new issue + * @see https://developer.github.com/v3/issues/#create-an-issue + * @param {Object} issueData - the issue to create + * @param {Requestable.callback} [cb] - will receive the created issue + * @return {Promise} - the promise for the http request + */ + + + _createClass(Issue, [{ + key: 'createIssue', + value: function createIssue(issueData, cb) { + return this._request('POST', '/repos/' + this.__repository + '/issues', issueData, cb); + } + + /** + * List the issues for the repository + * @see https://developer.github.com/v3/issues/#list-issues-for-a-repository + * @param {Object} options - filtering options + * @param {Requestable.callback} [cb] - will receive the array of issues + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'listIssues', + value: function listIssues(options, cb) { + return this._requestAllPages('/repos/' + this.__repository + '/issues', options, cb); + } + + /** + * List the events for an issue + * @see https://developer.github.com/v3/issues/events/#list-events-for-an-issue + * @param {number} issue - the issue to get events for + * @param {Requestable.callback} [cb] - will receive the list of events + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'listIssueEvents', + value: function listIssueEvents(issue, cb) { + return this._request('GET', '/repos/' + this.__repository + '/issues/' + issue + '/events', null, cb); + } + + /** + * List comments on an issue + * @see https://developer.github.com/v3/issues/comments/#list-comments-on-an-issue + * @param {number} issue - the id of the issue to get comments from + * @param {Requestable.callback} [cb] - will receive the comments + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'listIssueComments', + value: function listIssueComments(issue, cb) { + return this._request('GET', '/repos/' + this.__repository + '/issues/' + issue + '/comments', null, cb); + } + + /** + * Get a single comment on an issue + * @see https://developer.github.com/v3/issues/comments/#get-a-single-comment + * @param {number} id - the comment id to get + * @param {Requestable.callback} [cb] - will receive the comment + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'getIssueComment', + value: function getIssueComment(id, cb) { + return this._request('GET', '/repos/' + this.__repository + '/issues/comments/' + id, null, cb); + } + + /** + * Comment on an issue + * @see https://developer.github.com/v3/issues/comments/#create-a-comment + * @param {number} issue - the id of the issue to comment on + * @param {string} comment - the comment to add + * @param {Requestable.callback} [cb] - will receive the created comment + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'createIssueComment', + value: function createIssueComment(issue, comment, cb) { + return this._request('POST', '/repos/' + this.__repository + '/issues/' + issue + '/comments', { body: comment }, cb); + } + + /** + * Edit a comment on an issue + * @see https://developer.github.com/v3/issues/comments/#edit-a-comment + * @param {number} id - the comment id to edit + * @param {string} comment - the comment to edit + * @param {Requestable.callback} [cb] - will receive the edited comment + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'editIssueComment', + value: function editIssueComment(id, comment, cb) { + return this._request('PATCH', '/repos/' + this.__repository + '/issues/comments/' + id, { body: comment }, cb); + } + + /** + * Delete a comment on an issue + * @see https://developer.github.com/v3/issues/comments/#delete-a-comment + * @param {number} id - the comment id to delete + * @param {Requestable.callback} [cb] - will receive true if the request is successful + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'deleteIssueComment', + value: function deleteIssueComment(id, cb) { + return this._request('DELETE', '/repos/' + this.__repository + '/issues/comments/' + id, null, cb); + } + + /** + * Edit an issue + * @see https://developer.github.com/v3/issues/#edit-an-issue + * @param {number} issue - the issue number to edit + * @param {Object} issueData - the new issue data + * @param {Requestable.callback} [cb] - will receive the modified issue + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'editIssue', + value: function editIssue(issue, issueData, cb) { + return this._request('PATCH', '/repos/' + this.__repository + '/issues/' + issue, issueData, cb); + } + + /** + * Get a particular issue + * @see https://developer.github.com/v3/issues/#get-a-single-issue + * @param {number} issue - the issue number to fetch + * @param {Requestable.callback} [cb] - will receive the issue + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'getIssue', + value: function getIssue(issue, cb) { + return this._request('GET', '/repos/' + this.__repository + '/issues/' + issue, null, cb); + } + + /** + * List the milestones for the repository + * @see https://developer.github.com/v3/issues/milestones/#list-milestones-for-a-repository + * @param {Object} options - filtering options + * @param {Requestable.callback} [cb] - will receive the array of milestones + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'listMilestones', + value: function listMilestones(options, cb) { + return this._request('GET', '/repos/' + this.__repository + '/milestones', options, cb); + } + + /** + * Get a milestone + * @see https://developer.github.com/v3/issues/milestones/#get-a-single-milestone + * @param {string} milestone - the id of the milestone to fetch + * @param {Requestable.callback} [cb] - will receive the milestone + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'getMilestone', + value: function getMilestone(milestone, cb) { + return this._request('GET', '/repos/' + this.__repository + '/milestones/' + milestone, null, cb); + } + + /** + * Create a new milestone + * @see https://developer.github.com/v3/issues/milestones/#create-a-milestone + * @param {Object} milestoneData - the milestone definition + * @param {Requestable.callback} [cb] - will receive the milestone + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'createMilestone', + value: function createMilestone(milestoneData, cb) { + return this._request('POST', '/repos/' + this.__repository + '/milestones', milestoneData, cb); + } + + /** + * Edit a milestone + * @see https://developer.github.com/v3/issues/milestones/#update-a-milestone + * @param {string} milestone - the id of the milestone to edit + * @param {Object} milestoneData - the updates to make to the milestone + * @param {Requestable.callback} [cb] - will receive the updated milestone + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'editMilestone', + value: function editMilestone(milestone, milestoneData, cb) { + return this._request('PATCH', '/repos/' + this.__repository + '/milestones/' + milestone, milestoneData, cb); + } + + /** + * Delete a milestone (this is distinct from closing a milestone) + * @see https://developer.github.com/v3/issues/milestones/#delete-a-milestone + * @param {string} milestone - the id of the milestone to delete + * @param {Requestable.callback} [cb] - will receive the status + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'deleteMilestone', + value: function deleteMilestone(milestone, cb) { + return this._request('DELETE', '/repos/' + this.__repository + '/milestones/' + milestone, null, cb); + } + + /** + * Create a new label + * @see https://developer.github.com/v3/issues/labels/#create-a-label + * @param {Object} labelData - the label definition + * @param {Requestable.callback} [cb] - will receive the object representing the label + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'createLabel', + value: function createLabel(labelData, cb) { + return this._request('POST', '/repos/' + this.__repository + '/labels', labelData, cb); + } + + /** + * List the labels for the repository + * @see https://developer.github.com/v3/issues/labels/#list-all-labels-for-this-repository + * @param {Object} options - filtering options + * @param {Requestable.callback} [cb] - will receive the array of labels + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'listLabels', + value: function listLabels(options, cb) { + return this._request('GET', '/repos/' + this.__repository + '/labels', options, cb); + } + + /** + * Get a label + * @see https://developer.github.com/v3/issues/labels/#get-a-single-label + * @param {string} label - the name of the label to fetch + * @param {Requestable.callback} [cb] - will receive the label + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'getLabel', + value: function getLabel(label, cb) { + return this._request('GET', '/repos/' + this.__repository + '/labels/' + label, null, cb); + } + + /** + * Edit a label + * @see https://developer.github.com/v3/issues/labels/#update-a-label + * @param {string} label - the name of the label to edit + * @param {Object} labelData - the updates to make to the label + * @param {Requestable.callback} [cb] - will receive the updated label + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'editLabel', + value: function editLabel(label, labelData, cb) { + return this._request('PATCH', '/repos/' + this.__repository + '/labels/' + label, labelData, cb); + } + + /** + * Delete a label + * @see https://developer.github.com/v3/issues/labels/#delete-a-label + * @param {string} label - the name of the label to delete + * @param {Requestable.callback} [cb] - will receive the status + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'deleteLabel', + value: function deleteLabel(label, cb) { + return this._request('DELETE', '/repos/' + this.__repository + '/labels/' + label, null, cb); + } + }]); + + return Issue; +}(_Requestable3.default); + +module.exports = Issue; + +},{"./Requestable":9}],4:[function(require,module,exports){ +'use strict'; + +var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); + +var _Requestable2 = require('./Requestable'); + +var _Requestable3 = _interopRequireDefault(_Requestable2); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } + +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } /** + * @file + * @copyright 2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc. + * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}. + * Github.js is freely distributable. + */ + +/** + * Renders html from Markdown text + */ +var Markdown = function (_Requestable) { + _inherits(Markdown, _Requestable); + + /** + * construct a Markdown + * @param {Requestable.auth} auth - the credentials to authenticate to GitHub + * @param {string} [apiBase] - the base Github API URL + * @return {Promise} - the promise for the http request + */ + function Markdown(auth, apiBase) { + _classCallCheck(this, Markdown); + + return _possibleConstructorReturn(this, (Markdown.__proto__ || Object.getPrototypeOf(Markdown)).call(this, auth, apiBase)); + } + + /** + * Render html from Markdown text. + * @see https://developer.github.com/v3/markdown/#render-an-arbitrary-markdown-document + * @param {Object} options - conversion options + * @param {string} [options.text] - the markdown text to convert + * @param {string} [options.mode=markdown] - can be either `markdown` or `gfm` + * @param {string} [options.context] - repository name if mode is gfm + * @param {Requestable.callback} [cb] - will receive the converted html + * @return {Promise} - the promise for the http request + */ + + + _createClass(Markdown, [{ + key: 'render', + value: function render(options, cb) { + return this._request('POST', '/markdown', options, cb); + } + }]); + + return Markdown; +}(_Requestable3.default); + +module.exports = Markdown; + +},{"./Requestable":9}],5:[function(require,module,exports){ +'use strict'; + +var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); + +var _Requestable2 = require('./Requestable'); + +var _Requestable3 = _interopRequireDefault(_Requestable2); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } + +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } /** + * @file + * @copyright 2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc. + * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}. + * Github.js is freely distributable. + */ + +/** + * Organization encapsulates the functionality to create repositories in organizations + */ +var Organization = function (_Requestable) { + _inherits(Organization, _Requestable); + + /** + * Create a new Organization + * @param {string} organization - the name of the organization + * @param {Requestable.auth} [auth] - information required to authenticate to Github + * @param {string} [apiBase=https://api.github.com] - the base Github API URL + */ + function Organization(organization, auth, apiBase) { + _classCallCheck(this, Organization); + + var _this = _possibleConstructorReturn(this, (Organization.__proto__ || Object.getPrototypeOf(Organization)).call(this, auth, apiBase)); + + _this.__name = organization; + return _this; + } + + /** + * Create a repository in an organization + * @see https://developer.github.com/v3/repos/#create + * @param {Object} options - the repository definition + * @param {Requestable.callback} [cb] - will receive the created repository + * @return {Promise} - the promise for the http request + */ + + + _createClass(Organization, [{ + key: 'createRepo', + value: function createRepo(options, cb) { + return this._request('POST', '/orgs/' + this.__name + '/repos', options, cb); + } + + /** + * List the repositories in an organization + * @see https://developer.github.com/v3/repos/#list-organization-repositories + * @param {Requestable.callback} [cb] - will receive the list of repositories + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'getRepos', + value: function getRepos(cb) { + var requestOptions = this._getOptionsWithDefaults({ direction: 'desc' }); + + return this._requestAllPages('/orgs/' + this.__name + '/repos', requestOptions, cb); + } + + /** + * Query if the user is a member or not + * @param {string} username - the user in question + * @param {Requestable.callback} [cb] - will receive true if the user is a member + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'isMember', + value: function isMember(username, cb) { + return this._request204or404('/orgs/' + this.__name + '/members/' + username, null, cb); + } + + /** + * List the users who are members of the company + * @see https://developer.github.com/v3/orgs/members/#members-list + * @param {object} options - filtering options + * @param {string} [options.filter=all] - can be either `2fa_disabled` or `all` + * @param {string} [options.role=all] - can be one of: `all`, `admin`, or `member` + * @param {Requestable.callback} [cb] - will receive the list of users + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'listMembers', + value: function listMembers(options, cb) { + return this._request('GET', '/orgs/' + this.__name + '/members', options, cb); + } + + /** + * List the Teams in the Organization + * @see https://developer.github.com/v3/orgs/teams/#list-teams + * @param {Requestable.callback} [cb] - will receive the list of teams + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'getTeams', + value: function getTeams(cb) { + return this._requestAllPages('/orgs/' + this.__name + '/teams', undefined, cb); + } + + /** + * Create a team + * @see https://developer.github.com/v3/orgs/teams/#create-team + * @param {object} options - Team creation parameters + * @param {string} options.name - The name of the team + * @param {string} [options.description] - Team description + * @param {string} [options.repo_names] - Repos to add the team to + * @param {string} [options.privacy=secret] - The level of privacy the team should have. Can be either one + * of: `secret`, or `closed` + * @param {Requestable.callback} [cb] - will receive the created team + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'createTeam', + value: function createTeam(options, cb) { + return this._request('POST', '/orgs/' + this.__name + '/teams', options, cb); + } + + /** + * Get information about all projects + * @see https://developer.github.com/v3/projects/#list-organization-projects + * @param {Requestable.callback} [cb] - will receive the list of projects + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'listProjects', + value: function listProjects(cb) { + return this._requestAllPages('/orgs/' + this.__name + '/projects', { AcceptHeader: 'inertia-preview' }, cb); + } + + /** + * Create a new project + * @see https://developer.github.com/v3/repos/projects/#create-a-project + * @param {Object} options - the description of the project + * @param {Requestable.callback} cb - will receive the newly created project + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'createProject', + value: function createProject(options, cb) { + options = options || {}; + options.AcceptHeader = 'inertia-preview'; + return this._request('POST', '/orgs/' + this.__name + '/projects', options, cb); + } + }]); + + return Organization; +}(_Requestable3.default); + +module.exports = Organization; + +},{"./Requestable":9}],6:[function(require,module,exports){ +'use strict'; + +var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); + +var _Requestable2 = require('./Requestable'); + +var _Requestable3 = _interopRequireDefault(_Requestable2); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +function _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } } + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } + +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } /** + * @file + * @copyright 2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc. + * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}. + * Github.js is freely distributable. + */ + +/** + * Project encapsulates the functionality to create, query, and modify cards and columns. + */ +var Project = function (_Requestable) { + _inherits(Project, _Requestable); + + /** + * Create a Project. + * @param {string} id - the id of the project + * @param {Requestable.auth} [auth] - information required to authenticate to Github + * @param {string} [apiBase=https://api.github.com] - the base Github API URL + */ + function Project(id, auth, apiBase) { + _classCallCheck(this, Project); + + var _this = _possibleConstructorReturn(this, (Project.__proto__ || Object.getPrototypeOf(Project)).call(this, auth, apiBase, 'inertia-preview')); + + _this.__id = id; + return _this; + } + + /** + * Get information about a project + * @see https://developer.github.com/v3/projects/#get-a-project + * @param {Requestable.callback} cb - will receive the project information + * @return {Promise} - the promise for the http request + */ + + + _createClass(Project, [{ + key: 'getProject', + value: function getProject(cb) { + return this._request('GET', '/projects/' + this.__id, null, cb); + } + + /** + * Edit a project + * @see https://developer.github.com/v3/projects/#update-a-project + * @param {Object} options - the description of the project + * @param {Requestable.callback} cb - will receive the modified project + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'updateProject', + value: function updateProject(options, cb) { + return this._request('PATCH', '/projects/' + this.__id, options, cb); + } + + /** + * Delete a project + * @see https://developer.github.com/v3/projects/#delete-a-project + * @param {Requestable.callback} cb - will receive true if the operation is successful + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'deleteProject', + value: function deleteProject(cb) { + return this._request('DELETE', '/projects/' + this.__id, null, cb); + } + + /** + * Get information about all columns of a project + * @see https://developer.github.com/v3/projects/columns/#list-project-columns + * @param {Requestable.callback} [cb] - will receive the list of columns + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'listProjectColumns', + value: function listProjectColumns(cb) { + return this._requestAllPages('/projects/' + this.__id + '/columns', null, cb); + } + + /** + * Get information about a column + * @see https://developer.github.com/v3/projects/columns/#get-a-project-column + * @param {string} colId - the id of the column + * @param {Requestable.callback} cb - will receive the column information + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'getProjectColumn', + value: function getProjectColumn(colId, cb) { + return this._request('GET', '/projects/columns/' + colId, null, cb); + } + + /** + * Create a new column + * @see https://developer.github.com/v3/projects/columns/#create-a-project-column + * @param {Object} options - the description of the column + * @param {Requestable.callback} cb - will receive the newly created column + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'createProjectColumn', + value: function createProjectColumn(options, cb) { + return this._request('POST', '/projects/' + this.__id + '/columns', options, cb); + } + + /** + * Edit a column + * @see https://developer.github.com/v3/projects/columns/#update-a-project-column + * @param {string} colId - the column id + * @param {Object} options - the description of the column + * @param {Requestable.callback} cb - will receive the modified column + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'updateProjectColumn', + value: function updateProjectColumn(colId, options, cb) { + return this._request('PATCH', '/projects/columns/' + colId, options, cb); + } + + /** + * Delete a column + * @see https://developer.github.com/v3/projects/columns/#delete-a-project-column + * @param {string} colId - the column to be deleted + * @param {Requestable.callback} cb - will receive true if the operation is successful + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'deleteProjectColumn', + value: function deleteProjectColumn(colId, cb) { + return this._request('DELETE', '/projects/columns/' + colId, null, cb); + } + + /** + * Move a column + * @see https://developer.github.com/v3/projects/columns/#move-a-project-column + * @param {string} colId - the column to be moved + * @param {string} position - can be one of first, last, or after:, + * where is the id value of a column in the same project. + * @param {Requestable.callback} cb - will receive true if the operation is successful + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'moveProjectColumn', + value: function moveProjectColumn(colId, position, cb) { + return this._request('POST', '/projects/columns/' + colId + '/moves', { position: position }, cb); + } + + /** + * Get information about all cards of a project + * @see https://developer.github.com/v3/projects/cards/#list-project-cards + * @param {Requestable.callback} [cb] - will receive the list of cards + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'listProjectCards', + value: function listProjectCards(cb) { + var _this2 = this; + + return this.listProjectColumns().then(function (_ref) { + var data = _ref.data; + + return Promise.all(data.map(function (column) { + return _this2._requestAllPages('/projects/columns/' + column.id + '/cards', null); + })); + }).then(function (cardsInColumns) { + var cards = cardsInColumns.reduce(function (prev, _ref2) { + var data = _ref2.data; + + prev.push.apply(prev, _toConsumableArray(data)); + return prev; + }, []); + if (cb) { + cb(null, cards); + } + return cards; + }).catch(function (err) { + if (cb) { + cb(err); + return; + } + throw err; + }); + } + + /** + * Get information about all cards of a column + * @see https://developer.github.com/v3/projects/cards/#list-project-cards + * @param {string} colId - the id of the column + * @param {Requestable.callback} [cb] - will receive the list of cards + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'listColumnCards', + value: function listColumnCards(colId, cb) { + return this._requestAllPages('/projects/columns/' + colId + '/cards', null, cb); + } + + /** + * Get information about a card + * @see https://developer.github.com/v3/projects/cards/#get-a-project-card + * @param {string} cardId - the id of the card + * @param {Requestable.callback} cb - will receive the card information + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'getProjectCard', + value: function getProjectCard(cardId, cb) { + return this._request('GET', '/projects/columns/cards/' + cardId, null, cb); + } + + /** + * Create a new card + * @see https://developer.github.com/v3/projects/cards/#create-a-project-card + * @param {string} colId - the column id + * @param {Object} options - the description of the card + * @param {Requestable.callback} cb - will receive the newly created card + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'createProjectCard', + value: function createProjectCard(colId, options, cb) { + return this._request('POST', '/projects/columns/' + colId + '/cards', options, cb); + } + + /** + * Edit a card + * @see https://developer.github.com/v3/projects/cards/#update-a-project-card + * @param {string} cardId - the card id + * @param {Object} options - the description of the card + * @param {Requestable.callback} cb - will receive the modified card + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'updateProjectCard', + value: function updateProjectCard(cardId, options, cb) { + return this._request('PATCH', '/projects/columns/cards/' + cardId, options, cb); + } + + /** + * Delete a card + * @see https://developer.github.com/v3/projects/cards/#delete-a-project-card + * @param {string} cardId - the card to be deleted + * @param {Requestable.callback} cb - will receive true if the operation is successful + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'deleteProjectCard', + value: function deleteProjectCard(cardId, cb) { + return this._request('DELETE', '/projects/columns/cards/' + cardId, null, cb); + } + + /** + * Move a card + * @see https://developer.github.com/v3/projects/cards/#move-a-project-card + * @param {string} cardId - the card to be moved + * @param {string} position - can be one of top, bottom, or after:, + * where is the id value of a card in the same project. + * @param {string} colId - the id value of a column in the same project. + * @param {Requestable.callback} cb - will receive true if the operation is successful + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'moveProjectCard', + value: function moveProjectCard(cardId, position, colId, cb) { + return this._request('POST', '/projects/columns/cards/' + cardId + '/moves', { position: position, column_id: colId }, // eslint-disable-line camelcase + cb); + } + }]); + + return Project; +}(_Requestable3.default); + +module.exports = Project; + +},{"./Requestable":9}],7:[function(require,module,exports){ +'use strict'; + +var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); + +var _Requestable2 = require('./Requestable'); + +var _Requestable3 = _interopRequireDefault(_Requestable2); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } + +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } /** + * @file + * @copyright 2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc. + * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}. + * Github.js is freely distributable. + */ + +/** + * RateLimit allows users to query their rate-limit status + */ +var RateLimit = function (_Requestable) { + _inherits(RateLimit, _Requestable); + + /** + * construct a RateLimit + * @param {Requestable.auth} auth - the credentials to authenticate to GitHub + * @param {string} [apiBase] - the base Github API URL + * @return {Promise} - the promise for the http request + */ + function RateLimit(auth, apiBase) { + _classCallCheck(this, RateLimit); + + return _possibleConstructorReturn(this, (RateLimit.__proto__ || Object.getPrototypeOf(RateLimit)).call(this, auth, apiBase)); + } + + /** + * Query the current rate limit + * @see https://developer.github.com/v3/rate_limit/ + * @param {Requestable.callback} [cb] - will receive the rate-limit data + * @return {Promise} - the promise for the http request + */ + + + _createClass(RateLimit, [{ + key: 'getRateLimit', + value: function getRateLimit(cb) { + return this._request('GET', '/rate_limit', null, cb); + } + }]); + + return RateLimit; +}(_Requestable3.default); + +module.exports = RateLimit; + +},{"./Requestable":9}],8:[function(require,module,exports){ +(function (Buffer){ +'use strict'; + +var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; + +var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); + +var _Requestable2 = require('./Requestable'); + +var _Requestable3 = _interopRequireDefault(_Requestable2); + +var _utf = require('utf8'); + +var _utf2 = _interopRequireDefault(_utf); + +var _jsBase = require('js-base64'); + +var _debug = require('debug'); + +var _debug2 = _interopRequireDefault(_debug); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } + +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } /** + * @file + * @copyright 2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc. + * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}. + * Github.js is freely distributable. + */ + +var log = (0, _debug2.default)('github:repository'); + +/** + * Respository encapsulates the functionality to create, query, and modify files. + */ + +var Repository = function (_Requestable) { + _inherits(Repository, _Requestable); + + /** + * Create a Repository. + * @param {string} fullname - the full name of the repository + * @param {Requestable.auth} [auth] - information required to authenticate to Github + * @param {string} [apiBase=https://api.github.com] - the base Github API URL + */ + function Repository(fullname, auth, apiBase) { + _classCallCheck(this, Repository); + + var _this = _possibleConstructorReturn(this, (Repository.__proto__ || Object.getPrototypeOf(Repository)).call(this, auth, apiBase)); + + _this.__fullname = fullname; + _this.__currentTree = { + branch: null, + sha: null + }; + return _this; + } + + /** + * Get a reference + * @see https://developer.github.com/v3/git/refs/#get-a-reference + * @param {string} ref - the reference to get + * @param {Requestable.callback} [cb] - will receive the reference's refSpec or a list of refSpecs that match `ref` + * @return {Promise} - the promise for the http request + */ + + + _createClass(Repository, [{ + key: 'getRef', + value: function getRef(ref, cb) { + return this._request('GET', '/repos/' + this.__fullname + '/git/refs/' + ref, null, cb); + } + + /** + * Create a reference + * @see https://developer.github.com/v3/git/refs/#create-a-reference + * @param {Object} options - the object describing the ref + * @param {Requestable.callback} [cb] - will receive the ref + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'createRef', + value: function createRef(options, cb) { + return this._request('POST', '/repos/' + this.__fullname + '/git/refs', options, cb); + } + + /** + * Delete a reference + * @see https://developer.github.com/v3/git/refs/#delete-a-reference + * @param {string} ref - the name of the ref to delte + * @param {Requestable.callback} [cb] - will receive true if the request is successful + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'deleteRef', + value: function deleteRef(ref, cb) { + return this._request('DELETE', '/repos/' + this.__fullname + '/git/refs/' + ref, null, cb); + } + + /** + * Delete a repository + * @see https://developer.github.com/v3/repos/#delete-a-repository + * @param {Requestable.callback} [cb] - will receive true if the request is successful + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'deleteRepo', + value: function deleteRepo(cb) { + return this._request('DELETE', '/repos/' + this.__fullname, null, cb); + } + + /** + * List the tags on a repository + * @see https://developer.github.com/v3/repos/#list-tags + * @param {Requestable.callback} [cb] - will receive the tag data + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'listTags', + value: function listTags(cb) { + return this._request('GET', '/repos/' + this.__fullname + '/tags', null, cb); + } + + /** + * List the open pull requests on the repository + * @see https://developer.github.com/v3/pulls/#list-pull-requests + * @param {Object} options - options to filter the search + * @param {Requestable.callback} [cb] - will receive the list of PRs + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'listPullRequests', + value: function listPullRequests(options, cb) { + options = options || {}; + return this._request('GET', '/repos/' + this.__fullname + '/pulls', options, cb); + } + + /** + * Get information about a specific pull request + * @see https://developer.github.com/v3/pulls/#get-a-single-pull-request + * @param {number} number - the PR you wish to fetch + * @param {Requestable.callback} [cb] - will receive the PR from the API + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'getPullRequest', + value: function getPullRequest(number, cb) { + return this._request('GET', '/repos/' + this.__fullname + '/pulls/' + number, null, cb); + } + + /** + * List the files of a specific pull request + * @see https://developer.github.com/v3/pulls/#list-pull-requests-files + * @param {number|string} number - the PR you wish to fetch + * @param {Requestable.callback} [cb] - will receive the list of files from the API + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'listPullRequestFiles', + value: function listPullRequestFiles(number, cb) { + return this._request('GET', '/repos/' + this.__fullname + '/pulls/' + number + '/files', null, cb); + } + + /** + * Compare two branches/commits/repositories + * @see https://developer.github.com/v3/repos/commits/#compare-two-commits + * @param {string} base - the base commit + * @param {string} head - the head commit + * @param {Requestable.callback} cb - will receive the comparison + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'compareBranches', + value: function compareBranches(base, head, cb) { + return this._request('GET', '/repos/' + this.__fullname + '/compare/' + base + '...' + head, null, cb); + } + + /** + * List all the branches for the repository + * @see https://developer.github.com/v3/repos/#list-branches + * @param {Requestable.callback} cb - will receive the list of branches + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'listBranches', + value: function listBranches(cb) { + return this._request('GET', '/repos/' + this.__fullname + '/branches', null, cb); + } + + /** + * Get a raw blob from the repository + * @see https://developer.github.com/v3/git/blobs/#get-a-blob + * @param {string} sha - the sha of the blob to fetch + * @param {Requestable.callback} cb - will receive the blob from the API + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'getBlob', + value: function getBlob(sha, cb) { + return this._request('GET', '/repos/' + this.__fullname + '/git/blobs/' + sha, null, cb, 'raw'); + } + + /** + * Get a single branch + * @see https://developer.github.com/v3/repos/branches/#get-branch + * @param {string} branch - the name of the branch to fetch + * @param {Requestable.callback} cb - will receive the branch from the API + * @returns {Promise} - the promise for the http request + */ + + }, { + key: 'getBranch', + value: function getBranch(branch, cb) { + return this._request('GET', '/repos/' + this.__fullname + '/branches/' + branch, null, cb); + } + + /** + * Get a commit from the repository + * @see https://developer.github.com/v3/repos/commits/#get-a-single-commit + * @param {string} sha - the sha for the commit to fetch + * @param {Requestable.callback} cb - will receive the commit data + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'getCommit', + value: function getCommit(sha, cb) { + return this._request('GET', '/repos/' + this.__fullname + '/git/commits/' + sha, null, cb); + } + + /** + * List the commits on a repository, optionally filtering by path, author or time range + * @see https://developer.github.com/v3/repos/commits/#list-commits-on-a-repository + * @param {Object} [options] - the filtering options for commits + * @param {string} [options.sha] - the SHA or branch to start from + * @param {string} [options.path] - the path to search on + * @param {string} [options.author] - the commit author + * @param {(Date|string)} [options.since] - only commits after this date will be returned + * @param {(Date|string)} [options.until] - only commits before this date will be returned + * @param {Requestable.callback} cb - will receive the list of commits found matching the criteria + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'listCommits', + value: function listCommits(options, cb) { + options = options || {}; + + options.since = this._dateToISO(options.since); + options.until = this._dateToISO(options.until); + + return this._request('GET', '/repos/' + this.__fullname + '/commits', options, cb); + } + + /** + * Gets a single commit information for a repository + * @see https://developer.github.com/v3/repos/commits/#get-a-single-commit + * @param {string} ref - the reference for the commit-ish + * @param {Requestable.callback} cb - will receive the commit information + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'getSingleCommit', + value: function getSingleCommit(ref, cb) { + ref = ref || ''; + return this._request('GET', '/repos/' + this.__fullname + '/commits/' + ref, null, cb); + } + + /** + * Get tha sha for a particular object in the repository. This is a convenience function + * @see https://developer.github.com/v3/repos/contents/#get-contents + * @param {string} [branch] - the branch to look in, or the repository's default branch if omitted + * @param {string} path - the path of the file or directory + * @param {Requestable.callback} cb - will receive a description of the requested object, including a `SHA` property + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'getSha', + value: function getSha(branch, path, cb) { + branch = branch ? '?ref=' + branch : ''; + return this._request('GET', '/repos/' + this.__fullname + '/contents/' + path + branch, null, cb); + } + + /** + * List the commit statuses for a particular sha, branch, or tag + * @see https://developer.github.com/v3/repos/statuses/#list-statuses-for-a-specific-ref + * @param {string} sha - the sha, branch, or tag to get statuses for + * @param {Requestable.callback} cb - will receive the list of statuses + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'listStatuses', + value: function listStatuses(sha, cb) { + return this._request('GET', '/repos/' + this.__fullname + '/commits/' + sha + '/statuses', null, cb); + } + + /** + * Get a description of a git tree + * @see https://developer.github.com/v3/git/trees/#get-a-tree + * @param {string} treeSHA - the SHA of the tree to fetch + * @param {Requestable.callback} cb - will receive the callback data + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'getTree', + value: function getTree(treeSHA, cb) { + return this._request('GET', '/repos/' + this.__fullname + '/git/trees/' + treeSHA, null, cb); + } + + /** + * Create a blob + * @see https://developer.github.com/v3/git/blobs/#create-a-blob + * @param {(string|Buffer|Blob)} content - the content to add to the repository + * @param {Requestable.callback} cb - will receive the details of the created blob + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'createBlob', + value: function createBlob(content, cb) { + var postBody = this._getContentObject(content); + + log('sending content', postBody); + return this._request('POST', '/repos/' + this.__fullname + '/git/blobs', postBody, cb); + } + + /** + * Get the object that represents the provided content + * @param {string|Buffer|Blob} content - the content to send to the server + * @return {Object} the representation of `content` for the GitHub API + */ + + }, { + key: '_getContentObject', + value: function _getContentObject(content) { + if (typeof content === 'string') { + log('contet is a string'); + return { + content: _utf2.default.encode(content), + encoding: 'utf-8' + }; + } else if (typeof Buffer !== 'undefined' && content instanceof Buffer) { + log('We appear to be in Node'); + return { + content: content.toString('base64'), + encoding: 'base64' + }; + } else if (typeof Blob !== 'undefined' && content instanceof Blob) { + log('We appear to be in the browser'); + return { + content: _jsBase.Base64.encode(content), + encoding: 'base64' + }; + } else { + // eslint-disable-line + log('Not sure what this content is: ' + (typeof content === 'undefined' ? 'undefined' : _typeof(content)) + ', ' + JSON.stringify(content)); + throw new Error('Unknown content passed to postBlob. Must be string or Buffer (node) or Blob (web)'); + } + } + + /** + * Update a tree in Git + * @see https://developer.github.com/v3/git/trees/#create-a-tree + * @param {string} baseTreeSHA - the SHA of the tree to update + * @param {string} path - the path for the new file + * @param {string} blobSHA - the SHA for the blob to put at `path` + * @param {Requestable.callback} cb - will receive the new tree that is created + * @return {Promise} - the promise for the http request + * @deprecated use {@link Repository#createTree} instead + */ + + }, { + key: 'updateTree', + value: function updateTree(baseTreeSHA, path, blobSHA, cb) { + var newTree = { + base_tree: baseTreeSHA, // eslint-disable-line + tree: [{ + path: path, + sha: blobSHA, + mode: '100644', + type: 'blob' + }] + }; + + return this._request('POST', '/repos/' + this.__fullname + '/git/trees', newTree, cb); + } + + /** + * Create a new tree in git + * @see https://developer.github.com/v3/git/trees/#create-a-tree + * @param {Object} tree - the tree to create + * @param {string} baseSHA - the root sha of the tree + * @param {Requestable.callback} cb - will receive the new tree that is created + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'createTree', + value: function createTree(tree, baseSHA, cb) { + return this._request('POST', '/repos/' + this.__fullname + '/git/trees', { + tree: tree, + base_tree: baseSHA }, cb); + } + + /** + * Add a commit to the repository + * @see https://developer.github.com/v3/git/commits/#create-a-commit + * @param {string} parent - the SHA of the parent commit + * @param {string} tree - the SHA of the tree for this commit + * @param {string} message - the commit message + * @param {Requestable.callback} cb - will receive the commit that is created + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'commit', + value: function commit(parent, tree, message, cb) { + var _this2 = this; + + var data = { + message: message, + tree: tree, + parents: [parent] + }; + + return this._request('POST', '/repos/' + this.__fullname + '/git/commits', data, cb).then(function (response) { + _this2.__currentTree.sha = response.data.sha; // Update latest commit + return response; + }); + } + + /** + * Update a ref + * @see https://developer.github.com/v3/git/refs/#update-a-reference + * @param {string} ref - the ref to update + * @param {string} commitSHA - the SHA to point the reference to + * @param {boolean} force - indicates whether to force or ensure a fast-forward update + * @param {Requestable.callback} cb - will receive the updated ref back + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'updateHead', + value: function updateHead(ref, commitSHA, force, cb) { + return this._request('PATCH', '/repos/' + this.__fullname + '/git/refs/' + ref, { + sha: commitSHA, + force: force + }, cb); + } + + /** + * Update commit status + * @see https://developer.github.com/v3/repos/statuses/ + * @param {string} commitSHA - the SHA of the commit that should be updated + * @param {object} options - Commit status parameters + * @param {string} options.state - The state of the status. Can be one of: pending, success, error, or failure. + * @param {string} [options.target_url] - The target URL to associate with this status. + * @param {string} [options.description] - A short description of the status. + * @param {string} [options.context] - A string label to differentiate this status among CI systems. + * @param {Requestable.callback} cb - will receive the updated commit back + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'updateStatus', + value: function updateStatus(commitSHA, options, cb) { + return this._request('POST', '/repos/' + this.__fullname + '/statuses/' + commitSHA, options, cb); + } + + /** + * Update repository information + * @see https://developer.github.com/v3/repos/#edit + * @param {object} options - New parameters that will be set to the repository + * @param {string} options.name - Name of the repository + * @param {string} [options.description] - A short description of the repository + * @param {string} [options.homepage] - A URL with more information about the repository + * @param {boolean} [options.private] - Either true to make the repository private, or false to make it public. + * @param {boolean} [options.has_issues] - Either true to enable issues for this repository, false to disable them. + * @param {boolean} [options.has_wiki] - Either true to enable the wiki for this repository, false to disable it. + * @param {boolean} [options.has_downloads] - Either true to enable downloads, false to disable them. + * @param {string} [options.default_branch] - Updates the default branch for this repository. + * @param {Requestable.callback} cb - will receive the updated repository back + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'updateRepository', + value: function updateRepository(options, cb) { + return this._request('PATCH', '/repos/' + this.__fullname, options, cb); + } + + /** + * Get information about the repository + * @see https://developer.github.com/v3/repos/#get + * @param {Requestable.callback} cb - will receive the information about the repository + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'getDetails', + value: function getDetails(cb) { + return this._request('GET', '/repos/' + this.__fullname, null, cb); + } + + /** + * List the contributors to the repository + * @see https://developer.github.com/v3/repos/#list-contributors + * @param {Requestable.callback} cb - will receive the list of contributors + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'getContributors', + value: function getContributors(cb) { + return this._request('GET', '/repos/' + this.__fullname + '/contributors', null, cb); + } + + /** + * List the contributor stats to the repository + * @see https://developer.github.com/v3/repos/#list-contributors + * @param {Requestable.callback} cb - will receive the list of contributors + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'getContributorStats', + value: function getContributorStats(cb) { + return this._request('GET', '/repos/' + this.__fullname + '/stats/contributors', null, cb); + } + + /** + * List the users who are collaborators on the repository. The currently authenticated user must have + * push access to use this method + * @see https://developer.github.com/v3/repos/collaborators/#list-collaborators + * @param {Requestable.callback} cb - will receive the list of collaborators + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'getCollaborators', + value: function getCollaborators(cb) { + return this._request('GET', '/repos/' + this.__fullname + '/collaborators', null, cb); + } + + /** + * Check if a user is a collaborator on the repository + * @see https://developer.github.com/v3/repos/collaborators/#check-if-a-user-is-a-collaborator + * @param {string} username - the user to check + * @param {Requestable.callback} cb - will receive true if the user is a collaborator and false if they are not + * @return {Promise} - the promise for the http request {Boolean} [description] + */ + + }, { + key: 'isCollaborator', + value: function isCollaborator(username, cb) { + return this._request('GET', '/repos/' + this.__fullname + '/collaborators/' + username, null, cb); + } + + /** + * Get the contents of a repository + * @see https://developer.github.com/v3/repos/contents/#get-contents + * @param {string} ref - the ref to check + * @param {string} path - the path containing the content to fetch + * @param {boolean} raw - `true` if the results should be returned raw instead of GitHub's normalized format + * @param {Requestable.callback} cb - will receive the fetched data + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'getContents', + value: function getContents(ref, path, raw, cb) { + path = path ? '' + encodeURI(path) : ''; + return this._request('GET', '/repos/' + this.__fullname + '/contents/' + path, { + ref: ref + }, cb, raw); + } + + /** + * Get the README of a repository + * @see https://developer.github.com/v3/repos/contents/#get-the-readme + * @param {string} ref - the ref to check + * @param {boolean} raw - `true` if the results should be returned raw instead of GitHub's normalized format + * @param {Requestable.callback} cb - will receive the fetched data + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'getReadme', + value: function getReadme(ref, raw, cb) { + return this._request('GET', '/repos/' + this.__fullname + '/readme', { + ref: ref + }, cb, raw); + } + + /** + * Fork a repository + * @see https://developer.github.com/v3/repos/forks/#create-a-fork + * @param {Requestable.callback} cb - will receive the information about the newly created fork + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'fork', + value: function fork(cb) { + return this._request('POST', '/repos/' + this.__fullname + '/forks', null, cb); + } + + /** + * List a repository's forks + * @see https://developer.github.com/v3/repos/forks/#list-forks + * @param {Requestable.callback} cb - will receive the list of repositories forked from this one + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'listForks', + value: function listForks(cb) { + return this._request('GET', '/repos/' + this.__fullname + '/forks', null, cb); + } + + /** + * Create a new branch from an existing branch. + * @param {string} [oldBranch=master] - the name of the existing branch + * @param {string} newBranch - the name of the new branch + * @param {Requestable.callback} cb - will receive the commit data for the head of the new branch + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'createBranch', + value: function createBranch(oldBranch, newBranch, cb) { + var _this3 = this; + + if (typeof newBranch === 'function') { + cb = newBranch; + newBranch = oldBranch; + oldBranch = 'master'; + } + + return this.getRef('heads/' + oldBranch).then(function (response) { + var sha = response.data.object.sha; + return _this3.createRef({ + sha: sha, + ref: 'refs/heads/' + newBranch + }, cb); + }); + } + + /** + * Create a new pull request + * @see https://developer.github.com/v3/pulls/#create-a-pull-request + * @param {Object} options - the pull request description + * @param {Requestable.callback} cb - will receive the new pull request + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'createPullRequest', + value: function createPullRequest(options, cb) { + return this._request('POST', '/repos/' + this.__fullname + '/pulls', options, cb); + } + + /** + * Update a pull request + * @see https://developer.github.com/v3/pulls/#update-a-pull-request + * @param {number|string} number - the number of the pull request to update + * @param {Object} options - the pull request description + * @param {Requestable.callback} [cb] - will receive the pull request information + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'updatePullRequest', + value: function updatePullRequest(number, options, cb) { + return this._request('PATCH', '/repos/' + this.__fullname + '/pulls/' + number, options, cb); + } + + /** + * List the hooks for the repository + * @see https://developer.github.com/v3/repos/hooks/#list-hooks + * @param {Requestable.callback} cb - will receive the list of hooks + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'listHooks', + value: function listHooks(cb) { + return this._request('GET', '/repos/' + this.__fullname + '/hooks', null, cb); + } + + /** + * Get a hook for the repository + * @see https://developer.github.com/v3/repos/hooks/#get-single-hook + * @param {number} id - the id of the webook + * @param {Requestable.callback} cb - will receive the details of the webook + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'getHook', + value: function getHook(id, cb) { + return this._request('GET', '/repos/' + this.__fullname + '/hooks/' + id, null, cb); + } + + /** + * Add a new hook to the repository + * @see https://developer.github.com/v3/repos/hooks/#create-a-hook + * @param {Object} options - the configuration describing the new hook + * @param {Requestable.callback} cb - will receive the new webhook + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'createHook', + value: function createHook(options, cb) { + return this._request('POST', '/repos/' + this.__fullname + '/hooks', options, cb); + } + + /** + * Edit an existing webhook + * @see https://developer.github.com/v3/repos/hooks/#edit-a-hook + * @param {number} id - the id of the webhook + * @param {Object} options - the new description of the webhook + * @param {Requestable.callback} cb - will receive the updated webhook + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'updateHook', + value: function updateHook(id, options, cb) { + return this._request('PATCH', '/repos/' + this.__fullname + '/hooks/' + id, options, cb); + } + + /** + * Delete a webhook + * @see https://developer.github.com/v3/repos/hooks/#delete-a-hook + * @param {number} id - the id of the webhook to be deleted + * @param {Requestable.callback} cb - will receive true if the call is successful + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'deleteHook', + value: function deleteHook(id, cb) { + return this._request('DELETE', '/repos/' + this.__fullname + '/hooks/' + id, null, cb); + } + + /** + * List the deploy keys for the repository + * @see https://developer.github.com/v3/repos/keys/#list-deploy-keys + * @param {Requestable.callback} cb - will receive the list of deploy keys + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'listKeys', + value: function listKeys(cb) { + return this._request('GET', '/repos/' + this.__fullname + '/keys', null, cb); + } + + /** + * Get a deploy key for the repository + * @see https://developer.github.com/v3/repos/keys/#get-a-deploy-key + * @param {number} id - the id of the deploy key + * @param {Requestable.callback} cb - will receive the details of the deploy key + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'getKey', + value: function getKey(id, cb) { + return this._request('GET', '/repos/' + this.__fullname + '/keys/' + id, null, cb); + } + + /** + * Add a new deploy key to the repository + * @see https://developer.github.com/v3/repos/keys/#add-a-new-deploy-key + * @param {Object} options - the configuration describing the new deploy key + * @param {Requestable.callback} cb - will receive the new deploy key + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'createKey', + value: function createKey(options, cb) { + return this._request('POST', '/repos/' + this.__fullname + '/keys', options, cb); + } + + /** + * Delete a deploy key + * @see https://developer.github.com/v3/repos/keys/#remove-a-deploy-key + * @param {number} id - the id of the deploy key to be deleted + * @param {Requestable.callback} cb - will receive true if the call is successful + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'deleteKey', + value: function deleteKey(id, cb) { + return this._request('DELETE', '/repos/' + this.__fullname + '/keys/' + id, null, cb); + } + + /** + * Delete a file from a branch + * @see https://developer.github.com/v3/repos/contents/#delete-a-file + * @param {string} branch - the branch to delete from, or the default branch if not specified + * @param {string} path - the path of the file to remove + * @param {Requestable.callback} cb - will receive the commit in which the delete occurred + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'deleteFile', + value: function deleteFile(branch, path, cb) { + var _this4 = this; + + return this.getSha(branch, path).then(function (response) { + var deleteCommit = { + message: 'Delete the file at \'' + path + '\'', + sha: response.data.sha, + branch: branch + }; + return _this4._request('DELETE', '/repos/' + _this4.__fullname + '/contents/' + path, deleteCommit, cb); + }); + } + + /** + * Change all references in a repo from oldPath to new_path + * @param {string} branch - the branch to carry out the reference change, or the default branch if not specified + * @param {string} oldPath - original path + * @param {string} newPath - new reference path + * @param {Requestable.callback} cb - will receive the commit in which the move occurred + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'move', + value: function move(branch, oldPath, newPath, cb) { + var _this5 = this; + + var oldSha = void 0; + return this.getRef('heads/' + branch).then(function (_ref) { + var object = _ref.data.object; + return _this5.getTree(object.sha + '?recursive=true'); + }).then(function (_ref2) { + var _ref2$data = _ref2.data, + tree = _ref2$data.tree, + sha = _ref2$data.sha; + + oldSha = sha; + var newTree = tree.map(function (ref) { + if (ref.path === oldPath) { + ref.path = newPath; + } + if (ref.type === 'tree') { + delete ref.sha; + } + return ref; + }); + return _this5.createTree(newTree); + }).then(function (_ref3) { + var tree = _ref3.data; + return _this5.commit(oldSha, tree.sha, 'Renamed \'' + oldPath + '\' to \'' + newPath + '\''); + }).then(function (_ref4) { + var commit = _ref4.data; + return _this5.updateHead('heads/' + branch, commit.sha, true, cb); + }); + } + + /** + * Write a file to the repository + * @see https://developer.github.com/v3/repos/contents/#update-a-file + * @param {string} branch - the name of the branch + * @param {string} path - the path for the file + * @param {string} content - the contents of the file + * @param {string} message - the commit message + * @param {Object} [options] - commit options + * @param {Object} [options.author] - the author of the commit + * @param {Object} [options.commiter] - the committer + * @param {boolean} [options.encode] - true if the content should be base64 encoded + * @param {Requestable.callback} cb - will receive the new commit + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'writeFile', + value: function writeFile(branch, path, content, message, options, cb) { + var _this6 = this; + + if (typeof options === 'function') { + cb = options; + options = {}; + } + var filePath = path ? encodeURI(path) : ''; + var shouldEncode = options.encode !== false; + var commit = { + branch: branch, + message: message, + author: options.author, + committer: options.committer, + content: shouldEncode ? _jsBase.Base64.encode(content) : content + }; + + return this.getSha(branch, filePath).then(function (response) { + commit.sha = response.data.sha; + return _this6._request('PUT', '/repos/' + _this6.__fullname + '/contents/' + filePath, commit, cb); + }, function () { + return _this6._request('PUT', '/repos/' + _this6.__fullname + '/contents/' + filePath, commit, cb); + }); + } + + /** + * Check if a repository is starred by you + * @see https://developer.github.com/v3/activity/starring/#check-if-you-are-starring-a-repository + * @param {Requestable.callback} cb - will receive true if the repository is starred and false if the repository + * is not starred + * @return {Promise} - the promise for the http request {Boolean} [description] + */ + + }, { + key: 'isStarred', + value: function isStarred(cb) { + return this._request204or404('/user/starred/' + this.__fullname, null, cb); + } + + /** + * Star a repository + * @see https://developer.github.com/v3/activity/starring/#star-a-repository + * @param {Requestable.callback} cb - will receive true if the repository is starred + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'star', + value: function star(cb) { + return this._request('PUT', '/user/starred/' + this.__fullname, null, cb); + } + + /** + * Unstar a repository + * @see https://developer.github.com/v3/activity/starring/#unstar-a-repository + * @param {Requestable.callback} cb - will receive true if the repository is unstarred + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'unstar', + value: function unstar(cb) { + return this._request('DELETE', '/user/starred/' + this.__fullname, null, cb); + } + + /** + * Create a new release + * @see https://developer.github.com/v3/repos/releases/#create-a-release + * @param {Object} options - the description of the release + * @param {Requestable.callback} cb - will receive the newly created release + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'createRelease', + value: function createRelease(options, cb) { + return this._request('POST', '/repos/' + this.__fullname + '/releases', options, cb); + } + + /** + * Edit a release + * @see https://developer.github.com/v3/repos/releases/#edit-a-release + * @param {string} id - the id of the release + * @param {Object} options - the description of the release + * @param {Requestable.callback} cb - will receive the modified release + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'updateRelease', + value: function updateRelease(id, options, cb) { + return this._request('PATCH', '/repos/' + this.__fullname + '/releases/' + id, options, cb); + } + + /** + * Get information about all releases + * @see https://developer.github.com/v3/repos/releases/#list-releases-for-a-repository + * @param {Requestable.callback} cb - will receive the release information + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'listReleases', + value: function listReleases(cb) { + return this._request('GET', '/repos/' + this.__fullname + '/releases', null, cb); + } + + /** + * Get information about a release + * @see https://developer.github.com/v3/repos/releases/#get-a-single-release + * @param {string} id - the id of the release + * @param {Requestable.callback} cb - will receive the release information + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'getRelease', + value: function getRelease(id, cb) { + return this._request('GET', '/repos/' + this.__fullname + '/releases/' + id, null, cb); + } + + /** + * Delete a release + * @see https://developer.github.com/v3/repos/releases/#delete-a-release + * @param {string} id - the release to be deleted + * @param {Requestable.callback} cb - will receive true if the operation is successful + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'deleteRelease', + value: function deleteRelease(id, cb) { + return this._request('DELETE', '/repos/' + this.__fullname + '/releases/' + id, null, cb); + } + + /** + * Merge a pull request + * @see https://developer.github.com/v3/pulls/#merge-a-pull-request-merge-button + * @param {number|string} number - the number of the pull request to merge + * @param {Object} options - the merge options for the pull request + * @param {Requestable.callback} [cb] - will receive the merge information if the operation is successful + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'mergePullRequest', + value: function mergePullRequest(number, options, cb) { + return this._request('PUT', '/repos/' + this.__fullname + '/pulls/' + number + '/merge', options, cb); + } + + /** + * Get information about all projects + * @see https://developer.github.com/v3/projects/#list-repository-projects + * @param {Requestable.callback} [cb] - will receive the list of projects + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'listProjects', + value: function listProjects(cb) { + return this._requestAllPages('/repos/' + this.__fullname + '/projects', { AcceptHeader: 'inertia-preview' }, cb); + } + + /** + * Create a new project + * @see https://developer.github.com/v3/projects/#create-a-repository-project + * @param {Object} options - the description of the project + * @param {Requestable.callback} cb - will receive the newly created project + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'createProject', + value: function createProject(options, cb) { + options = options || {}; + options.AcceptHeader = 'inertia-preview'; + return this._request('POST', '/repos/' + this.__fullname + '/projects', options, cb); + } + }]); + + return Repository; +}(_Requestable3.default); + +module.exports = Repository; + +}).call(this,require("buffer").Buffer) + +},{"./Requestable":9,"buffer":39,"debug":40,"js-base64":44,"utf8":47}],9:[function(require,module,exports){ +'use strict'; + +var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; + +var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); + +var _axios = require('axios'); + +var _axios2 = _interopRequireDefault(_axios); + +var _debug = require('debug'); + +var _debug2 = _interopRequireDefault(_debug); + +var _jsBase = require('js-base64'); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +function _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } } + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } + +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } /** + * @file + * @copyright 2016 Yahoo Inc. + * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}. + * Github.js is freely distributable. + */ + +var log = (0, _debug2.default)('github:request'); + +/** + * The error structure returned when a network call fails + */ + +var ResponseError = function (_Error) { + _inherits(ResponseError, _Error); + + /** + * Construct a new ResponseError + * @param {string} message - an message to return instead of the the default error message + * @param {string} path - the requested path + * @param {Object} response - the object returned by Axios + */ + function ResponseError(message, path, response) { + _classCallCheck(this, ResponseError); + + var _this = _possibleConstructorReturn(this, (ResponseError.__proto__ || Object.getPrototypeOf(ResponseError)).call(this, message)); + + _this.path = path; + _this.request = response.config; + _this.response = (response || {}).response || response; + _this.status = response.status; + return _this; + } + + return ResponseError; +}(Error); + +/** + * Requestable wraps the logic for making http requests to the API + */ + + +var Requestable = function () { + /** + * Either a username and password or an oauth token for Github + * @typedef {Object} Requestable.auth + * @prop {string} [username] - the Github username + * @prop {string} [password] - the user's password + * @prop {token} [token] - an OAuth token + */ + /** + * Initialize the http internals. + * @param {Requestable.auth} [auth] - the credentials to authenticate to Github. If auth is + * not provided request will be made unauthenticated + * @param {string} [apiBase=https://api.github.com] - the base Github API URL + * @param {string} [AcceptHeader=v3] - the accept header for the requests + */ + function Requestable(auth, apiBase, AcceptHeader) { + _classCallCheck(this, Requestable); + + this.__apiBase = apiBase || 'https://api.github.com'; + this.__auth = { + token: auth.token, + username: auth.username, + password: auth.password + }; + this.__AcceptHeader = AcceptHeader || 'v3'; + + if (auth.token) { + this.__authorizationHeader = 'token ' + auth.token; + } else if (auth.username && auth.password) { + this.__authorizationHeader = 'Basic ' + _jsBase.Base64.encode(auth.username + ':' + auth.password); + } + } + + /** + * Compute the URL to use to make a request. + * @private + * @param {string} path - either a URL relative to the API base or an absolute URL + * @return {string} - the URL to use + */ + + + _createClass(Requestable, [{ + key: '__getURL', + value: function __getURL(path) { + var url = path; + + if (path.indexOf('//') === -1) { + url = this.__apiBase + path; + } + + var newCacheBuster = 'timestamp=' + new Date().getTime(); + return url.replace(/(timestamp=\d+)/, newCacheBuster); + } + + /** + * Compute the headers required for an API request. + * @private + * @param {boolean} raw - if the request should be treated as JSON or as a raw request + * @param {string} AcceptHeader - the accept header for the request + * @return {Object} - the headers to use in the request + */ + + }, { + key: '__getRequestHeaders', + value: function __getRequestHeaders(raw, AcceptHeader) { + var headers = { + 'Content-Type': 'application/json;charset=UTF-8', + 'Accept': 'application/vnd.github.' + (AcceptHeader || this.__AcceptHeader) + }; + + if (raw) { + headers.Accept += '.raw'; + } + headers.Accept += '+json'; + + if (this.__authorizationHeader) { + headers.Authorization = this.__authorizationHeader; + } + + return headers; + } + + /** + * Sets the default options for API requests + * @protected + * @param {Object} [requestOptions={}] - the current options for the request + * @return {Object} - the options to pass to the request + */ + + }, { + key: '_getOptionsWithDefaults', + value: function _getOptionsWithDefaults() { + var requestOptions = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {}; + + if (!(requestOptions.visibility || requestOptions.affiliation)) { + requestOptions.type = requestOptions.type || 'all'; + } + requestOptions.sort = requestOptions.sort || 'updated'; + requestOptions.per_page = requestOptions.per_page || '100'; // eslint-disable-line + + return requestOptions; + } + + /** + * if a `Date` is passed to this function it will be converted to an ISO string + * @param {*} date - the object to attempt to cooerce into an ISO date string + * @return {string} - the ISO representation of `date` or whatever was passed in if it was not a date + */ + + }, { + key: '_dateToISO', + value: function _dateToISO(date) { + if (date && date instanceof Date) { + date = date.toISOString(); + } + + return date; + } + + /** + * A function that receives the result of the API request. + * @callback Requestable.callback + * @param {Requestable.Error} error - the error returned by the API or `null` + * @param {(Object|true)} result - the data returned by the API or `true` if the API returns `204 No Content` + * @param {Object} request - the raw {@linkcode https://github.com/mzabriskie/axios#response-schema Response} + */ + /** + * Make a request. + * @param {string} method - the method for the request (GET, PUT, POST, DELETE) + * @param {string} path - the path for the request + * @param {*} [data] - the data to send to the server. For HTTP methods that don't have a body the data + * will be sent as query parameters + * @param {Requestable.callback} [cb] - the callback for the request + * @param {boolean} [raw=false] - if the request should be sent as raw. If this is a falsy value then the + * request will be made as JSON + * @return {Promise} - the Promise for the http request + */ + + }, { + key: '_request', + value: function _request(method, path, data, cb, raw) { + var url = this.__getURL(path); + + var AcceptHeader = (data || {}).AcceptHeader; + if (AcceptHeader) { + delete data.AcceptHeader; + } + var headers = this.__getRequestHeaders(raw, AcceptHeader); + + var queryParams = {}; + + var shouldUseDataAsParams = data && (typeof data === 'undefined' ? 'undefined' : _typeof(data)) === 'object' && methodHasNoBody(method); + if (shouldUseDataAsParams) { + queryParams = data; + data = undefined; + } + + var config = { + url: url, + method: method, + headers: headers, + params: queryParams, + data: data, + responseType: raw ? 'text' : 'json' + }; + + log(config.method + ' to ' + config.url); + var requestPromise = (0, _axios2.default)(config).catch(callbackErrorOrThrow(cb, path)); + + if (cb) { + requestPromise.then(function (response) { + if (response.data && Object.keys(response.data).length > 0) { + // When data has results + cb(null, response.data, response); + } else if (config.method !== 'GET' && Object.keys(response.data).length < 1) { + // True when successful submit a request and receive a empty object + cb(null, response.status < 300, response); + } else { + cb(null, response.data, response); + } + }); + } + + return requestPromise; + } + + /** + * Make a request to an endpoint the returns 204 when true and 404 when false + * @param {string} path - the path to request + * @param {Object} data - any query parameters for the request + * @param {Requestable.callback} cb - the callback that will receive `true` or `false` + * @param {method} [method=GET] - HTTP Method to use + * @return {Promise} - the promise for the http request + */ + + }, { + key: '_request204or404', + value: function _request204or404(path, data, cb) { + var method = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 'GET'; + + return this._request(method, path, data).then(function success(response) { + if (cb) { + cb(null, true, response); + } + return true; + }, function failure(response) { + if (response.response.status === 404) { + if (cb) { + cb(null, false, response); + } + return false; + } + + if (cb) { + cb(response); + } + throw response; + }); + } + + /** + * Make a request and fetch all the available data. Github will paginate responses so for queries + * that might span multiple pages this method is preferred to {@link Requestable#request} + * @param {string} path - the path to request + * @param {Object} options - the query parameters to include + * @param {Requestable.callback} [cb] - the function to receive the data. The returned data will always be an array. + * @param {Object[]} results - the partial results. This argument is intended for interal use only. + * @return {Promise} - a promise which will resolve when all pages have been fetched + * @deprecated This will be folded into {@link Requestable#_request} in the 2.0 release. + */ + + }, { + key: '_requestAllPages', + value: function _requestAllPages(path, options, cb, results) { + var _this2 = this; + + results = results || []; + + return this._request('GET', path, options).then(function (response) { + var _results; + + var thisGroup = void 0; + if (response.data instanceof Array) { + thisGroup = response.data; + } else if (response.data.items instanceof Array) { + thisGroup = response.data.items; + } else { + var message = 'cannot figure out how to append ' + response.data + ' to the result set'; + throw new ResponseError(message, path, response); + } + (_results = results).push.apply(_results, _toConsumableArray(thisGroup)); + + var nextUrl = getNextPage(response.headers.link); + if (nextUrl && typeof options.page !== 'number') { + log('getting next page: ' + nextUrl); + return _this2._requestAllPages(nextUrl, options, cb, results); + } + + if (cb) { + cb(null, results, response); + } + + response.data = results; + return response; + }).catch(callbackErrorOrThrow(cb, path)); + } + }]); + + return Requestable; +}(); + +module.exports = Requestable; + +// ////////////////////////// // +// Private helper functions // +// ////////////////////////// // +var METHODS_WITH_NO_BODY = ['GET', 'HEAD', 'DELETE']; +function methodHasNoBody(method) { + return METHODS_WITH_NO_BODY.indexOf(method) !== -1; +} + +function getNextPage() { + var linksHeader = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : ''; + + var links = linksHeader.split(/\s*,\s*/); // splits and strips the urls + return links.reduce(function (nextUrl, link) { + if (link.search(/rel="next"/) !== -1) { + return (link.match(/<(.*)>/) || [])[1]; + } + + return nextUrl; + }, undefined); +} + +function callbackErrorOrThrow(cb, path) { + return function handler(object) { + var error = void 0; + if (object.hasOwnProperty('config')) { + var _object$response = object.response, + status = _object$response.status, + statusText = _object$response.statusText, + _object$config = object.config, + method = _object$config.method, + url = _object$config.url; + + var message = status + ' error making request ' + method + ' ' + url + ': "' + statusText + '"'; + error = new ResponseError(message, path, object); + log(message + ' ' + JSON.stringify(object.data)); + } else { + error = object; + } + if (cb) { + log('going to error callback'); + cb(error); + } else { + log('throwing error'); + throw error; + } + }; +} + +},{"axios":13,"debug":40,"js-base64":44}],10:[function(require,module,exports){ +'use strict'; + +var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); + +var _Requestable2 = require('./Requestable'); + +var _Requestable3 = _interopRequireDefault(_Requestable2); + +var _debug = require('debug'); + +var _debug2 = _interopRequireDefault(_debug); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } + +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } /** + * @file + * @copyright 2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc. + * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}. + * Github.js is freely distributable. + */ + +var log = (0, _debug2.default)('github:search'); + +/** + * Wrap the Search API + */ + +var Search = function (_Requestable) { + _inherits(Search, _Requestable); + + /** + * Create a Search + * @param {Object} defaults - defaults for the search + * @param {Requestable.auth} [auth] - information required to authenticate to Github + * @param {string} [apiBase=https://api.github.com] - the base Github API URL + */ + function Search(defaults, auth, apiBase) { + _classCallCheck(this, Search); + + var _this = _possibleConstructorReturn(this, (Search.__proto__ || Object.getPrototypeOf(Search)).call(this, auth, apiBase)); + + _this.__defaults = _this._getOptionsWithDefaults(defaults); + return _this; + } + + /** + * Available search options + * @see https://developer.github.com/v3/search/#parameters + * @typedef {Object} Search.Params + * @param {string} q - the query to make + * @param {string} sort - the sort field, one of `stars`, `forks`, or `updated`. + * Default is [best match](https://developer.github.com/v3/search/#ranking-search-results) + * @param {string} order - the ordering, either `asc` or `desc` + */ + /** + * Perform a search on the GitHub API + * @private + * @param {string} path - the scope of the search + * @param {Search.Params} [withOptions] - additional parameters for the search + * @param {Requestable.callback} [cb] - will receive the results of the search + * @return {Promise} - the promise for the http request + */ + + + _createClass(Search, [{ + key: '_search', + value: function _search(path) { + var _this2 = this; + + var withOptions = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; + var cb = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : undefined; + + var requestOptions = {}; + Object.keys(this.__defaults).forEach(function (prop) { + requestOptions[prop] = _this2.__defaults[prop]; + }); + Object.keys(withOptions).forEach(function (prop) { + requestOptions[prop] = withOptions[prop]; + }); + + log('searching ' + path + ' with options:', requestOptions); + return this._requestAllPages('/search/' + path, requestOptions, cb); + } + + /** + * Search for repositories + * @see https://developer.github.com/v3/search/#search-repositories + * @param {Search.Params} [options] - additional parameters for the search + * @param {Requestable.callback} [cb] - will receive the results of the search + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'forRepositories', + value: function forRepositories(options, cb) { + return this._search('repositories', options, cb); + } + + /** + * Search for code + * @see https://developer.github.com/v3/search/#search-code + * @param {Search.Params} [options] - additional parameters for the search + * @param {Requestable.callback} [cb] - will receive the results of the search + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'forCode', + value: function forCode(options, cb) { + return this._search('code', options, cb); + } + + /** + * Search for issues + * @see https://developer.github.com/v3/search/#search-issues + * @param {Search.Params} [options] - additional parameters for the search + * @param {Requestable.callback} [cb] - will receive the results of the search + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'forIssues', + value: function forIssues(options, cb) { + return this._search('issues', options, cb); + } + + /** + * Search for users + * @see https://developer.github.com/v3/search/#search-users + * @param {Search.Params} [options] - additional parameters for the search + * @param {Requestable.callback} [cb] - will receive the results of the search + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'forUsers', + value: function forUsers(options, cb) { + return this._search('users', options, cb); + } + }]); + + return Search; +}(_Requestable3.default); + +module.exports = Search; + +},{"./Requestable":9,"debug":40}],11:[function(require,module,exports){ +'use strict'; + +var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); + +var _Requestable2 = require('./Requestable'); + +var _Requestable3 = _interopRequireDefault(_Requestable2); + +var _debug = require('debug'); + +var _debug2 = _interopRequireDefault(_debug); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } + +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } /** + * @file + * @copyright 2016 Matt Smith (Development Seed) + * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}. + * Github.js is freely distributable. + */ + +var log = (0, _debug2.default)('github:team'); + +/** + * A Team allows scoping of API requests to a particular Github Organization Team. + */ + +var Team = function (_Requestable) { + _inherits(Team, _Requestable); + + /** + * Create a Team. + * @param {string} [teamId] - the id for the team + * @param {Requestable.auth} [auth] - information required to authenticate to Github + * @param {string} [apiBase=https://api.github.com] - the base Github API URL + */ + function Team(teamId, auth, apiBase) { + _classCallCheck(this, Team); + + var _this = _possibleConstructorReturn(this, (Team.__proto__ || Object.getPrototypeOf(Team)).call(this, auth, apiBase)); + + _this.__teamId = teamId; + return _this; + } + + /** + * Get Team information + * @see https://developer.github.com/v3/orgs/teams/#get-team + * @param {Requestable.callback} [cb] - will receive the team + * @return {Promise} - the promise for the http request + */ + + + _createClass(Team, [{ + key: 'getTeam', + value: function getTeam(cb) { + log('Fetching Team ' + this.__teamId); + return this._request('Get', '/teams/' + this.__teamId, undefined, cb); + } + + /** + * List the Team's repositories + * @see https://developer.github.com/v3/orgs/teams/#list-team-repos + * @param {Requestable.callback} [cb] - will receive the list of repositories + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'listRepos', + value: function listRepos(cb) { + log('Fetching repositories for Team ' + this.__teamId); + return this._requestAllPages('/teams/' + this.__teamId + '/repos', undefined, cb); + } + + /** + * Edit Team information + * @see https://developer.github.com/v3/orgs/teams/#edit-team + * @param {object} options - Parameters for team edit + * @param {string} options.name - The name of the team + * @param {string} [options.description] - Team description + * @param {string} [options.repo_names] - Repos to add the team to + * @param {string} [options.privacy=secret] - The level of privacy the team should have. Can be either one + * of: `secret`, or `closed` + * @param {Requestable.callback} [cb] - will receive the updated team + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'editTeam', + value: function editTeam(options, cb) { + log('Editing Team ' + this.__teamId); + return this._request('PATCH', '/teams/' + this.__teamId, options, cb); + } + + /** + * List the users who are members of the Team + * @see https://developer.github.com/v3/orgs/teams/#list-team-members + * @param {object} options - Parameters for listing team users + * @param {string} [options.role=all] - can be one of: `all`, `maintainer`, or `member` + * @param {Requestable.callback} [cb] - will receive the list of users + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'listMembers', + value: function listMembers(options, cb) { + log('Getting members of Team ' + this.__teamId); + return this._requestAllPages('/teams/' + this.__teamId + '/members', options, cb); + } + + /** + * Get Team membership status for a user + * @see https://developer.github.com/v3/orgs/teams/#get-team-membership + * @param {string} username - can be one of: `all`, `maintainer`, or `member` + * @param {Requestable.callback} [cb] - will receive the membership status of a user + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'getMembership', + value: function getMembership(username, cb) { + log('Getting membership of user ' + username + ' in Team ' + this.__teamId); + return this._request('GET', '/teams/' + this.__teamId + '/memberships/' + username, undefined, cb); + } + + /** + * Add a member to the Team + * @see https://developer.github.com/v3/orgs/teams/#add-team-membership + * @param {string} username - can be one of: `all`, `maintainer`, or `member` + * @param {object} options - Parameters for adding a team member + * @param {string} [options.role=member] - The role that this user should have in the team. Can be one + * of: `member`, or `maintainer` + * @param {Requestable.callback} [cb] - will receive the membership status of added user + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'addMembership', + value: function addMembership(username, options, cb) { + log('Adding user ' + username + ' to Team ' + this.__teamId); + return this._request('PUT', '/teams/' + this.__teamId + '/memberships/' + username, options, cb); + } + + /** + * Get repo management status for team + * @see https://developer.github.com/v3/orgs/teams/#remove-team-membership + * @param {string} owner - Organization name + * @param {string} repo - Repo name + * @param {Requestable.callback} [cb] - will receive the membership status of added user + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'isManagedRepo', + value: function isManagedRepo(owner, repo, cb) { + log('Getting repo management by Team ' + this.__teamId + ' for repo ' + owner + '/' + repo); + return this._request204or404('/teams/' + this.__teamId + '/repos/' + owner + '/' + repo, undefined, cb); + } + + /** + * Add or Update repo management status for team + * @see https://developer.github.com/v3/orgs/teams/#add-or-update-team-repository + * @param {string} owner - Organization name + * @param {string} repo - Repo name + * @param {object} options - Parameters for adding or updating repo management for the team + * @param {string} [options.permission] - The permission to grant the team on this repository. Can be one + * of: `pull`, `push`, or `admin` + * @param {Requestable.callback} [cb] - will receive the membership status of added user + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'manageRepo', + value: function manageRepo(owner, repo, options, cb) { + log('Adding or Updating repo management by Team ' + this.__teamId + ' for repo ' + owner + '/' + repo); + return this._request204or404('/teams/' + this.__teamId + '/repos/' + owner + '/' + repo, options, cb, 'PUT'); + } + + /** + * Remove repo management status for team + * @see https://developer.github.com/v3/orgs/teams/#remove-team-repository + * @param {string} owner - Organization name + * @param {string} repo - Repo name + * @param {Requestable.callback} [cb] - will receive the membership status of added user + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'unmanageRepo', + value: function unmanageRepo(owner, repo, cb) { + log('Remove repo management by Team ' + this.__teamId + ' for repo ' + owner + '/' + repo); + return this._request204or404('/teams/' + this.__teamId + '/repos/' + owner + '/' + repo, undefined, cb, 'DELETE'); + } + + /** + * Delete Team + * @see https://developer.github.com/v3/orgs/teams/#delete-team + * @param {Requestable.callback} [cb] - will receive the list of repositories + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'deleteTeam', + value: function deleteTeam(cb) { + log('Deleting Team ' + this.__teamId); + return this._request204or404('/teams/' + this.__teamId, undefined, cb, 'DELETE'); + } + }]); + + return Team; +}(_Requestable3.default); + +module.exports = Team; + +},{"./Requestable":9,"debug":40}],12:[function(require,module,exports){ +'use strict'; + +var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); + +var _Requestable2 = require('./Requestable'); + +var _Requestable3 = _interopRequireDefault(_Requestable2); + +var _debug = require('debug'); + +var _debug2 = _interopRequireDefault(_debug); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } + +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } /** + * @file + * @copyright 2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc. + * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}. + * Github.js is freely distributable. + */ + +var log = (0, _debug2.default)('github:user'); + +/** + * A User allows scoping of API requests to a particular Github user. + */ + +var User = function (_Requestable) { + _inherits(User, _Requestable); + + /** + * Create a User. + * @param {string} [username] - the user to use for user-scoped queries + * @param {Requestable.auth} [auth] - information required to authenticate to Github + * @param {string} [apiBase=https://api.github.com] - the base Github API URL + */ + function User(username, auth, apiBase) { + _classCallCheck(this, User); + + var _this = _possibleConstructorReturn(this, (User.__proto__ || Object.getPrototypeOf(User)).call(this, auth, apiBase)); + + _this.__user = username; + return _this; + } + + /** + * Get the url for the request. (dependent on if we're requesting for the authenticated user or not) + * @private + * @param {string} endpoint - the endpoint being requested + * @return {string} - the resolved endpoint + */ + + + _createClass(User, [{ + key: '__getScopedUrl', + value: function __getScopedUrl(endpoint) { + if (this.__user) { + return endpoint ? '/users/' + this.__user + '/' + endpoint : '/users/' + this.__user; + } else { + // eslint-disable-line + switch (endpoint) { + case '': + return '/user'; + + case 'notifications': + case 'gists': + return '/' + endpoint; + + default: + return '/user/' + endpoint; + } + } + } + + /** + * List the user's repositories + * @see https://developer.github.com/v3/repos/#list-user-repositories + * @param {Object} [options={}] - any options to refine the search + * @param {Requestable.callback} [cb] - will receive the list of repositories + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'listRepos', + value: function listRepos(options, cb) { + if (typeof options === 'function') { + cb = options; + options = {}; + } + + options = this._getOptionsWithDefaults(options); + + log('Fetching repositories with options: ' + JSON.stringify(options)); + return this._requestAllPages(this.__getScopedUrl('repos'), options, cb); + } + + /** + * List the orgs that the user belongs to + * @see https://developer.github.com/v3/orgs/#list-user-organizations + * @param {Requestable.callback} [cb] - will receive the list of organizations + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'listOrgs', + value: function listOrgs(cb) { + return this._request('GET', this.__getScopedUrl('orgs'), null, cb); + } + + /** + * List the user's gists + * @see https://developer.github.com/v3/gists/#list-a-users-gists + * @param {Requestable.callback} [cb] - will receive the list of gists + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'listGists', + value: function listGists(cb) { + return this._request('GET', this.__getScopedUrl('gists'), null, cb); + } + + /** + * List the user's starred gists + * @see https://developer.github.com/v3/gists/#list-starred-gists + * @param {Requestable.callback} [cb] - will receive the list of gists + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'listStarredGists', + value: function listStarredGists(cb) { + return this._request('GET', this.__getScopedUrl('gists/starred'), null, cb); + } + + /** + * List the user's gists + * @see https://developer.github.com/v3/gists/#list-a-users-gists + * @param {Requestable.callback} [cb] - will receive the list of gists + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'listStarredGists', + value: function listStarredGists(cb) { + return this._request('GET', this.__getScopedUrl('gists'), null, cb); + } + + /** + * List the user's notifications + * @see https://developer.github.com/v3/activity/notifications/#list-your-notifications + * @param {Object} [options={}] - any options to refine the search + * @param {Requestable.callback} [cb] - will receive the list of repositories + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'listNotifications', + value: function listNotifications(options, cb) { + options = options || {}; + if (typeof options === 'function') { + cb = options; + options = {}; + } + + options.since = this._dateToISO(options.since); + options.before = this._dateToISO(options.before); + + return this._request('GET', this.__getScopedUrl('notifications'), options, cb); + } + + /** + * Show the user's profile + * @see https://developer.github.com/v3/users/#get-a-single-user + * @param {Requestable.callback} [cb] - will receive the user's information + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'getProfile', + value: function getProfile(cb) { + return this._request('GET', this.__getScopedUrl(''), null, cb); + } + + /** + * Gets the list of starred repositories for the user + * @see https://developer.github.com/v3/activity/starring/#list-repositories-being-starred + * @param {Requestable.callback} [cb] - will receive the list of starred repositories + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'listStarredRepos', + value: function listStarredRepos(cb) { + var requestOptions = this._getOptionsWithDefaults(); + return this._requestAllPages(this.__getScopedUrl('starred'), requestOptions, cb); + } + + /** + * List email addresses for a user + * @see https://developer.github.com/v3/users/emails/#list-email-addresses-for-a-user + * @param {Requestable.callback} [cb] - will receive the list of emails + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'getEmails', + value: function getEmails(cb) { + return this._request('GET', '/user/emails', null, cb); + } + + /** + * Have the authenticated user follow this user + * @see https://developer.github.com/v3/users/followers/#follow-a-user + * @param {string} username - the user to follow + * @param {Requestable.callback} [cb] - will receive true if the request succeeds + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'follow', + value: function follow(username, cb) { + return this._request('PUT', '/user/following/' + this.__user, null, cb); + } + + /** + * Have the currently authenticated user unfollow this user + * @see https://developer.github.com/v3/users/followers/#follow-a-user + * @param {string} username - the user to unfollow + * @param {Requestable.callback} [cb] - receives true if the request succeeds + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'unfollow', + value: function unfollow(username, cb) { + return this._request('DELETE', '/user/following/' + this.__user, null, cb); + } + + /** + * Create a new repository for the currently authenticated user + * @see https://developer.github.com/v3/repos/#create + * @param {object} options - the repository definition + * @param {Requestable.callback} [cb] - will receive the API response + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'createRepo', + value: function createRepo(options, cb) { + return this._request('POST', '/user/repos', options, cb); + } + }]); + + return User; +}(_Requestable3.default); + +module.exports = User; + +},{"./Requestable":9,"debug":40}],13:[function(require,module,exports){ +module.exports = require('./lib/axios'); +},{"./lib/axios":15}],14:[function(require,module,exports){ +(function (process){ +'use strict'; + +var utils = require('./../utils'); +var settle = require('./../core/settle'); +var buildURL = require('./../helpers/buildURL'); +var parseHeaders = require('./../helpers/parseHeaders'); +var isURLSameOrigin = require('./../helpers/isURLSameOrigin'); +var createError = require('../core/createError'); +var btoa = (typeof window !== 'undefined' && window.btoa && window.btoa.bind(window)) || require('./../helpers/btoa'); + +module.exports = function xhrAdapter(config) { + return new Promise(function dispatchXhrRequest(resolve, reject) { + var requestData = config.data; + var requestHeaders = config.headers; + + if (utils.isFormData(requestData)) { + delete requestHeaders['Content-Type']; // Let the browser set it + } + + var request = new XMLHttpRequest(); + var loadEvent = 'onreadystatechange'; + var xDomain = false; + + // For IE 8/9 CORS support + // Only supports POST and GET calls and doesn't returns the response headers. + // DON'T do this for testing b/c XMLHttpRequest is mocked, not XDomainRequest. + if (process.env.NODE_ENV !== 'test' && + typeof window !== 'undefined' && + window.XDomainRequest && !('withCredentials' in request) && + !isURLSameOrigin(config.url)) { + request = new window.XDomainRequest(); + loadEvent = 'onload'; + xDomain = true; + request.onprogress = function handleProgress() {}; + request.ontimeout = function handleTimeout() {}; + } + + // HTTP basic authentication + if (config.auth) { + var username = config.auth.username || ''; + var password = config.auth.password || ''; + requestHeaders.Authorization = 'Basic ' + btoa(username + ':' + password); + } + + request.open(config.method.toUpperCase(), buildURL(config.url, config.params, config.paramsSerializer), true); + + // Set the request timeout in MS + request.timeout = config.timeout; + + // Listen for ready state + request[loadEvent] = function handleLoad() { + if (!request || (request.readyState !== 4 && !xDomain)) { + return; + } + + // The request errored out and we didn't get a response, this will be + // handled by onerror instead + // With one exception: request that using file: protocol, most browsers + // will return status as 0 even though it's a successful request + if (request.status === 0 && !(request.responseURL && request.responseURL.indexOf('file:') === 0)) { + return; + } + + // Prepare the response + var responseHeaders = 'getAllResponseHeaders' in request ? parseHeaders(request.getAllResponseHeaders()) : null; + var responseData = !config.responseType || config.responseType === 'text' ? request.responseText : request.response; + var response = { + data: responseData, + // IE sends 1223 instead of 204 (https://github.com/mzabriskie/axios/issues/201) + status: request.status === 1223 ? 204 : request.status, + statusText: request.status === 1223 ? 'No Content' : request.statusText, + headers: responseHeaders, + config: config, + request: request + }; + + settle(resolve, reject, response); + + // Clean up request + request = null; + }; + + // Handle low level network errors + request.onerror = function handleError() { + // Real errors are hidden from us by the browser + // onerror should only fire if it's a network error + reject(createError('Network Error', config)); + + // Clean up request + request = null; + }; + + // Handle timeout + request.ontimeout = function handleTimeout() { + reject(createError('timeout of ' + config.timeout + 'ms exceeded', config, 'ECONNABORTED')); + + // Clean up request + request = null; + }; + + // Add xsrf header + // This is only done if running in a standard browser environment. + // Specifically not if we're in a web worker, or react-native. + if (utils.isStandardBrowserEnv()) { + var cookies = require('./../helpers/cookies'); + + // Add xsrf header + var xsrfValue = (config.withCredentials || isURLSameOrigin(config.url)) && config.xsrfCookieName ? + cookies.read(config.xsrfCookieName) : + undefined; + + if (xsrfValue) { + requestHeaders[config.xsrfHeaderName] = xsrfValue; + } + } + + // Add headers to the request + if ('setRequestHeader' in request) { + utils.forEach(requestHeaders, function setRequestHeader(val, key) { + if (typeof requestData === 'undefined' && key.toLowerCase() === 'content-type') { + // Remove Content-Type if data is undefined + delete requestHeaders[key]; + } else { + // Otherwise add header to the request + request.setRequestHeader(key, val); + } + }); + } + + // Add withCredentials to request if needed + if (config.withCredentials) { + request.withCredentials = true; + } + + // Add responseType to request if needed + if (config.responseType) { + try { + request.responseType = config.responseType; + } catch (e) { + if (request.responseType !== 'json') { + throw e; + } + } + } + + // Handle progress if needed + if (typeof config.onDownloadProgress === 'function') { + request.addEventListener('progress', config.onDownloadProgress); + } + + // Not all browsers support upload events + if (typeof config.onUploadProgress === 'function' && request.upload) { + request.upload.addEventListener('progress', config.onUploadProgress); + } + + if (config.cancelToken) { + // Handle cancellation + config.cancelToken.promise.then(function onCanceled(cancel) { + if (!request) { + return; + } + + request.abort(); + reject(cancel); + // Clean up request + request = null; + }); + } + + if (requestData === undefined) { + requestData = null; + } + + // Send the request + request.send(requestData); + }); +}; + +}).call(this,require('_process')) + +},{"../core/createError":21,"./../core/settle":24,"./../helpers/btoa":28,"./../helpers/buildURL":29,"./../helpers/cookies":31,"./../helpers/isURLSameOrigin":33,"./../helpers/parseHeaders":35,"./../utils":37,"_process":46}],15:[function(require,module,exports){ +'use strict'; + +var utils = require('./utils'); +var bind = require('./helpers/bind'); +var Axios = require('./core/Axios'); +var defaults = require('./defaults'); + +/** + * Create an instance of Axios + * + * @param {Object} defaultConfig The default config for the instance + * @return {Axios} A new instance of Axios + */ +function createInstance(defaultConfig) { + var context = new Axios(defaultConfig); + var instance = bind(Axios.prototype.request, context); + + // Copy axios.prototype to instance + utils.extend(instance, Axios.prototype, context); + + // Copy context to instance + utils.extend(instance, context); + + return instance; +} + +// Create the default instance to be exported +var axios = createInstance(defaults); + +// Expose Axios class to allow class inheritance +axios.Axios = Axios; + +// Factory for creating new instances +axios.create = function create(instanceConfig) { + return createInstance(utils.merge(defaults, instanceConfig)); +}; + +// Expose Cancel & CancelToken +axios.Cancel = require('./cancel/Cancel'); +axios.CancelToken = require('./cancel/CancelToken'); +axios.isCancel = require('./cancel/isCancel'); + +// Expose all/spread +axios.all = function all(promises) { + return Promise.all(promises); +}; +axios.spread = require('./helpers/spread'); + +module.exports = axios; + +// Allow use of default import syntax in TypeScript +module.exports.default = axios; + +},{"./cancel/Cancel":16,"./cancel/CancelToken":17,"./cancel/isCancel":18,"./core/Axios":19,"./defaults":26,"./helpers/bind":27,"./helpers/spread":36,"./utils":37}],16:[function(require,module,exports){ +'use strict'; + +/** + * A `Cancel` is an object that is thrown when an operation is canceled. + * + * @class + * @param {string=} message The message. + */ +function Cancel(message) { + this.message = message; +} + +Cancel.prototype.toString = function toString() { + return 'Cancel' + (this.message ? ': ' + this.message : ''); +}; + +Cancel.prototype.__CANCEL__ = true; + +module.exports = Cancel; + +},{}],17:[function(require,module,exports){ +'use strict'; + +var Cancel = require('./Cancel'); + +/** + * A `CancelToken` is an object that can be used to request cancellation of an operation. + * + * @class + * @param {Function} executor The executor function. + */ +function CancelToken(executor) { + if (typeof executor !== 'function') { + throw new TypeError('executor must be a function.'); + } + + var resolvePromise; + this.promise = new Promise(function promiseExecutor(resolve) { + resolvePromise = resolve; + }); + + var token = this; + executor(function cancel(message) { + if (token.reason) { + // Cancellation has already been requested + return; + } + + token.reason = new Cancel(message); + resolvePromise(token.reason); + }); +} + +/** + * Throws a `Cancel` if cancellation has been requested. + */ +CancelToken.prototype.throwIfRequested = function throwIfRequested() { + if (this.reason) { + throw this.reason; + } +}; + +/** + * Returns an object that contains a new `CancelToken` and a function that, when called, + * cancels the `CancelToken`. + */ +CancelToken.source = function source() { + var cancel; + var token = new CancelToken(function executor(c) { + cancel = c; + }); + return { + token: token, + cancel: cancel + }; +}; + +module.exports = CancelToken; + +},{"./Cancel":16}],18:[function(require,module,exports){ +'use strict'; + +module.exports = function isCancel(value) { + return !!(value && value.__CANCEL__); +}; + +},{}],19:[function(require,module,exports){ +'use strict'; + +var defaults = require('./../defaults'); +var utils = require('./../utils'); +var InterceptorManager = require('./InterceptorManager'); +var dispatchRequest = require('./dispatchRequest'); +var isAbsoluteURL = require('./../helpers/isAbsoluteURL'); +var combineURLs = require('./../helpers/combineURLs'); + +/** + * Create a new instance of Axios + * + * @param {Object} instanceConfig The default config for the instance + */ +function Axios(instanceConfig) { + this.defaults = instanceConfig; + this.interceptors = { + request: new InterceptorManager(), + response: new InterceptorManager() + }; +} + +/** + * Dispatch a request + * + * @param {Object} config The config specific for this request (merged with this.defaults) + */ +Axios.prototype.request = function request(config) { + /*eslint no-param-reassign:0*/ + // Allow for axios('example/url'[, config]) a la fetch API + if (typeof config === 'string') { + config = utils.merge({ + url: arguments[0] + }, arguments[1]); + } + + config = utils.merge(defaults, this.defaults, { method: 'get' }, config); + + // Support baseURL config + if (config.baseURL && !isAbsoluteURL(config.url)) { + config.url = combineURLs(config.baseURL, config.url); + } + + // Hook up interceptors middleware + var chain = [dispatchRequest, undefined]; + var promise = Promise.resolve(config); + + this.interceptors.request.forEach(function unshiftRequestInterceptors(interceptor) { + chain.unshift(interceptor.fulfilled, interceptor.rejected); + }); + + this.interceptors.response.forEach(function pushResponseInterceptors(interceptor) { + chain.push(interceptor.fulfilled, interceptor.rejected); + }); + + while (chain.length) { + promise = promise.then(chain.shift(), chain.shift()); + } + + return promise; +}; + +// Provide aliases for supported request methods +utils.forEach(['delete', 'get', 'head'], function forEachMethodNoData(method) { + /*eslint func-names:0*/ + Axios.prototype[method] = function(url, config) { + return this.request(utils.merge(config || {}, { + method: method, + url: url + })); + }; +}); + +utils.forEach(['post', 'put', 'patch'], function forEachMethodWithData(method) { + /*eslint func-names:0*/ + Axios.prototype[method] = function(url, data, config) { + return this.request(utils.merge(config || {}, { + method: method, + url: url, + data: data + })); + }; +}); + +module.exports = Axios; + +},{"./../defaults":26,"./../helpers/combineURLs":30,"./../helpers/isAbsoluteURL":32,"./../utils":37,"./InterceptorManager":20,"./dispatchRequest":22}],20:[function(require,module,exports){ +'use strict'; + +var utils = require('./../utils'); + +function InterceptorManager() { + this.handlers = []; +} + +/** + * Add a new interceptor to the stack + * + * @param {Function} fulfilled The function to handle `then` for a `Promise` + * @param {Function} rejected The function to handle `reject` for a `Promise` + * + * @return {Number} An ID used to remove interceptor later + */ +InterceptorManager.prototype.use = function use(fulfilled, rejected) { + this.handlers.push({ + fulfilled: fulfilled, + rejected: rejected + }); + return this.handlers.length - 1; +}; + +/** + * Remove an interceptor from the stack + * + * @param {Number} id The ID that was returned by `use` + */ +InterceptorManager.prototype.eject = function eject(id) { + if (this.handlers[id]) { + this.handlers[id] = null; + } +}; + +/** + * Iterate over all the registered interceptors + * + * This method is particularly useful for skipping over any + * interceptors that may have become `null` calling `eject`. + * + * @param {Function} fn The function to call for each interceptor + */ +InterceptorManager.prototype.forEach = function forEach(fn) { + utils.forEach(this.handlers, function forEachHandler(h) { + if (h !== null) { + fn(h); + } + }); +}; + +module.exports = InterceptorManager; + +},{"./../utils":37}],21:[function(require,module,exports){ +'use strict'; + +var enhanceError = require('./enhanceError'); + +/** + * Create an Error with the specified message, config, error code, and response. + * + * @param {string} message The error message. + * @param {Object} config The config. + * @param {string} [code] The error code (for example, 'ECONNABORTED'). + @ @param {Object} [response] The response. + * @returns {Error} The created error. + */ +module.exports = function createError(message, config, code, response) { + var error = new Error(message); + return enhanceError(error, config, code, response); +}; + +},{"./enhanceError":23}],22:[function(require,module,exports){ +'use strict'; + +var utils = require('./../utils'); +var transformData = require('./transformData'); +var isCancel = require('../cancel/isCancel'); +var defaults = require('../defaults'); + +/** + * Throws a `Cancel` if cancellation has been requested. + */ +function throwIfCancellationRequested(config) { + if (config.cancelToken) { + config.cancelToken.throwIfRequested(); + } +} + +/** + * Dispatch a request to the server using the configured adapter. + * + * @param {object} config The config that is to be used for the request + * @returns {Promise} The Promise to be fulfilled + */ +module.exports = function dispatchRequest(config) { + throwIfCancellationRequested(config); + + // Ensure headers exist + config.headers = config.headers || {}; + + // Transform request data + config.data = transformData( + config.data, + config.headers, + config.transformRequest + ); + + // Flatten headers + config.headers = utils.merge( + config.headers.common || {}, + config.headers[config.method] || {}, + config.headers || {} + ); + + utils.forEach( + ['delete', 'get', 'head', 'post', 'put', 'patch', 'common'], + function cleanHeaderConfig(method) { + delete config.headers[method]; + } + ); + + var adapter = config.adapter || defaults.adapter; + + return adapter(config).then(function onAdapterResolution(response) { + throwIfCancellationRequested(config); + + // Transform response data + response.data = transformData( + response.data, + response.headers, + config.transformResponse + ); + + return response; + }, function onAdapterRejection(reason) { + if (!isCancel(reason)) { + throwIfCancellationRequested(config); + + // Transform response data + if (reason && reason.response) { + reason.response.data = transformData( + reason.response.data, + reason.response.headers, + config.transformResponse + ); + } + } + + return Promise.reject(reason); + }); +}; + +},{"../cancel/isCancel":18,"../defaults":26,"./../utils":37,"./transformData":25}],23:[function(require,module,exports){ +'use strict'; + +/** + * Update an Error with the specified config, error code, and response. + * + * @param {Error} error The error to update. + * @param {Object} config The config. + * @param {string} [code] The error code (for example, 'ECONNABORTED'). + @ @param {Object} [response] The response. + * @returns {Error} The error. + */ +module.exports = function enhanceError(error, config, code, response) { + error.config = config; + if (code) { + error.code = code; + } + error.response = response; + return error; +}; + +},{}],24:[function(require,module,exports){ +'use strict'; + +var createError = require('./createError'); + +/** + * Resolve or reject a Promise based on response status. + * + * @param {Function} resolve A function that resolves the promise. + * @param {Function} reject A function that rejects the promise. + * @param {object} response The response. + */ +module.exports = function settle(resolve, reject, response) { + var validateStatus = response.config.validateStatus; + // Note: status is not exposed by XDomainRequest + if (!response.status || !validateStatus || validateStatus(response.status)) { + resolve(response); + } else { + reject(createError( + 'Request failed with status code ' + response.status, + response.config, + null, + response + )); + } +}; + +},{"./createError":21}],25:[function(require,module,exports){ +'use strict'; + +var utils = require('./../utils'); + +/** + * Transform the data for a request or a response + * + * @param {Object|String} data The data to be transformed + * @param {Array} headers The headers for the request or response + * @param {Array|Function} fns A single function or Array of functions + * @returns {*} The resulting transformed data + */ +module.exports = function transformData(data, headers, fns) { + /*eslint no-param-reassign:0*/ + utils.forEach(fns, function transform(fn) { + data = fn(data, headers); + }); + + return data; +}; + +},{"./../utils":37}],26:[function(require,module,exports){ +(function (process){ +'use strict'; + +var utils = require('./utils'); +var normalizeHeaderName = require('./helpers/normalizeHeaderName'); + +var PROTECTION_PREFIX = /^\)\]\}',?\n/; +var DEFAULT_CONTENT_TYPE = { + 'Content-Type': 'application/x-www-form-urlencoded' +}; + +function setContentTypeIfUnset(headers, value) { + if (!utils.isUndefined(headers) && utils.isUndefined(headers['Content-Type'])) { + headers['Content-Type'] = value; + } +} + +function getDefaultAdapter() { + var adapter; + if (typeof XMLHttpRequest !== 'undefined') { + // For browsers use XHR adapter + adapter = require('./adapters/xhr'); + } else if (typeof process !== 'undefined') { + // For node use HTTP adapter + adapter = require('./adapters/http'); + } + return adapter; +} + +var defaults = { + adapter: getDefaultAdapter(), + + transformRequest: [function transformRequest(data, headers) { + normalizeHeaderName(headers, 'Content-Type'); + if (utils.isFormData(data) || + utils.isArrayBuffer(data) || + utils.isStream(data) || + utils.isFile(data) || + utils.isBlob(data) + ) { + return data; + } + if (utils.isArrayBufferView(data)) { + return data.buffer; + } + if (utils.isURLSearchParams(data)) { + setContentTypeIfUnset(headers, 'application/x-www-form-urlencoded;charset=utf-8'); + return data.toString(); + } + if (utils.isObject(data)) { + setContentTypeIfUnset(headers, 'application/json;charset=utf-8'); + return JSON.stringify(data); + } + return data; + }], + + transformResponse: [function transformResponse(data) { + /*eslint no-param-reassign:0*/ + if (typeof data === 'string') { + data = data.replace(PROTECTION_PREFIX, ''); + try { + data = JSON.parse(data); + } catch (e) { /* Ignore */ } + } + return data; + }], + + timeout: 0, + + xsrfCookieName: 'XSRF-TOKEN', + xsrfHeaderName: 'X-XSRF-TOKEN', + + maxContentLength: -1, + + validateStatus: function validateStatus(status) { + return status >= 200 && status < 300; + } +}; + +defaults.headers = { + common: { + 'Accept': 'application/json, text/plain, */*' + } +}; + +utils.forEach(['delete', 'get', 'head'], function forEachMehtodNoData(method) { + defaults.headers[method] = {}; +}); + +utils.forEach(['post', 'put', 'patch'], function forEachMethodWithData(method) { + defaults.headers[method] = utils.merge(DEFAULT_CONTENT_TYPE); +}); + +module.exports = defaults; + +}).call(this,require('_process')) + +},{"./adapters/http":14,"./adapters/xhr":14,"./helpers/normalizeHeaderName":34,"./utils":37,"_process":46}],27:[function(require,module,exports){ +'use strict'; + +module.exports = function bind(fn, thisArg) { + return function wrap() { + var args = new Array(arguments.length); + for (var i = 0; i < args.length; i++) { + args[i] = arguments[i]; + } + return fn.apply(thisArg, args); + }; +}; + +},{}],28:[function(require,module,exports){ +'use strict'; + +// btoa polyfill for IE<10 courtesy https://github.com/davidchambers/Base64.js + +var chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/='; + +function E() { + this.message = 'String contains an invalid character'; +} +E.prototype = new Error; +E.prototype.code = 5; +E.prototype.name = 'InvalidCharacterError'; + +function btoa(input) { + var str = String(input); + var output = ''; + for ( + // initialize result and counter + var block, charCode, idx = 0, map = chars; + // if the next str index does not exist: + // change the mapping table to "=" + // check if d has no fractional digits + str.charAt(idx | 0) || (map = '=', idx % 1); + // "8 - idx % 1 * 8" generates the sequence 2, 4, 6, 8 + output += map.charAt(63 & block >> 8 - idx % 1 * 8) + ) { + charCode = str.charCodeAt(idx += 3 / 4); + if (charCode > 0xFF) { + throw new E(); + } + block = block << 8 | charCode; + } + return output; +} + +module.exports = btoa; + +},{}],29:[function(require,module,exports){ +'use strict'; + +var utils = require('./../utils'); + +function encode(val) { + return encodeURIComponent(val). + replace(/%40/gi, '@'). + replace(/%3A/gi, ':'). + replace(/%24/g, '$'). + replace(/%2C/gi, ','). + replace(/%20/g, '+'). + replace(/%5B/gi, '['). + replace(/%5D/gi, ']'); +} + +/** + * Build a URL by appending params to the end + * + * @param {string} url The base of the url (e.g., http://www.google.com) + * @param {object} [params] The params to be appended + * @returns {string} The formatted url + */ +module.exports = function buildURL(url, params, paramsSerializer) { + /*eslint no-param-reassign:0*/ + if (!params) { + return url; + } + + var serializedParams; + if (paramsSerializer) { + serializedParams = paramsSerializer(params); + } else if (utils.isURLSearchParams(params)) { + serializedParams = params.toString(); + } else { + var parts = []; + + utils.forEach(params, function serialize(val, key) { + if (val === null || typeof val === 'undefined') { + return; + } + + if (utils.isArray(val)) { + key = key + '[]'; + } + + if (!utils.isArray(val)) { + val = [val]; + } + + utils.forEach(val, function parseValue(v) { + if (utils.isDate(v)) { + v = v.toISOString(); + } else if (utils.isObject(v)) { + v = JSON.stringify(v); + } + parts.push(encode(key) + '=' + encode(v)); + }); + }); + + serializedParams = parts.join('&'); + } + + if (serializedParams) { + url += (url.indexOf('?') === -1 ? '?' : '&') + serializedParams; + } + + return url; +}; + +},{"./../utils":37}],30:[function(require,module,exports){ +'use strict'; + +/** + * Creates a new URL by combining the specified URLs + * + * @param {string} baseURL The base URL + * @param {string} relativeURL The relative URL + * @returns {string} The combined URL + */ +module.exports = function combineURLs(baseURL, relativeURL) { + return baseURL.replace(/\/+$/, '') + '/' + relativeURL.replace(/^\/+/, ''); +}; + +},{}],31:[function(require,module,exports){ +'use strict'; + +var utils = require('./../utils'); + +module.exports = ( + utils.isStandardBrowserEnv() ? + + // Standard browser envs support document.cookie + (function standardBrowserEnv() { + return { + write: function write(name, value, expires, path, domain, secure) { + var cookie = []; + cookie.push(name + '=' + encodeURIComponent(value)); + + if (utils.isNumber(expires)) { + cookie.push('expires=' + new Date(expires).toGMTString()); + } + + if (utils.isString(path)) { + cookie.push('path=' + path); + } + + if (utils.isString(domain)) { + cookie.push('domain=' + domain); + } + + if (secure === true) { + cookie.push('secure'); + } + + document.cookie = cookie.join('; '); + }, + + read: function read(name) { + var match = document.cookie.match(new RegExp('(^|;\\s*)(' + name + ')=([^;]*)')); + return (match ? decodeURIComponent(match[3]) : null); + }, + + remove: function remove(name) { + this.write(name, '', Date.now() - 86400000); + } + }; + })() : + + // Non standard browser env (web workers, react-native) lack needed support. + (function nonStandardBrowserEnv() { + return { + write: function write() {}, + read: function read() { return null; }, + remove: function remove() {} + }; + })() +); + +},{"./../utils":37}],32:[function(require,module,exports){ +'use strict'; + +/** + * Determines whether the specified URL is absolute + * + * @param {string} url The URL to test + * @returns {boolean} True if the specified URL is absolute, otherwise false + */ +module.exports = function isAbsoluteURL(url) { + // A URL is considered absolute if it begins with "://" or "//" (protocol-relative URL). + // RFC 3986 defines scheme name as a sequence of characters beginning with a letter and followed + // by any combination of letters, digits, plus, period, or hyphen. + return /^([a-z][a-z\d\+\-\.]*:)?\/\//i.test(url); +}; + +},{}],33:[function(require,module,exports){ +'use strict'; + +var utils = require('./../utils'); + +module.exports = ( + utils.isStandardBrowserEnv() ? + + // Standard browser envs have full support of the APIs needed to test + // whether the request URL is of the same origin as current location. + (function standardBrowserEnv() { + var msie = /(msie|trident)/i.test(navigator.userAgent); + var urlParsingNode = document.createElement('a'); + var originURL; + + /** + * Parse a URL to discover it's components + * + * @param {String} url The URL to be parsed + * @returns {Object} + */ + function resolveURL(url) { + var href = url; + + if (msie) { + // IE needs attribute set twice to normalize properties + urlParsingNode.setAttribute('href', href); + href = urlParsingNode.href; + } + + urlParsingNode.setAttribute('href', href); + + // urlParsingNode provides the UrlUtils interface - http://url.spec.whatwg.org/#urlutils + return { + href: urlParsingNode.href, + protocol: urlParsingNode.protocol ? urlParsingNode.protocol.replace(/:$/, '') : '', + host: urlParsingNode.host, + search: urlParsingNode.search ? urlParsingNode.search.replace(/^\?/, '') : '', + hash: urlParsingNode.hash ? urlParsingNode.hash.replace(/^#/, '') : '', + hostname: urlParsingNode.hostname, + port: urlParsingNode.port, + pathname: (urlParsingNode.pathname.charAt(0) === '/') ? + urlParsingNode.pathname : + '/' + urlParsingNode.pathname + }; + } + + originURL = resolveURL(window.location.href); + + /** + * Determine if a URL shares the same origin as the current location + * + * @param {String} requestURL The URL to test + * @returns {boolean} True if URL shares the same origin, otherwise false + */ + return function isURLSameOrigin(requestURL) { + var parsed = (utils.isString(requestURL)) ? resolveURL(requestURL) : requestURL; + return (parsed.protocol === originURL.protocol && + parsed.host === originURL.host); + }; + })() : + + // Non standard browser envs (web workers, react-native) lack needed support. + (function nonStandardBrowserEnv() { + return function isURLSameOrigin() { + return true; + }; + })() +); + +},{"./../utils":37}],34:[function(require,module,exports){ +'use strict'; + +var utils = require('../utils'); + +module.exports = function normalizeHeaderName(headers, normalizedName) { + utils.forEach(headers, function processHeader(value, name) { + if (name !== normalizedName && name.toUpperCase() === normalizedName.toUpperCase()) { + headers[normalizedName] = value; + delete headers[name]; + } + }); +}; + +},{"../utils":37}],35:[function(require,module,exports){ +'use strict'; + +var utils = require('./../utils'); + +/** + * Parse headers into an object + * + * ``` + * Date: Wed, 27 Aug 2014 08:58:49 GMT + * Content-Type: application/json + * Connection: keep-alive + * Transfer-Encoding: chunked + * ``` + * + * @param {String} headers Headers needing to be parsed + * @returns {Object} Headers parsed into an object + */ +module.exports = function parseHeaders(headers) { + var parsed = {}; + var key; + var val; + var i; + + if (!headers) { return parsed; } + + utils.forEach(headers.split('\n'), function parser(line) { + i = line.indexOf(':'); + key = utils.trim(line.substr(0, i)).toLowerCase(); + val = utils.trim(line.substr(i + 1)); + + if (key) { + parsed[key] = parsed[key] ? parsed[key] + ', ' + val : val; + } + }); + + return parsed; +}; + +},{"./../utils":37}],36:[function(require,module,exports){ +'use strict'; + +/** + * Syntactic sugar for invoking a function and expanding an array for arguments. + * + * Common use case would be to use `Function.prototype.apply`. + * + * ```js + * function f(x, y, z) {} + * var args = [1, 2, 3]; + * f.apply(null, args); + * ``` + * + * With `spread` this example can be re-written. + * + * ```js + * spread(function(x, y, z) {})([1, 2, 3]); + * ``` + * + * @param {Function} callback + * @returns {Function} + */ +module.exports = function spread(callback) { + return function wrap(arr) { + return callback.apply(null, arr); + }; +}; + +},{}],37:[function(require,module,exports){ +'use strict'; + +var bind = require('./helpers/bind'); + +/*global toString:true*/ + +// utils is a library of generic helper functions non-specific to axios + +var toString = Object.prototype.toString; + +/** + * Determine if a value is an Array + * + * @param {Object} val The value to test + * @returns {boolean} True if value is an Array, otherwise false + */ +function isArray(val) { + return toString.call(val) === '[object Array]'; +} + +/** + * Determine if a value is an ArrayBuffer + * + * @param {Object} val The value to test + * @returns {boolean} True if value is an ArrayBuffer, otherwise false + */ +function isArrayBuffer(val) { + return toString.call(val) === '[object ArrayBuffer]'; +} + +/** + * Determine if a value is a FormData + * + * @param {Object} val The value to test + * @returns {boolean} True if value is an FormData, otherwise false + */ +function isFormData(val) { + return (typeof FormData !== 'undefined') && (val instanceof FormData); +} + +/** + * Determine if a value is a view on an ArrayBuffer + * + * @param {Object} val The value to test + * @returns {boolean} True if value is a view on an ArrayBuffer, otherwise false + */ +function isArrayBufferView(val) { + var result; + if ((typeof ArrayBuffer !== 'undefined') && (ArrayBuffer.isView)) { + result = ArrayBuffer.isView(val); + } else { + result = (val) && (val.buffer) && (val.buffer instanceof ArrayBuffer); + } + return result; +} + +/** + * Determine if a value is a String + * + * @param {Object} val The value to test + * @returns {boolean} True if value is a String, otherwise false + */ +function isString(val) { + return typeof val === 'string'; +} + +/** + * Determine if a value is a Number + * + * @param {Object} val The value to test + * @returns {boolean} True if value is a Number, otherwise false + */ +function isNumber(val) { + return typeof val === 'number'; +} + +/** + * Determine if a value is undefined + * + * @param {Object} val The value to test + * @returns {boolean} True if the value is undefined, otherwise false + */ +function isUndefined(val) { + return typeof val === 'undefined'; +} + +/** + * Determine if a value is an Object + * + * @param {Object} val The value to test + * @returns {boolean} True if value is an Object, otherwise false + */ +function isObject(val) { + return val !== null && typeof val === 'object'; +} + +/** + * Determine if a value is a Date + * + * @param {Object} val The value to test + * @returns {boolean} True if value is a Date, otherwise false + */ +function isDate(val) { + return toString.call(val) === '[object Date]'; +} + +/** + * Determine if a value is a File + * + * @param {Object} val The value to test + * @returns {boolean} True if value is a File, otherwise false + */ +function isFile(val) { + return toString.call(val) === '[object File]'; +} + +/** + * Determine if a value is a Blob + * + * @param {Object} val The value to test + * @returns {boolean} True if value is a Blob, otherwise false + */ +function isBlob(val) { + return toString.call(val) === '[object Blob]'; +} + +/** + * Determine if a value is a Function + * + * @param {Object} val The value to test + * @returns {boolean} True if value is a Function, otherwise false + */ +function isFunction(val) { + return toString.call(val) === '[object Function]'; +} + +/** + * Determine if a value is a Stream + * + * @param {Object} val The value to test + * @returns {boolean} True if value is a Stream, otherwise false + */ +function isStream(val) { + return isObject(val) && isFunction(val.pipe); +} + +/** + * Determine if a value is a URLSearchParams object + * + * @param {Object} val The value to test + * @returns {boolean} True if value is a URLSearchParams object, otherwise false + */ +function isURLSearchParams(val) { + return typeof URLSearchParams !== 'undefined' && val instanceof URLSearchParams; +} + +/** + * Trim excess whitespace off the beginning and end of a string + * + * @param {String} str The String to trim + * @returns {String} The String freed of excess whitespace + */ +function trim(str) { + return str.replace(/^\s*/, '').replace(/\s*$/, ''); +} + +/** + * Determine if we're running in a standard browser environment + * + * This allows axios to run in a web worker, and react-native. + * Both environments support XMLHttpRequest, but not fully standard globals. + * + * web workers: + * typeof window -> undefined + * typeof document -> undefined + * + * react-native: + * typeof document.createElement -> undefined + */ +function isStandardBrowserEnv() { + return ( + typeof window !== 'undefined' && + typeof document !== 'undefined' && + typeof document.createElement === 'function' + ); +} + +/** + * Iterate over an Array or an Object invoking a function for each item. + * + * If `obj` is an Array callback will be called passing + * the value, index, and complete array for each item. + * + * If 'obj' is an Object callback will be called passing + * the value, key, and complete object for each property. + * + * @param {Object|Array} obj The object to iterate + * @param {Function} fn The callback to invoke for each item + */ +function forEach(obj, fn) { + // Don't bother if no value provided + if (obj === null || typeof obj === 'undefined') { + return; + } + + // Force an array if not already something iterable + if (typeof obj !== 'object' && !isArray(obj)) { + /*eslint no-param-reassign:0*/ + obj = [obj]; + } + + if (isArray(obj)) { + // Iterate over array values + for (var i = 0, l = obj.length; i < l; i++) { + fn.call(null, obj[i], i, obj); + } + } else { + // Iterate over object keys + for (var key in obj) { + if (Object.prototype.hasOwnProperty.call(obj, key)) { + fn.call(null, obj[key], key, obj); + } + } + } +} + +/** + * Accepts varargs expecting each argument to be an object, then + * immutably merges the properties of each object and returns result. + * + * When multiple objects contain the same key the later object in + * the arguments list will take precedence. + * + * Example: + * + * ```js + * var result = merge({foo: 123}, {foo: 456}); + * console.log(result.foo); // outputs 456 + * ``` + * + * @param {Object} obj1 Object to merge + * @returns {Object} Result of all merge properties + */ +function merge(/* obj1, obj2, obj3, ... */) { + var result = {}; + function assignValue(val, key) { + if (typeof result[key] === 'object' && typeof val === 'object') { + result[key] = merge(result[key], val); + } else { + result[key] = val; + } + } + + for (var i = 0, l = arguments.length; i < l; i++) { + forEach(arguments[i], assignValue); + } + return result; +} + +/** + * Extends object a by mutably adding to it the properties of object b. + * + * @param {Object} a The object to be extended + * @param {Object} b The object to copy properties from + * @param {Object} thisArg The object to bind function to + * @return {Object} The resulting value of object a + */ +function extend(a, b, thisArg) { + forEach(b, function assignValue(val, key) { + if (thisArg && typeof val === 'function') { + a[key] = bind(val, thisArg); + } else { + a[key] = val; + } + }); + return a; +} + +module.exports = { + isArray: isArray, + isArrayBuffer: isArrayBuffer, + isFormData: isFormData, + isArrayBufferView: isArrayBufferView, + isString: isString, + isNumber: isNumber, + isObject: isObject, + isUndefined: isUndefined, + isDate: isDate, + isFile: isFile, + isBlob: isBlob, + isFunction: isFunction, + isStream: isStream, + isURLSearchParams: isURLSearchParams, + isStandardBrowserEnv: isStandardBrowserEnv, + forEach: forEach, + merge: merge, + extend: extend, + trim: trim +}; + +},{"./helpers/bind":27}],38:[function(require,module,exports){ +'use strict' + +exports.byteLength = byteLength +exports.toByteArray = toByteArray +exports.fromByteArray = fromByteArray + +var lookup = [] +var revLookup = [] +var Arr = typeof Uint8Array !== 'undefined' ? Uint8Array : Array + +var code = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/' +for (var i = 0, len = code.length; i < len; ++i) { + lookup[i] = code[i] + revLookup[code.charCodeAt(i)] = i +} + +revLookup['-'.charCodeAt(0)] = 62 +revLookup['_'.charCodeAt(0)] = 63 + +function placeHoldersCount (b64) { + var len = b64.length + if (len % 4 > 0) { + throw new Error('Invalid string. Length must be a multiple of 4') + } + + // the number of equal signs (place holders) + // if there are two placeholders, than the two characters before it + // represent one byte + // if there is only one, then the three characters before it represent 2 bytes + // this is just a cheap hack to not do indexOf twice + return b64[len - 2] === '=' ? 2 : b64[len - 1] === '=' ? 1 : 0 +} + +function byteLength (b64) { + // base64 is 4/3 + up to two characters of the original data + return b64.length * 3 / 4 - placeHoldersCount(b64) +} + +function toByteArray (b64) { + var i, j, l, tmp, placeHolders, arr + var len = b64.length + placeHolders = placeHoldersCount(b64) + + arr = new Arr(len * 3 / 4 - placeHolders) + + // if there are placeholders, only get up to the last complete 4 chars + l = placeHolders > 0 ? len - 4 : len + + var L = 0 + + for (i = 0, j = 0; i < l; i += 4, j += 3) { + tmp = (revLookup[b64.charCodeAt(i)] << 18) | (revLookup[b64.charCodeAt(i + 1)] << 12) | (revLookup[b64.charCodeAt(i + 2)] << 6) | revLookup[b64.charCodeAt(i + 3)] + arr[L++] = (tmp >> 16) & 0xFF + arr[L++] = (tmp >> 8) & 0xFF + arr[L++] = tmp & 0xFF + } + + if (placeHolders === 2) { + tmp = (revLookup[b64.charCodeAt(i)] << 2) | (revLookup[b64.charCodeAt(i + 1)] >> 4) + arr[L++] = tmp & 0xFF + } else if (placeHolders === 1) { + tmp = (revLookup[b64.charCodeAt(i)] << 10) | (revLookup[b64.charCodeAt(i + 1)] << 4) | (revLookup[b64.charCodeAt(i + 2)] >> 2) + arr[L++] = (tmp >> 8) & 0xFF + arr[L++] = tmp & 0xFF + } + + return arr +} + +function tripletToBase64 (num) { + return lookup[num >> 18 & 0x3F] + lookup[num >> 12 & 0x3F] + lookup[num >> 6 & 0x3F] + lookup[num & 0x3F] +} + +function encodeChunk (uint8, start, end) { + var tmp + var output = [] + for (var i = start; i < end; i += 3) { + tmp = (uint8[i] << 16) + (uint8[i + 1] << 8) + (uint8[i + 2]) + output.push(tripletToBase64(tmp)) + } + return output.join('') +} + +function fromByteArray (uint8) { + var tmp + var len = uint8.length + var extraBytes = len % 3 // if we have 1 byte left, pad 2 bytes + var output = '' + var parts = [] + var maxChunkLength = 16383 // must be multiple of 3 + + // go through the array every three bytes, we'll deal with trailing stuff later + for (var i = 0, len2 = len - extraBytes; i < len2; i += maxChunkLength) { + parts.push(encodeChunk(uint8, i, (i + maxChunkLength) > len2 ? len2 : (i + maxChunkLength))) + } + + // pad the end with zeros, but make sure to not forget the extra bytes + if (extraBytes === 1) { + tmp = uint8[len - 1] + output += lookup[tmp >> 2] + output += lookup[(tmp << 4) & 0x3F] + output += '==' + } else if (extraBytes === 2) { + tmp = (uint8[len - 2] << 8) + (uint8[len - 1]) + output += lookup[tmp >> 10] + output += lookup[(tmp >> 4) & 0x3F] + output += lookup[(tmp << 2) & 0x3F] + output += '=' + } + + parts.push(output) + + return parts.join('') +} + +},{}],39:[function(require,module,exports){ +(function (global){ +/*! + * The buffer module from node.js, for the browser. + * + * @author Feross Aboukhadijeh + * @license MIT + */ +/* eslint-disable no-proto */ + +'use strict' + +var base64 = require('base64-js') +var ieee754 = require('ieee754') +var isArray = require('isarray') + +exports.Buffer = Buffer +exports.SlowBuffer = SlowBuffer +exports.INSPECT_MAX_BYTES = 50 + +/** + * If `Buffer.TYPED_ARRAY_SUPPORT`: + * === true Use Uint8Array implementation (fastest) + * === false Use Object implementation (most compatible, even IE6) + * + * Browsers that support typed arrays are IE 10+, Firefox 4+, Chrome 7+, Safari 5.1+, + * Opera 11.6+, iOS 4.2+. + * + * Due to various browser bugs, sometimes the Object implementation will be used even + * when the browser supports typed arrays. + * + * Note: + * + * - Firefox 4-29 lacks support for adding new properties to `Uint8Array` instances, + * See: https://bugzilla.mozilla.org/show_bug.cgi?id=695438. + * + * - Chrome 9-10 is missing the `TypedArray.prototype.subarray` function. + * + * - IE10 has a broken `TypedArray.prototype.subarray` function which returns arrays of + * incorrect length in some situations. + + * We detect these buggy browsers and set `Buffer.TYPED_ARRAY_SUPPORT` to `false` so they + * get the Object implementation, which is slower but behaves correctly. + */ +Buffer.TYPED_ARRAY_SUPPORT = global.TYPED_ARRAY_SUPPORT !== undefined + ? global.TYPED_ARRAY_SUPPORT + : typedArraySupport() + +/* + * Export kMaxLength after typed array support is determined. + */ +exports.kMaxLength = kMaxLength() + +function typedArraySupport () { + try { + var arr = new Uint8Array(1) + arr.__proto__ = {__proto__: Uint8Array.prototype, foo: function () { return 42 }} + return arr.foo() === 42 && // typed array instances can be augmented + typeof arr.subarray === 'function' && // chrome 9-10 lack `subarray` + arr.subarray(1, 1).byteLength === 0 // ie10 has broken `subarray` + } catch (e) { + return false + } +} + +function kMaxLength () { + return Buffer.TYPED_ARRAY_SUPPORT + ? 0x7fffffff + : 0x3fffffff +} + +function createBuffer (that, length) { + if (kMaxLength() < length) { + throw new RangeError('Invalid typed array length') + } + if (Buffer.TYPED_ARRAY_SUPPORT) { + // Return an augmented `Uint8Array` instance, for best performance + that = new Uint8Array(length) + that.__proto__ = Buffer.prototype + } else { + // Fallback: Return an object instance of the Buffer class + if (that === null) { + that = new Buffer(length) + } + that.length = length + } + + return that +} + +/** + * The Buffer constructor returns instances of `Uint8Array` that have their + * prototype changed to `Buffer.prototype`. Furthermore, `Buffer` is a subclass of + * `Uint8Array`, so the returned instances will have all the node `Buffer` methods + * and the `Uint8Array` methods. Square bracket notation works as expected -- it + * returns a single octet. + * + * The `Uint8Array` prototype remains unmodified. + */ + +function Buffer (arg, encodingOrOffset, length) { + if (!Buffer.TYPED_ARRAY_SUPPORT && !(this instanceof Buffer)) { + return new Buffer(arg, encodingOrOffset, length) + } + + // Common case. + if (typeof arg === 'number') { + if (typeof encodingOrOffset === 'string') { + throw new Error( + 'If encoding is specified then the first argument must be a string' + ) + } + return allocUnsafe(this, arg) + } + return from(this, arg, encodingOrOffset, length) +} + +Buffer.poolSize = 8192 // not used by this implementation + +// TODO: Legacy, not needed anymore. Remove in next major version. +Buffer._augment = function (arr) { + arr.__proto__ = Buffer.prototype + return arr +} + +function from (that, value, encodingOrOffset, length) { + if (typeof value === 'number') { + throw new TypeError('"value" argument must not be a number') + } + + if (typeof ArrayBuffer !== 'undefined' && value instanceof ArrayBuffer) { + return fromArrayBuffer(that, value, encodingOrOffset, length) + } + + if (typeof value === 'string') { + return fromString(that, value, encodingOrOffset) + } + + return fromObject(that, value) +} + +/** + * Functionally equivalent to Buffer(arg, encoding) but throws a TypeError + * if value is a number. + * Buffer.from(str[, encoding]) + * Buffer.from(array) + * Buffer.from(buffer) + * Buffer.from(arrayBuffer[, byteOffset[, length]]) + **/ +Buffer.from = function (value, encodingOrOffset, length) { + return from(null, value, encodingOrOffset, length) +} + +if (Buffer.TYPED_ARRAY_SUPPORT) { + Buffer.prototype.__proto__ = Uint8Array.prototype + Buffer.__proto__ = Uint8Array + if (typeof Symbol !== 'undefined' && Symbol.species && + Buffer[Symbol.species] === Buffer) { + // Fix subarray() in ES2016. See: https://github.com/feross/buffer/pull/97 + Object.defineProperty(Buffer, Symbol.species, { + value: null, + configurable: true + }) + } +} + +function assertSize (size) { + if (typeof size !== 'number') { + throw new TypeError('"size" argument must be a number') + } else if (size < 0) { + throw new RangeError('"size" argument must not be negative') + } +} + +function alloc (that, size, fill, encoding) { + assertSize(size) + if (size <= 0) { + return createBuffer(that, size) + } + if (fill !== undefined) { + // Only pay attention to encoding if it's a string. This + // prevents accidentally sending in a number that would + // be interpretted as a start offset. + return typeof encoding === 'string' + ? createBuffer(that, size).fill(fill, encoding) + : createBuffer(that, size).fill(fill) + } + return createBuffer(that, size) +} + +/** + * Creates a new filled Buffer instance. + * alloc(size[, fill[, encoding]]) + **/ +Buffer.alloc = function (size, fill, encoding) { + return alloc(null, size, fill, encoding) +} + +function allocUnsafe (that, size) { + assertSize(size) + that = createBuffer(that, size < 0 ? 0 : checked(size) | 0) + if (!Buffer.TYPED_ARRAY_SUPPORT) { + for (var i = 0; i < size; ++i) { + that[i] = 0 + } + } + return that +} + +/** + * Equivalent to Buffer(num), by default creates a non-zero-filled Buffer instance. + * */ +Buffer.allocUnsafe = function (size) { + return allocUnsafe(null, size) +} +/** + * Equivalent to SlowBuffer(num), by default creates a non-zero-filled Buffer instance. + */ +Buffer.allocUnsafeSlow = function (size) { + return allocUnsafe(null, size) +} + +function fromString (that, string, encoding) { + if (typeof encoding !== 'string' || encoding === '') { + encoding = 'utf8' + } + + if (!Buffer.isEncoding(encoding)) { + throw new TypeError('"encoding" must be a valid string encoding') + } + + var length = byteLength(string, encoding) | 0 + that = createBuffer(that, length) + + var actual = that.write(string, encoding) + + if (actual !== length) { + // Writing a hex string, for example, that contains invalid characters will + // cause everything after the first invalid character to be ignored. (e.g. + // 'abxxcd' will be treated as 'ab') + that = that.slice(0, actual) + } + + return that +} + +function fromArrayLike (that, array) { + var length = array.length < 0 ? 0 : checked(array.length) | 0 + that = createBuffer(that, length) + for (var i = 0; i < length; i += 1) { + that[i] = array[i] & 255 + } + return that +} + +function fromArrayBuffer (that, array, byteOffset, length) { + array.byteLength // this throws if `array` is not a valid ArrayBuffer + + if (byteOffset < 0 || array.byteLength < byteOffset) { + throw new RangeError('\'offset\' is out of bounds') + } + + if (array.byteLength < byteOffset + (length || 0)) { + throw new RangeError('\'length\' is out of bounds') + } + + if (byteOffset === undefined && length === undefined) { + array = new Uint8Array(array) + } else if (length === undefined) { + array = new Uint8Array(array, byteOffset) + } else { + array = new Uint8Array(array, byteOffset, length) + } + + if (Buffer.TYPED_ARRAY_SUPPORT) { + // Return an augmented `Uint8Array` instance, for best performance + that = array + that.__proto__ = Buffer.prototype + } else { + // Fallback: Return an object instance of the Buffer class + that = fromArrayLike(that, array) + } + return that +} + +function fromObject (that, obj) { + if (Buffer.isBuffer(obj)) { + var len = checked(obj.length) | 0 + that = createBuffer(that, len) + + if (that.length === 0) { + return that + } + + obj.copy(that, 0, 0, len) + return that + } + + if (obj) { + if ((typeof ArrayBuffer !== 'undefined' && + obj.buffer instanceof ArrayBuffer) || 'length' in obj) { + if (typeof obj.length !== 'number' || isnan(obj.length)) { + return createBuffer(that, 0) + } + return fromArrayLike(that, obj) + } + + if (obj.type === 'Buffer' && isArray(obj.data)) { + return fromArrayLike(that, obj.data) + } + } + + throw new TypeError('First argument must be a string, Buffer, ArrayBuffer, Array, or array-like object.') +} + +function checked (length) { + // Note: cannot use `length < kMaxLength()` here because that fails when + // length is NaN (which is otherwise coerced to zero.) + if (length >= kMaxLength()) { + throw new RangeError('Attempt to allocate Buffer larger than maximum ' + + 'size: 0x' + kMaxLength().toString(16) + ' bytes') + } + return length | 0 +} + +function SlowBuffer (length) { + if (+length != length) { // eslint-disable-line eqeqeq + length = 0 + } + return Buffer.alloc(+length) +} + +Buffer.isBuffer = function isBuffer (b) { + return !!(b != null && b._isBuffer) +} + +Buffer.compare = function compare (a, b) { + if (!Buffer.isBuffer(a) || !Buffer.isBuffer(b)) { + throw new TypeError('Arguments must be Buffers') + } + + if (a === b) return 0 + + var x = a.length + var y = b.length + + for (var i = 0, len = Math.min(x, y); i < len; ++i) { + if (a[i] !== b[i]) { + x = a[i] + y = b[i] + break + } + } + + if (x < y) return -1 + if (y < x) return 1 + return 0 +} + +Buffer.isEncoding = function isEncoding (encoding) { + switch (String(encoding).toLowerCase()) { + case 'hex': + case 'utf8': + case 'utf-8': + case 'ascii': + case 'latin1': + case 'binary': + case 'base64': + case 'ucs2': + case 'ucs-2': + case 'utf16le': + case 'utf-16le': + return true + default: + return false + } +} + +Buffer.concat = function concat (list, length) { + if (!isArray(list)) { + throw new TypeError('"list" argument must be an Array of Buffers') + } + + if (list.length === 0) { + return Buffer.alloc(0) + } + + var i + if (length === undefined) { + length = 0 + for (i = 0; i < list.length; ++i) { + length += list[i].length + } + } + + var buffer = Buffer.allocUnsafe(length) + var pos = 0 + for (i = 0; i < list.length; ++i) { + var buf = list[i] + if (!Buffer.isBuffer(buf)) { + throw new TypeError('"list" argument must be an Array of Buffers') + } + buf.copy(buffer, pos) + pos += buf.length + } + return buffer +} + +function byteLength (string, encoding) { + if (Buffer.isBuffer(string)) { + return string.length + } + if (typeof ArrayBuffer !== 'undefined' && typeof ArrayBuffer.isView === 'function' && + (ArrayBuffer.isView(string) || string instanceof ArrayBuffer)) { + return string.byteLength + } + if (typeof string !== 'string') { + string = '' + string + } + + var len = string.length + if (len === 0) return 0 + + // Use a for loop to avoid recursion + var loweredCase = false + for (;;) { + switch (encoding) { + case 'ascii': + case 'latin1': + case 'binary': + return len + case 'utf8': + case 'utf-8': + case undefined: + return utf8ToBytes(string).length + case 'ucs2': + case 'ucs-2': + case 'utf16le': + case 'utf-16le': + return len * 2 + case 'hex': + return len >>> 1 + case 'base64': + return base64ToBytes(string).length + default: + if (loweredCase) return utf8ToBytes(string).length // assume utf8 + encoding = ('' + encoding).toLowerCase() + loweredCase = true + } + } +} +Buffer.byteLength = byteLength + +function slowToString (encoding, start, end) { + var loweredCase = false + + // No need to verify that "this.length <= MAX_UINT32" since it's a read-only + // property of a typed array. + + // This behaves neither like String nor Uint8Array in that we set start/end + // to their upper/lower bounds if the value passed is out of range. + // undefined is handled specially as per ECMA-262 6th Edition, + // Section 13.3.3.7 Runtime Semantics: KeyedBindingInitialization. + if (start === undefined || start < 0) { + start = 0 + } + // Return early if start > this.length. Done here to prevent potential uint32 + // coercion fail below. + if (start > this.length) { + return '' + } + + if (end === undefined || end > this.length) { + end = this.length + } + + if (end <= 0) { + return '' + } + + // Force coersion to uint32. This will also coerce falsey/NaN values to 0. + end >>>= 0 + start >>>= 0 + + if (end <= start) { + return '' + } + + if (!encoding) encoding = 'utf8' + + while (true) { + switch (encoding) { + case 'hex': + return hexSlice(this, start, end) + + case 'utf8': + case 'utf-8': + return utf8Slice(this, start, end) + + case 'ascii': + return asciiSlice(this, start, end) + + case 'latin1': + case 'binary': + return latin1Slice(this, start, end) + + case 'base64': + return base64Slice(this, start, end) + + case 'ucs2': + case 'ucs-2': + case 'utf16le': + case 'utf-16le': + return utf16leSlice(this, start, end) + + default: + if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding) + encoding = (encoding + '').toLowerCase() + loweredCase = true + } + } +} + +// The property is used by `Buffer.isBuffer` and `is-buffer` (in Safari 5-7) to detect +// Buffer instances. +Buffer.prototype._isBuffer = true + +function swap (b, n, m) { + var i = b[n] + b[n] = b[m] + b[m] = i +} + +Buffer.prototype.swap16 = function swap16 () { + var len = this.length + if (len % 2 !== 0) { + throw new RangeError('Buffer size must be a multiple of 16-bits') + } + for (var i = 0; i < len; i += 2) { + swap(this, i, i + 1) + } + return this +} + +Buffer.prototype.swap32 = function swap32 () { + var len = this.length + if (len % 4 !== 0) { + throw new RangeError('Buffer size must be a multiple of 32-bits') + } + for (var i = 0; i < len; i += 4) { + swap(this, i, i + 3) + swap(this, i + 1, i + 2) + } + return this +} + +Buffer.prototype.swap64 = function swap64 () { + var len = this.length + if (len % 8 !== 0) { + throw new RangeError('Buffer size must be a multiple of 64-bits') + } + for (var i = 0; i < len; i += 8) { + swap(this, i, i + 7) + swap(this, i + 1, i + 6) + swap(this, i + 2, i + 5) + swap(this, i + 3, i + 4) + } + return this +} + +Buffer.prototype.toString = function toString () { + var length = this.length | 0 + if (length === 0) return '' + if (arguments.length === 0) return utf8Slice(this, 0, length) + return slowToString.apply(this, arguments) +} + +Buffer.prototype.equals = function equals (b) { + if (!Buffer.isBuffer(b)) throw new TypeError('Argument must be a Buffer') + if (this === b) return true + return Buffer.compare(this, b) === 0 +} + +Buffer.prototype.inspect = function inspect () { + var str = '' + var max = exports.INSPECT_MAX_BYTES + if (this.length > 0) { + str = this.toString('hex', 0, max).match(/.{2}/g).join(' ') + if (this.length > max) str += ' ... ' + } + return '' +} + +Buffer.prototype.compare = function compare (target, start, end, thisStart, thisEnd) { + if (!Buffer.isBuffer(target)) { + throw new TypeError('Argument must be a Buffer') + } + + if (start === undefined) { + start = 0 + } + if (end === undefined) { + end = target ? target.length : 0 + } + if (thisStart === undefined) { + thisStart = 0 + } + if (thisEnd === undefined) { + thisEnd = this.length + } + + if (start < 0 || end > target.length || thisStart < 0 || thisEnd > this.length) { + throw new RangeError('out of range index') + } + + if (thisStart >= thisEnd && start >= end) { + return 0 + } + if (thisStart >= thisEnd) { + return -1 + } + if (start >= end) { + return 1 + } + + start >>>= 0 + end >>>= 0 + thisStart >>>= 0 + thisEnd >>>= 0 + + if (this === target) return 0 + + var x = thisEnd - thisStart + var y = end - start + var len = Math.min(x, y) + + var thisCopy = this.slice(thisStart, thisEnd) + var targetCopy = target.slice(start, end) + + for (var i = 0; i < len; ++i) { + if (thisCopy[i] !== targetCopy[i]) { + x = thisCopy[i] + y = targetCopy[i] + break + } + } + + if (x < y) return -1 + if (y < x) return 1 + return 0 +} + +// Finds either the first index of `val` in `buffer` at offset >= `byteOffset`, +// OR the last index of `val` in `buffer` at offset <= `byteOffset`. +// +// Arguments: +// - buffer - a Buffer to search +// - val - a string, Buffer, or number +// - byteOffset - an index into `buffer`; will be clamped to an int32 +// - encoding - an optional encoding, relevant is val is a string +// - dir - true for indexOf, false for lastIndexOf +function bidirectionalIndexOf (buffer, val, byteOffset, encoding, dir) { + // Empty buffer means no match + if (buffer.length === 0) return -1 + + // Normalize byteOffset + if (typeof byteOffset === 'string') { + encoding = byteOffset + byteOffset = 0 + } else if (byteOffset > 0x7fffffff) { + byteOffset = 0x7fffffff + } else if (byteOffset < -0x80000000) { + byteOffset = -0x80000000 + } + byteOffset = +byteOffset // Coerce to Number. + if (isNaN(byteOffset)) { + // byteOffset: it it's undefined, null, NaN, "foo", etc, search whole buffer + byteOffset = dir ? 0 : (buffer.length - 1) + } + + // Normalize byteOffset: negative offsets start from the end of the buffer + if (byteOffset < 0) byteOffset = buffer.length + byteOffset + if (byteOffset >= buffer.length) { + if (dir) return -1 + else byteOffset = buffer.length - 1 + } else if (byteOffset < 0) { + if (dir) byteOffset = 0 + else return -1 + } + + // Normalize val + if (typeof val === 'string') { + val = Buffer.from(val, encoding) + } + + // Finally, search either indexOf (if dir is true) or lastIndexOf + if (Buffer.isBuffer(val)) { + // Special case: looking for empty string/buffer always fails + if (val.length === 0) { + return -1 + } + return arrayIndexOf(buffer, val, byteOffset, encoding, dir) + } else if (typeof val === 'number') { + val = val & 0xFF // Search for a byte value [0-255] + if (Buffer.TYPED_ARRAY_SUPPORT && + typeof Uint8Array.prototype.indexOf === 'function') { + if (dir) { + return Uint8Array.prototype.indexOf.call(buffer, val, byteOffset) + } else { + return Uint8Array.prototype.lastIndexOf.call(buffer, val, byteOffset) + } + } + return arrayIndexOf(buffer, [ val ], byteOffset, encoding, dir) + } + + throw new TypeError('val must be string, number or Buffer') +} + +function arrayIndexOf (arr, val, byteOffset, encoding, dir) { + var indexSize = 1 + var arrLength = arr.length + var valLength = val.length + + if (encoding !== undefined) { + encoding = String(encoding).toLowerCase() + if (encoding === 'ucs2' || encoding === 'ucs-2' || + encoding === 'utf16le' || encoding === 'utf-16le') { + if (arr.length < 2 || val.length < 2) { + return -1 + } + indexSize = 2 + arrLength /= 2 + valLength /= 2 + byteOffset /= 2 + } + } + + function read (buf, i) { + if (indexSize === 1) { + return buf[i] + } else { + return buf.readUInt16BE(i * indexSize) + } + } + + var i + if (dir) { + var foundIndex = -1 + for (i = byteOffset; i < arrLength; i++) { + if (read(arr, i) === read(val, foundIndex === -1 ? 0 : i - foundIndex)) { + if (foundIndex === -1) foundIndex = i + if (i - foundIndex + 1 === valLength) return foundIndex * indexSize + } else { + if (foundIndex !== -1) i -= i - foundIndex + foundIndex = -1 + } + } + } else { + if (byteOffset + valLength > arrLength) byteOffset = arrLength - valLength + for (i = byteOffset; i >= 0; i--) { + var found = true + for (var j = 0; j < valLength; j++) { + if (read(arr, i + j) !== read(val, j)) { + found = false + break + } + } + if (found) return i + } + } + + return -1 +} + +Buffer.prototype.includes = function includes (val, byteOffset, encoding) { + return this.indexOf(val, byteOffset, encoding) !== -1 +} + +Buffer.prototype.indexOf = function indexOf (val, byteOffset, encoding) { + return bidirectionalIndexOf(this, val, byteOffset, encoding, true) +} + +Buffer.prototype.lastIndexOf = function lastIndexOf (val, byteOffset, encoding) { + return bidirectionalIndexOf(this, val, byteOffset, encoding, false) +} + +function hexWrite (buf, string, offset, length) { + offset = Number(offset) || 0 + var remaining = buf.length - offset + if (!length) { + length = remaining + } else { + length = Number(length) + if (length > remaining) { + length = remaining + } + } + + // must be an even number of digits + var strLen = string.length + if (strLen % 2 !== 0) throw new TypeError('Invalid hex string') + + if (length > strLen / 2) { + length = strLen / 2 + } + for (var i = 0; i < length; ++i) { + var parsed = parseInt(string.substr(i * 2, 2), 16) + if (isNaN(parsed)) return i + buf[offset + i] = parsed + } + return i +} + +function utf8Write (buf, string, offset, length) { + return blitBuffer(utf8ToBytes(string, buf.length - offset), buf, offset, length) +} + +function asciiWrite (buf, string, offset, length) { + return blitBuffer(asciiToBytes(string), buf, offset, length) +} + +function latin1Write (buf, string, offset, length) { + return asciiWrite(buf, string, offset, length) +} + +function base64Write (buf, string, offset, length) { + return blitBuffer(base64ToBytes(string), buf, offset, length) +} + +function ucs2Write (buf, string, offset, length) { + return blitBuffer(utf16leToBytes(string, buf.length - offset), buf, offset, length) +} + +Buffer.prototype.write = function write (string, offset, length, encoding) { + // Buffer#write(string) + if (offset === undefined) { + encoding = 'utf8' + length = this.length + offset = 0 + // Buffer#write(string, encoding) + } else if (length === undefined && typeof offset === 'string') { + encoding = offset + length = this.length + offset = 0 + // Buffer#write(string, offset[, length][, encoding]) + } else if (isFinite(offset)) { + offset = offset | 0 + if (isFinite(length)) { + length = length | 0 + if (encoding === undefined) encoding = 'utf8' + } else { + encoding = length + length = undefined + } + // legacy write(string, encoding, offset, length) - remove in v0.13 + } else { + throw new Error( + 'Buffer.write(string, encoding, offset[, length]) is no longer supported' + ) + } + + var remaining = this.length - offset + if (length === undefined || length > remaining) length = remaining + + if ((string.length > 0 && (length < 0 || offset < 0)) || offset > this.length) { + throw new RangeError('Attempt to write outside buffer bounds') + } + + if (!encoding) encoding = 'utf8' + + var loweredCase = false + for (;;) { + switch (encoding) { + case 'hex': + return hexWrite(this, string, offset, length) + + case 'utf8': + case 'utf-8': + return utf8Write(this, string, offset, length) + + case 'ascii': + return asciiWrite(this, string, offset, length) + + case 'latin1': + case 'binary': + return latin1Write(this, string, offset, length) + + case 'base64': + // Warning: maxLength not taken into account in base64Write + return base64Write(this, string, offset, length) + + case 'ucs2': + case 'ucs-2': + case 'utf16le': + case 'utf-16le': + return ucs2Write(this, string, offset, length) + + default: + if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding) + encoding = ('' + encoding).toLowerCase() + loweredCase = true + } + } +} + +Buffer.prototype.toJSON = function toJSON () { + return { + type: 'Buffer', + data: Array.prototype.slice.call(this._arr || this, 0) + } +} + +function base64Slice (buf, start, end) { + if (start === 0 && end === buf.length) { + return base64.fromByteArray(buf) + } else { + return base64.fromByteArray(buf.slice(start, end)) + } +} + +function utf8Slice (buf, start, end) { + end = Math.min(buf.length, end) + var res = [] + + var i = start + while (i < end) { + var firstByte = buf[i] + var codePoint = null + var bytesPerSequence = (firstByte > 0xEF) ? 4 + : (firstByte > 0xDF) ? 3 + : (firstByte > 0xBF) ? 2 + : 1 + + if (i + bytesPerSequence <= end) { + var secondByte, thirdByte, fourthByte, tempCodePoint + + switch (bytesPerSequence) { + case 1: + if (firstByte < 0x80) { + codePoint = firstByte + } + break + case 2: + secondByte = buf[i + 1] + if ((secondByte & 0xC0) === 0x80) { + tempCodePoint = (firstByte & 0x1F) << 0x6 | (secondByte & 0x3F) + if (tempCodePoint > 0x7F) { + codePoint = tempCodePoint + } + } + break + case 3: + secondByte = buf[i + 1] + thirdByte = buf[i + 2] + if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80) { + tempCodePoint = (firstByte & 0xF) << 0xC | (secondByte & 0x3F) << 0x6 | (thirdByte & 0x3F) + if (tempCodePoint > 0x7FF && (tempCodePoint < 0xD800 || tempCodePoint > 0xDFFF)) { + codePoint = tempCodePoint + } + } + break + case 4: + secondByte = buf[i + 1] + thirdByte = buf[i + 2] + fourthByte = buf[i + 3] + if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80 && (fourthByte & 0xC0) === 0x80) { + tempCodePoint = (firstByte & 0xF) << 0x12 | (secondByte & 0x3F) << 0xC | (thirdByte & 0x3F) << 0x6 | (fourthByte & 0x3F) + if (tempCodePoint > 0xFFFF && tempCodePoint < 0x110000) { + codePoint = tempCodePoint + } + } + } + } + + if (codePoint === null) { + // we did not generate a valid codePoint so insert a + // replacement char (U+FFFD) and advance only 1 byte + codePoint = 0xFFFD + bytesPerSequence = 1 + } else if (codePoint > 0xFFFF) { + // encode to utf16 (surrogate pair dance) + codePoint -= 0x10000 + res.push(codePoint >>> 10 & 0x3FF | 0xD800) + codePoint = 0xDC00 | codePoint & 0x3FF + } + + res.push(codePoint) + i += bytesPerSequence + } + + return decodeCodePointsArray(res) +} + +// Based on http://stackoverflow.com/a/22747272/680742, the browser with +// the lowest limit is Chrome, with 0x10000 args. +// We go 1 magnitude less, for safety +var MAX_ARGUMENTS_LENGTH = 0x1000 + +function decodeCodePointsArray (codePoints) { + var len = codePoints.length + if (len <= MAX_ARGUMENTS_LENGTH) { + return String.fromCharCode.apply(String, codePoints) // avoid extra slice() + } + + // Decode in chunks to avoid "call stack size exceeded". + var res = '' + var i = 0 + while (i < len) { + res += String.fromCharCode.apply( + String, + codePoints.slice(i, i += MAX_ARGUMENTS_LENGTH) + ) + } + return res +} + +function asciiSlice (buf, start, end) { + var ret = '' + end = Math.min(buf.length, end) + + for (var i = start; i < end; ++i) { + ret += String.fromCharCode(buf[i] & 0x7F) + } + return ret +} + +function latin1Slice (buf, start, end) { + var ret = '' + end = Math.min(buf.length, end) + + for (var i = start; i < end; ++i) { + ret += String.fromCharCode(buf[i]) + } + return ret +} + +function hexSlice (buf, start, end) { + var len = buf.length + + if (!start || start < 0) start = 0 + if (!end || end < 0 || end > len) end = len + + var out = '' + for (var i = start; i < end; ++i) { + out += toHex(buf[i]) + } + return out +} + +function utf16leSlice (buf, start, end) { + var bytes = buf.slice(start, end) + var res = '' + for (var i = 0; i < bytes.length; i += 2) { + res += String.fromCharCode(bytes[i] + bytes[i + 1] * 256) + } + return res +} + +Buffer.prototype.slice = function slice (start, end) { + var len = this.length + start = ~~start + end = end === undefined ? len : ~~end + + if (start < 0) { + start += len + if (start < 0) start = 0 + } else if (start > len) { + start = len + } + + if (end < 0) { + end += len + if (end < 0) end = 0 + } else if (end > len) { + end = len + } + + if (end < start) end = start + + var newBuf + if (Buffer.TYPED_ARRAY_SUPPORT) { + newBuf = this.subarray(start, end) + newBuf.__proto__ = Buffer.prototype + } else { + var sliceLen = end - start + newBuf = new Buffer(sliceLen, undefined) + for (var i = 0; i < sliceLen; ++i) { + newBuf[i] = this[i + start] + } + } + + return newBuf +} + +/* + * Need to make sure that buffer isn't trying to write out of bounds. + */ +function checkOffset (offset, ext, length) { + if ((offset % 1) !== 0 || offset < 0) throw new RangeError('offset is not uint') + if (offset + ext > length) throw new RangeError('Trying to access beyond buffer length') +} + +Buffer.prototype.readUIntLE = function readUIntLE (offset, byteLength, noAssert) { + offset = offset | 0 + byteLength = byteLength | 0 + if (!noAssert) checkOffset(offset, byteLength, this.length) + + var val = this[offset] + var mul = 1 + var i = 0 + while (++i < byteLength && (mul *= 0x100)) { + val += this[offset + i] * mul + } + + return val +} + +Buffer.prototype.readUIntBE = function readUIntBE (offset, byteLength, noAssert) { + offset = offset | 0 + byteLength = byteLength | 0 + if (!noAssert) { + checkOffset(offset, byteLength, this.length) + } + + var val = this[offset + --byteLength] + var mul = 1 + while (byteLength > 0 && (mul *= 0x100)) { + val += this[offset + --byteLength] * mul + } + + return val +} + +Buffer.prototype.readUInt8 = function readUInt8 (offset, noAssert) { + if (!noAssert) checkOffset(offset, 1, this.length) + return this[offset] +} + +Buffer.prototype.readUInt16LE = function readUInt16LE (offset, noAssert) { + if (!noAssert) checkOffset(offset, 2, this.length) + return this[offset] | (this[offset + 1] << 8) +} + +Buffer.prototype.readUInt16BE = function readUInt16BE (offset, noAssert) { + if (!noAssert) checkOffset(offset, 2, this.length) + return (this[offset] << 8) | this[offset + 1] +} + +Buffer.prototype.readUInt32LE = function readUInt32LE (offset, noAssert) { + if (!noAssert) checkOffset(offset, 4, this.length) + + return ((this[offset]) | + (this[offset + 1] << 8) | + (this[offset + 2] << 16)) + + (this[offset + 3] * 0x1000000) +} + +Buffer.prototype.readUInt32BE = function readUInt32BE (offset, noAssert) { + if (!noAssert) checkOffset(offset, 4, this.length) + + return (this[offset] * 0x1000000) + + ((this[offset + 1] << 16) | + (this[offset + 2] << 8) | + this[offset + 3]) +} + +Buffer.prototype.readIntLE = function readIntLE (offset, byteLength, noAssert) { + offset = offset | 0 + byteLength = byteLength | 0 + if (!noAssert) checkOffset(offset, byteLength, this.length) + + var val = this[offset] + var mul = 1 + var i = 0 + while (++i < byteLength && (mul *= 0x100)) { + val += this[offset + i] * mul + } + mul *= 0x80 + + if (val >= mul) val -= Math.pow(2, 8 * byteLength) + + return val +} + +Buffer.prototype.readIntBE = function readIntBE (offset, byteLength, noAssert) { + offset = offset | 0 + byteLength = byteLength | 0 + if (!noAssert) checkOffset(offset, byteLength, this.length) + + var i = byteLength + var mul = 1 + var val = this[offset + --i] + while (i > 0 && (mul *= 0x100)) { + val += this[offset + --i] * mul + } + mul *= 0x80 + + if (val >= mul) val -= Math.pow(2, 8 * byteLength) + + return val +} + +Buffer.prototype.readInt8 = function readInt8 (offset, noAssert) { + if (!noAssert) checkOffset(offset, 1, this.length) + if (!(this[offset] & 0x80)) return (this[offset]) + return ((0xff - this[offset] + 1) * -1) +} + +Buffer.prototype.readInt16LE = function readInt16LE (offset, noAssert) { + if (!noAssert) checkOffset(offset, 2, this.length) + var val = this[offset] | (this[offset + 1] << 8) + return (val & 0x8000) ? val | 0xFFFF0000 : val +} + +Buffer.prototype.readInt16BE = function readInt16BE (offset, noAssert) { + if (!noAssert) checkOffset(offset, 2, this.length) + var val = this[offset + 1] | (this[offset] << 8) + return (val & 0x8000) ? val | 0xFFFF0000 : val +} + +Buffer.prototype.readInt32LE = function readInt32LE (offset, noAssert) { + if (!noAssert) checkOffset(offset, 4, this.length) + + return (this[offset]) | + (this[offset + 1] << 8) | + (this[offset + 2] << 16) | + (this[offset + 3] << 24) +} + +Buffer.prototype.readInt32BE = function readInt32BE (offset, noAssert) { + if (!noAssert) checkOffset(offset, 4, this.length) + + return (this[offset] << 24) | + (this[offset + 1] << 16) | + (this[offset + 2] << 8) | + (this[offset + 3]) +} + +Buffer.prototype.readFloatLE = function readFloatLE (offset, noAssert) { + if (!noAssert) checkOffset(offset, 4, this.length) + return ieee754.read(this, offset, true, 23, 4) +} + +Buffer.prototype.readFloatBE = function readFloatBE (offset, noAssert) { + if (!noAssert) checkOffset(offset, 4, this.length) + return ieee754.read(this, offset, false, 23, 4) +} + +Buffer.prototype.readDoubleLE = function readDoubleLE (offset, noAssert) { + if (!noAssert) checkOffset(offset, 8, this.length) + return ieee754.read(this, offset, true, 52, 8) +} + +Buffer.prototype.readDoubleBE = function readDoubleBE (offset, noAssert) { + if (!noAssert) checkOffset(offset, 8, this.length) + return ieee754.read(this, offset, false, 52, 8) +} + +function checkInt (buf, value, offset, ext, max, min) { + if (!Buffer.isBuffer(buf)) throw new TypeError('"buffer" argument must be a Buffer instance') + if (value > max || value < min) throw new RangeError('"value" argument is out of bounds') + if (offset + ext > buf.length) throw new RangeError('Index out of range') +} + +Buffer.prototype.writeUIntLE = function writeUIntLE (value, offset, byteLength, noAssert) { + value = +value + offset = offset | 0 + byteLength = byteLength | 0 + if (!noAssert) { + var maxBytes = Math.pow(2, 8 * byteLength) - 1 + checkInt(this, value, offset, byteLength, maxBytes, 0) + } + + var mul = 1 + var i = 0 + this[offset] = value & 0xFF + while (++i < byteLength && (mul *= 0x100)) { + this[offset + i] = (value / mul) & 0xFF + } + + return offset + byteLength +} + +Buffer.prototype.writeUIntBE = function writeUIntBE (value, offset, byteLength, noAssert) { + value = +value + offset = offset | 0 + byteLength = byteLength | 0 + if (!noAssert) { + var maxBytes = Math.pow(2, 8 * byteLength) - 1 + checkInt(this, value, offset, byteLength, maxBytes, 0) + } + + var i = byteLength - 1 + var mul = 1 + this[offset + i] = value & 0xFF + while (--i >= 0 && (mul *= 0x100)) { + this[offset + i] = (value / mul) & 0xFF + } + + return offset + byteLength +} + +Buffer.prototype.writeUInt8 = function writeUInt8 (value, offset, noAssert) { + value = +value + offset = offset | 0 + if (!noAssert) checkInt(this, value, offset, 1, 0xff, 0) + if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value) + this[offset] = (value & 0xff) + return offset + 1 +} + +function objectWriteUInt16 (buf, value, offset, littleEndian) { + if (value < 0) value = 0xffff + value + 1 + for (var i = 0, j = Math.min(buf.length - offset, 2); i < j; ++i) { + buf[offset + i] = (value & (0xff << (8 * (littleEndian ? i : 1 - i)))) >>> + (littleEndian ? i : 1 - i) * 8 + } +} + +Buffer.prototype.writeUInt16LE = function writeUInt16LE (value, offset, noAssert) { + value = +value + offset = offset | 0 + if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0) + if (Buffer.TYPED_ARRAY_SUPPORT) { + this[offset] = (value & 0xff) + this[offset + 1] = (value >>> 8) + } else { + objectWriteUInt16(this, value, offset, true) + } + return offset + 2 +} + +Buffer.prototype.writeUInt16BE = function writeUInt16BE (value, offset, noAssert) { + value = +value + offset = offset | 0 + if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0) + if (Buffer.TYPED_ARRAY_SUPPORT) { + this[offset] = (value >>> 8) + this[offset + 1] = (value & 0xff) + } else { + objectWriteUInt16(this, value, offset, false) + } + return offset + 2 +} + +function objectWriteUInt32 (buf, value, offset, littleEndian) { + if (value < 0) value = 0xffffffff + value + 1 + for (var i = 0, j = Math.min(buf.length - offset, 4); i < j; ++i) { + buf[offset + i] = (value >>> (littleEndian ? i : 3 - i) * 8) & 0xff + } +} + +Buffer.prototype.writeUInt32LE = function writeUInt32LE (value, offset, noAssert) { + value = +value + offset = offset | 0 + if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0) + if (Buffer.TYPED_ARRAY_SUPPORT) { + this[offset + 3] = (value >>> 24) + this[offset + 2] = (value >>> 16) + this[offset + 1] = (value >>> 8) + this[offset] = (value & 0xff) + } else { + objectWriteUInt32(this, value, offset, true) + } + return offset + 4 +} + +Buffer.prototype.writeUInt32BE = function writeUInt32BE (value, offset, noAssert) { + value = +value + offset = offset | 0 + if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0) + if (Buffer.TYPED_ARRAY_SUPPORT) { + this[offset] = (value >>> 24) + this[offset + 1] = (value >>> 16) + this[offset + 2] = (value >>> 8) + this[offset + 3] = (value & 0xff) + } else { + objectWriteUInt32(this, value, offset, false) + } + return offset + 4 +} + +Buffer.prototype.writeIntLE = function writeIntLE (value, offset, byteLength, noAssert) { + value = +value + offset = offset | 0 + if (!noAssert) { + var limit = Math.pow(2, 8 * byteLength - 1) + + checkInt(this, value, offset, byteLength, limit - 1, -limit) + } + + var i = 0 + var mul = 1 + var sub = 0 + this[offset] = value & 0xFF + while (++i < byteLength && (mul *= 0x100)) { + if (value < 0 && sub === 0 && this[offset + i - 1] !== 0) { + sub = 1 + } + this[offset + i] = ((value / mul) >> 0) - sub & 0xFF + } + + return offset + byteLength +} + +Buffer.prototype.writeIntBE = function writeIntBE (value, offset, byteLength, noAssert) { + value = +value + offset = offset | 0 + if (!noAssert) { + var limit = Math.pow(2, 8 * byteLength - 1) + + checkInt(this, value, offset, byteLength, limit - 1, -limit) + } + + var i = byteLength - 1 + var mul = 1 + var sub = 0 + this[offset + i] = value & 0xFF + while (--i >= 0 && (mul *= 0x100)) { + if (value < 0 && sub === 0 && this[offset + i + 1] !== 0) { + sub = 1 + } + this[offset + i] = ((value / mul) >> 0) - sub & 0xFF + } + + return offset + byteLength +} + +Buffer.prototype.writeInt8 = function writeInt8 (value, offset, noAssert) { + value = +value + offset = offset | 0 + if (!noAssert) checkInt(this, value, offset, 1, 0x7f, -0x80) + if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value) + if (value < 0) value = 0xff + value + 1 + this[offset] = (value & 0xff) + return offset + 1 +} + +Buffer.prototype.writeInt16LE = function writeInt16LE (value, offset, noAssert) { + value = +value + offset = offset | 0 + if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000) + if (Buffer.TYPED_ARRAY_SUPPORT) { + this[offset] = (value & 0xff) + this[offset + 1] = (value >>> 8) + } else { + objectWriteUInt16(this, value, offset, true) + } + return offset + 2 +} + +Buffer.prototype.writeInt16BE = function writeInt16BE (value, offset, noAssert) { + value = +value + offset = offset | 0 + if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000) + if (Buffer.TYPED_ARRAY_SUPPORT) { + this[offset] = (value >>> 8) + this[offset + 1] = (value & 0xff) + } else { + objectWriteUInt16(this, value, offset, false) + } + return offset + 2 +} + +Buffer.prototype.writeInt32LE = function writeInt32LE (value, offset, noAssert) { + value = +value + offset = offset | 0 + if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000) + if (Buffer.TYPED_ARRAY_SUPPORT) { + this[offset] = (value & 0xff) + this[offset + 1] = (value >>> 8) + this[offset + 2] = (value >>> 16) + this[offset + 3] = (value >>> 24) + } else { + objectWriteUInt32(this, value, offset, true) + } + return offset + 4 +} + +Buffer.prototype.writeInt32BE = function writeInt32BE (value, offset, noAssert) { + value = +value + offset = offset | 0 + if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000) + if (value < 0) value = 0xffffffff + value + 1 + if (Buffer.TYPED_ARRAY_SUPPORT) { + this[offset] = (value >>> 24) + this[offset + 1] = (value >>> 16) + this[offset + 2] = (value >>> 8) + this[offset + 3] = (value & 0xff) + } else { + objectWriteUInt32(this, value, offset, false) + } + return offset + 4 +} + +function checkIEEE754 (buf, value, offset, ext, max, min) { + if (offset + ext > buf.length) throw new RangeError('Index out of range') + if (offset < 0) throw new RangeError('Index out of range') +} + +function writeFloat (buf, value, offset, littleEndian, noAssert) { + if (!noAssert) { + checkIEEE754(buf, value, offset, 4, 3.4028234663852886e+38, -3.4028234663852886e+38) + } + ieee754.write(buf, value, offset, littleEndian, 23, 4) + return offset + 4 +} + +Buffer.prototype.writeFloatLE = function writeFloatLE (value, offset, noAssert) { + return writeFloat(this, value, offset, true, noAssert) +} + +Buffer.prototype.writeFloatBE = function writeFloatBE (value, offset, noAssert) { + return writeFloat(this, value, offset, false, noAssert) +} + +function writeDouble (buf, value, offset, littleEndian, noAssert) { + if (!noAssert) { + checkIEEE754(buf, value, offset, 8, 1.7976931348623157E+308, -1.7976931348623157E+308) + } + ieee754.write(buf, value, offset, littleEndian, 52, 8) + return offset + 8 +} + +Buffer.prototype.writeDoubleLE = function writeDoubleLE (value, offset, noAssert) { + return writeDouble(this, value, offset, true, noAssert) +} + +Buffer.prototype.writeDoubleBE = function writeDoubleBE (value, offset, noAssert) { + return writeDouble(this, value, offset, false, noAssert) +} + +// copy(targetBuffer, targetStart=0, sourceStart=0, sourceEnd=buffer.length) +Buffer.prototype.copy = function copy (target, targetStart, start, end) { + if (!start) start = 0 + if (!end && end !== 0) end = this.length + if (targetStart >= target.length) targetStart = target.length + if (!targetStart) targetStart = 0 + if (end > 0 && end < start) end = start + + // Copy 0 bytes; we're done + if (end === start) return 0 + if (target.length === 0 || this.length === 0) return 0 + + // Fatal error conditions + if (targetStart < 0) { + throw new RangeError('targetStart out of bounds') + } + if (start < 0 || start >= this.length) throw new RangeError('sourceStart out of bounds') + if (end < 0) throw new RangeError('sourceEnd out of bounds') + + // Are we oob? + if (end > this.length) end = this.length + if (target.length - targetStart < end - start) { + end = target.length - targetStart + start + } + + var len = end - start + var i + + if (this === target && start < targetStart && targetStart < end) { + // descending copy from end + for (i = len - 1; i >= 0; --i) { + target[i + targetStart] = this[i + start] + } + } else if (len < 1000 || !Buffer.TYPED_ARRAY_SUPPORT) { + // ascending copy from start + for (i = 0; i < len; ++i) { + target[i + targetStart] = this[i + start] + } + } else { + Uint8Array.prototype.set.call( + target, + this.subarray(start, start + len), + targetStart + ) + } + + return len +} + +// Usage: +// buffer.fill(number[, offset[, end]]) +// buffer.fill(buffer[, offset[, end]]) +// buffer.fill(string[, offset[, end]][, encoding]) +Buffer.prototype.fill = function fill (val, start, end, encoding) { + // Handle string cases: + if (typeof val === 'string') { + if (typeof start === 'string') { + encoding = start + start = 0 + end = this.length + } else if (typeof end === 'string') { + encoding = end + end = this.length + } + if (val.length === 1) { + var code = val.charCodeAt(0) + if (code < 256) { + val = code + } + } + if (encoding !== undefined && typeof encoding !== 'string') { + throw new TypeError('encoding must be a string') + } + if (typeof encoding === 'string' && !Buffer.isEncoding(encoding)) { + throw new TypeError('Unknown encoding: ' + encoding) + } + } else if (typeof val === 'number') { + val = val & 255 + } + + // Invalid ranges are not set to a default, so can range check early. + if (start < 0 || this.length < start || this.length < end) { + throw new RangeError('Out of range index') + } + + if (end <= start) { + return this + } + + start = start >>> 0 + end = end === undefined ? this.length : end >>> 0 + + if (!val) val = 0 + + var i + if (typeof val === 'number') { + for (i = start; i < end; ++i) { + this[i] = val + } + } else { + var bytes = Buffer.isBuffer(val) + ? val + : utf8ToBytes(new Buffer(val, encoding).toString()) + var len = bytes.length + for (i = 0; i < end - start; ++i) { + this[i + start] = bytes[i % len] + } + } + + return this +} + +// HELPER FUNCTIONS +// ================ + +var INVALID_BASE64_RE = /[^+\/0-9A-Za-z-_]/g + +function base64clean (str) { + // Node strips out invalid characters like \n and \t from the string, base64-js does not + str = stringtrim(str).replace(INVALID_BASE64_RE, '') + // Node converts strings with length < 2 to '' + if (str.length < 2) return '' + // Node allows for non-padded base64 strings (missing trailing ===), base64-js does not + while (str.length % 4 !== 0) { + str = str + '=' + } + return str +} + +function stringtrim (str) { + if (str.trim) return str.trim() + return str.replace(/^\s+|\s+$/g, '') +} + +function toHex (n) { + if (n < 16) return '0' + n.toString(16) + return n.toString(16) +} + +function utf8ToBytes (string, units) { + units = units || Infinity + var codePoint + var length = string.length + var leadSurrogate = null + var bytes = [] + + for (var i = 0; i < length; ++i) { + codePoint = string.charCodeAt(i) + + // is surrogate component + if (codePoint > 0xD7FF && codePoint < 0xE000) { + // last char was a lead + if (!leadSurrogate) { + // no lead yet + if (codePoint > 0xDBFF) { + // unexpected trail + if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD) + continue + } else if (i + 1 === length) { + // unpaired lead + if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD) + continue + } + + // valid lead + leadSurrogate = codePoint + + continue + } + + // 2 leads in a row + if (codePoint < 0xDC00) { + if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD) + leadSurrogate = codePoint + continue + } + + // valid surrogate pair + codePoint = (leadSurrogate - 0xD800 << 10 | codePoint - 0xDC00) + 0x10000 + } else if (leadSurrogate) { + // valid bmp char, but last char was a lead + if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD) + } + + leadSurrogate = null + + // encode utf8 + if (codePoint < 0x80) { + if ((units -= 1) < 0) break + bytes.push(codePoint) + } else if (codePoint < 0x800) { + if ((units -= 2) < 0) break + bytes.push( + codePoint >> 0x6 | 0xC0, + codePoint & 0x3F | 0x80 + ) + } else if (codePoint < 0x10000) { + if ((units -= 3) < 0) break + bytes.push( + codePoint >> 0xC | 0xE0, + codePoint >> 0x6 & 0x3F | 0x80, + codePoint & 0x3F | 0x80 + ) + } else if (codePoint < 0x110000) { + if ((units -= 4) < 0) break + bytes.push( + codePoint >> 0x12 | 0xF0, + codePoint >> 0xC & 0x3F | 0x80, + codePoint >> 0x6 & 0x3F | 0x80, + codePoint & 0x3F | 0x80 + ) + } else { + throw new Error('Invalid code point') + } + } + + return bytes +} + +function asciiToBytes (str) { + var byteArray = [] + for (var i = 0; i < str.length; ++i) { + // Node's code seems to be doing this and not & 0x7F.. + byteArray.push(str.charCodeAt(i) & 0xFF) + } + return byteArray +} + +function utf16leToBytes (str, units) { + var c, hi, lo + var byteArray = [] + for (var i = 0; i < str.length; ++i) { + if ((units -= 2) < 0) break + + c = str.charCodeAt(i) + hi = c >> 8 + lo = c % 256 + byteArray.push(lo) + byteArray.push(hi) + } + + return byteArray +} + +function base64ToBytes (str) { + return base64.toByteArray(base64clean(str)) +} + +function blitBuffer (src, dst, offset, length) { + for (var i = 0; i < length; ++i) { + if ((i + offset >= dst.length) || (i >= src.length)) break + dst[i + offset] = src[i] + } + return i +} + +function isnan (val) { + return val !== val // eslint-disable-line no-self-compare +} + +}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {}) + +},{"base64-js":38,"ieee754":42,"isarray":43}],40:[function(require,module,exports){ +(function (process){ +/** + * This is the web browser implementation of `debug()`. + * + * Expose `debug()` as the module. + */ + +exports = module.exports = require('./debug'); +exports.log = log; +exports.formatArgs = formatArgs; +exports.save = save; +exports.load = load; +exports.useColors = useColors; +exports.storage = 'undefined' != typeof chrome + && 'undefined' != typeof chrome.storage + ? chrome.storage.local + : localstorage(); + +/** + * Colors. + */ + +exports.colors = [ + 'lightseagreen', + 'forestgreen', + 'goldenrod', + 'dodgerblue', + 'darkorchid', + 'crimson' +]; + +/** + * Currently only WebKit-based Web Inspectors, Firefox >= v31, + * and the Firebug extension (any Firefox version) are known + * to support "%c" CSS customizations. + * + * TODO: add a `localStorage` variable to explicitly enable/disable colors + */ + +function useColors() { + // NB: In an Electron preload script, document will be defined but not fully + // initialized. Since we know we're in Chrome, we'll just detect this case + // explicitly + if (typeof window !== 'undefined' && window && typeof window.process !== 'undefined' && window.process.type === 'renderer') { + return true; + } + + // is webkit? http://stackoverflow.com/a/16459606/376773 + // document is undefined in react-native: https://github.com/facebook/react-native/pull/1632 + return (typeof document !== 'undefined' && document && 'WebkitAppearance' in document.documentElement.style) || + // is firebug? http://stackoverflow.com/a/398120/376773 + (typeof window !== 'undefined' && window && window.console && (console.firebug || (console.exception && console.table))) || + // is firefox >= v31? + // https://developer.mozilla.org/en-US/docs/Tools/Web_Console#Styling_messages + (typeof navigator !== 'undefined' && navigator && navigator.userAgent && navigator.userAgent.toLowerCase().match(/firefox\/(\d+)/) && parseInt(RegExp.$1, 10) >= 31) || + // double check webkit in userAgent just in case we are in a worker + (typeof navigator !== 'undefined' && navigator && navigator.userAgent && navigator.userAgent.toLowerCase().match(/applewebkit\/(\d+)/)); +} + +/** + * Map %j to `JSON.stringify()`, since no Web Inspectors do that by default. + */ + +exports.formatters.j = function(v) { + try { + return JSON.stringify(v); + } catch (err) { + return '[UnexpectedJSONParseError]: ' + err.message; + } +}; + + +/** + * Colorize log arguments if enabled. + * + * @api public + */ + +function formatArgs(args) { + var useColors = this.useColors; + + args[0] = (useColors ? '%c' : '') + + this.namespace + + (useColors ? ' %c' : ' ') + + args[0] + + (useColors ? '%c ' : ' ') + + '+' + exports.humanize(this.diff); + + if (!useColors) return; + + var c = 'color: ' + this.color; + args.splice(1, 0, c, 'color: inherit') + + // the final "%c" is somewhat tricky, because there could be other + // arguments passed either before or after the %c, so we need to + // figure out the correct index to insert the CSS into + var index = 0; + var lastC = 0; + args[0].replace(/%[a-zA-Z%]/g, function(match) { + if ('%%' === match) return; + index++; + if ('%c' === match) { + // we only are interested in the *last* %c + // (the user may have provided their own) + lastC = index; + } + }); + + args.splice(lastC, 0, c); +} + +/** + * Invokes `console.log()` when available. + * No-op when `console.log` is not a "function". + * + * @api public + */ + +function log() { + // this hackery is required for IE8/9, where + // the `console.log` function doesn't have 'apply' + return 'object' === typeof console + && console.log + && Function.prototype.apply.call(console.log, console, arguments); +} + +/** + * Save `namespaces`. + * + * @param {String} namespaces + * @api private + */ + +function save(namespaces) { + try { + if (null == namespaces) { + exports.storage.removeItem('debug'); + } else { + exports.storage.debug = namespaces; + } + } catch(e) {} +} + +/** + * Load `namespaces`. + * + * @return {String} returns the previously persisted debug modes + * @api private + */ + +function load() { + try { + return exports.storage.debug; + } catch(e) {} + + // If debug isn't set in LS, and we're in Electron, try to load $DEBUG + if (typeof process !== 'undefined' && 'env' in process) { + return process.env.DEBUG; + } +} + +/** + * Enable namespaces listed in `localStorage.debug` initially. + */ + +exports.enable(load()); + +/** + * Localstorage attempts to return the localstorage. + * + * This is necessary because safari throws + * when a user disables cookies/localstorage + * and you attempt to access it. + * + * @return {LocalStorage} + * @api private + */ + +function localstorage() { + try { + return window.localStorage; + } catch (e) {} +} + +}).call(this,require('_process')) + +},{"./debug":41,"_process":46}],41:[function(require,module,exports){ + +/** + * This is the common logic for both the Node.js and web browser + * implementations of `debug()`. + * + * Expose `debug()` as the module. + */ + +exports = module.exports = createDebug.debug = createDebug.default = createDebug; +exports.coerce = coerce; +exports.disable = disable; +exports.enable = enable; +exports.enabled = enabled; +exports.humanize = require('ms'); + +/** + * The currently active debug mode names, and names to skip. + */ + +exports.names = []; +exports.skips = []; + +/** + * Map of special "%n" handling functions, for the debug "format" argument. + * + * Valid key names are a single, lower or upper-case letter, i.e. "n" and "N". + */ + +exports.formatters = {}; + +/** + * Previous log timestamp. + */ + +var prevTime; + +/** + * Select a color. + * @param {String} namespace + * @return {Number} + * @api private + */ + +function selectColor(namespace) { + var hash = 0, i; + + for (i in namespace) { + hash = ((hash << 5) - hash) + namespace.charCodeAt(i); + hash |= 0; // Convert to 32bit integer + } + + return exports.colors[Math.abs(hash) % exports.colors.length]; +} + +/** + * Create a debugger with the given `namespace`. + * + * @param {String} namespace + * @return {Function} + * @api public + */ + +function createDebug(namespace) { + + function debug() { + // disabled? + if (!debug.enabled) return; + + var self = debug; + + // set `diff` timestamp + var curr = +new Date(); + var ms = curr - (prevTime || curr); + self.diff = ms; + self.prev = prevTime; + self.curr = curr; + prevTime = curr; + + // turn the `arguments` into a proper Array + var args = new Array(arguments.length); + for (var i = 0; i < args.length; i++) { + args[i] = arguments[i]; + } + + args[0] = exports.coerce(args[0]); + + if ('string' !== typeof args[0]) { + // anything else let's inspect with %O + args.unshift('%O'); + } + + // apply any `formatters` transformations + var index = 0; + args[0] = args[0].replace(/%([a-zA-Z%])/g, function(match, format) { + // if we encounter an escaped % then don't increase the array index + if (match === '%%') return match; + index++; + var formatter = exports.formatters[format]; + if ('function' === typeof formatter) { + var val = args[index]; + match = formatter.call(self, val); + + // now we need to remove `args[index]` since it's inlined in the `format` + args.splice(index, 1); + index--; + } + return match; + }); + + // apply env-specific formatting (colors, etc.) + exports.formatArgs.call(self, args); + + var logFn = debug.log || exports.log || console.log.bind(console); + logFn.apply(self, args); + } + + debug.namespace = namespace; + debug.enabled = exports.enabled(namespace); + debug.useColors = exports.useColors(); + debug.color = selectColor(namespace); + + // env-specific initialization logic for debug instances + if ('function' === typeof exports.init) { + exports.init(debug); + } + + return debug; +} + +/** + * Enables a debug mode by namespaces. This can include modes + * separated by a colon and wildcards. + * + * @param {String} namespaces + * @api public + */ + +function enable(namespaces) { + exports.save(namespaces); + + var split = (namespaces || '').split(/[\s,]+/); + var len = split.length; + + for (var i = 0; i < len; i++) { + if (!split[i]) continue; // ignore empty strings + namespaces = split[i].replace(/\*/g, '.*?'); + if (namespaces[0] === '-') { + exports.skips.push(new RegExp('^' + namespaces.substr(1) + '$')); + } else { + exports.names.push(new RegExp('^' + namespaces + '$')); + } + } +} + +/** + * Disable debug output. + * + * @api public + */ + +function disable() { + exports.enable(''); +} + +/** + * Returns true if the given mode name is enabled, false otherwise. + * + * @param {String} name + * @return {Boolean} + * @api public + */ + +function enabled(name) { + var i, len; + for (i = 0, len = exports.skips.length; i < len; i++) { + if (exports.skips[i].test(name)) { + return false; + } + } + for (i = 0, len = exports.names.length; i < len; i++) { + if (exports.names[i].test(name)) { + return true; + } + } + return false; +} + +/** + * Coerce `val`. + * + * @param {Mixed} val + * @return {Mixed} + * @api private + */ + +function coerce(val) { + if (val instanceof Error) return val.stack || val.message; + return val; +} + +},{"ms":45}],42:[function(require,module,exports){ +exports.read = function (buffer, offset, isLE, mLen, nBytes) { + var e, m + var eLen = nBytes * 8 - mLen - 1 + var eMax = (1 << eLen) - 1 + var eBias = eMax >> 1 + var nBits = -7 + var i = isLE ? (nBytes - 1) : 0 + var d = isLE ? -1 : 1 + var s = buffer[offset + i] + + i += d + + e = s & ((1 << (-nBits)) - 1) + s >>= (-nBits) + nBits += eLen + for (; nBits > 0; e = e * 256 + buffer[offset + i], i += d, nBits -= 8) {} + + m = e & ((1 << (-nBits)) - 1) + e >>= (-nBits) + nBits += mLen + for (; nBits > 0; m = m * 256 + buffer[offset + i], i += d, nBits -= 8) {} + + if (e === 0) { + e = 1 - eBias + } else if (e === eMax) { + return m ? NaN : ((s ? -1 : 1) * Infinity) + } else { + m = m + Math.pow(2, mLen) + e = e - eBias + } + return (s ? -1 : 1) * m * Math.pow(2, e - mLen) +} + +exports.write = function (buffer, value, offset, isLE, mLen, nBytes) { + var e, m, c + var eLen = nBytes * 8 - mLen - 1 + var eMax = (1 << eLen) - 1 + var eBias = eMax >> 1 + var rt = (mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0) + var i = isLE ? 0 : (nBytes - 1) + var d = isLE ? 1 : -1 + var s = value < 0 || (value === 0 && 1 / value < 0) ? 1 : 0 + + value = Math.abs(value) + + if (isNaN(value) || value === Infinity) { + m = isNaN(value) ? 1 : 0 + e = eMax + } else { + e = Math.floor(Math.log(value) / Math.LN2) + if (value * (c = Math.pow(2, -e)) < 1) { + e-- + c *= 2 + } + if (e + eBias >= 1) { + value += rt / c + } else { + value += rt * Math.pow(2, 1 - eBias) + } + if (value * c >= 2) { + e++ + c /= 2 + } + + if (e + eBias >= eMax) { + m = 0 + e = eMax + } else if (e + eBias >= 1) { + m = (value * c - 1) * Math.pow(2, mLen) + e = e + eBias + } else { + m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen) + e = 0 + } + } + + for (; mLen >= 8; buffer[offset + i] = m & 0xff, i += d, m /= 256, mLen -= 8) {} + + e = (e << mLen) | m + eLen += mLen + for (; eLen > 0; buffer[offset + i] = e & 0xff, i += d, e /= 256, eLen -= 8) {} + + buffer[offset + i - d] |= s * 128 +} + +},{}],43:[function(require,module,exports){ +var toString = {}.toString; + +module.exports = Array.isArray || function (arr) { + return toString.call(arr) == '[object Array]'; +}; + +},{}],44:[function(require,module,exports){ +/* + * $Id: base64.js,v 2.15 2014/04/05 12:58:57 dankogai Exp dankogai $ + * + * Licensed under the MIT license. + * http://opensource.org/licenses/mit-license + * + * References: + * http://en.wikipedia.org/wiki/Base64 + */ + +(function(global) { + 'use strict'; + // existing version for noConflict() + var _Base64 = global.Base64; + var version = "2.1.9"; + // if node.js, we use Buffer + var buffer; + if (typeof module !== 'undefined' && module.exports) { + try { + buffer = require('buffer').Buffer; + } catch (err) {} + } + // constants + var b64chars + = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'; + var b64tab = function(bin) { + var t = {}; + for (var i = 0, l = bin.length; i < l; i++) t[bin.charAt(i)] = i; + return t; + }(b64chars); + var fromCharCode = String.fromCharCode; + // encoder stuff + var cb_utob = function(c) { + if (c.length < 2) { + var cc = c.charCodeAt(0); + return cc < 0x80 ? c + : cc < 0x800 ? (fromCharCode(0xc0 | (cc >>> 6)) + + fromCharCode(0x80 | (cc & 0x3f))) + : (fromCharCode(0xe0 | ((cc >>> 12) & 0x0f)) + + fromCharCode(0x80 | ((cc >>> 6) & 0x3f)) + + fromCharCode(0x80 | ( cc & 0x3f))); + } else { + var cc = 0x10000 + + (c.charCodeAt(0) - 0xD800) * 0x400 + + (c.charCodeAt(1) - 0xDC00); + return (fromCharCode(0xf0 | ((cc >>> 18) & 0x07)) + + fromCharCode(0x80 | ((cc >>> 12) & 0x3f)) + + fromCharCode(0x80 | ((cc >>> 6) & 0x3f)) + + fromCharCode(0x80 | ( cc & 0x3f))); + } + }; + var re_utob = /[\uD800-\uDBFF][\uDC00-\uDFFFF]|[^\x00-\x7F]/g; + var utob = function(u) { + return u.replace(re_utob, cb_utob); + }; + var cb_encode = function(ccc) { + var padlen = [0, 2, 1][ccc.length % 3], + ord = ccc.charCodeAt(0) << 16 + | ((ccc.length > 1 ? ccc.charCodeAt(1) : 0) << 8) + | ((ccc.length > 2 ? ccc.charCodeAt(2) : 0)), + chars = [ + b64chars.charAt( ord >>> 18), + b64chars.charAt((ord >>> 12) & 63), + padlen >= 2 ? '=' : b64chars.charAt((ord >>> 6) & 63), + padlen >= 1 ? '=' : b64chars.charAt(ord & 63) + ]; + return chars.join(''); + }; + var btoa = global.btoa ? function(b) { + return global.btoa(b); + } : function(b) { + return b.replace(/[\s\S]{1,3}/g, cb_encode); + }; + var _encode = buffer ? function (u) { + return (u.constructor === buffer.constructor ? u : new buffer(u)) + .toString('base64') + } + : function (u) { return btoa(utob(u)) } + ; + var encode = function(u, urisafe) { + return !urisafe + ? _encode(String(u)) + : _encode(String(u)).replace(/[+\/]/g, function(m0) { + return m0 == '+' ? '-' : '_'; + }).replace(/=/g, ''); + }; + var encodeURI = function(u) { return encode(u, true) }; + // decoder stuff + var re_btou = new RegExp([ + '[\xC0-\xDF][\x80-\xBF]', + '[\xE0-\xEF][\x80-\xBF]{2}', + '[\xF0-\xF7][\x80-\xBF]{3}' + ].join('|'), 'g'); + var cb_btou = function(cccc) { + switch(cccc.length) { + case 4: + var cp = ((0x07 & cccc.charCodeAt(0)) << 18) + | ((0x3f & cccc.charCodeAt(1)) << 12) + | ((0x3f & cccc.charCodeAt(2)) << 6) + | (0x3f & cccc.charCodeAt(3)), + offset = cp - 0x10000; + return (fromCharCode((offset >>> 10) + 0xD800) + + fromCharCode((offset & 0x3FF) + 0xDC00)); + case 3: + return fromCharCode( + ((0x0f & cccc.charCodeAt(0)) << 12) + | ((0x3f & cccc.charCodeAt(1)) << 6) + | (0x3f & cccc.charCodeAt(2)) + ); + default: + return fromCharCode( + ((0x1f & cccc.charCodeAt(0)) << 6) + | (0x3f & cccc.charCodeAt(1)) + ); + } + }; + var btou = function(b) { + return b.replace(re_btou, cb_btou); + }; + var cb_decode = function(cccc) { + var len = cccc.length, + padlen = len % 4, + n = (len > 0 ? b64tab[cccc.charAt(0)] << 18 : 0) + | (len > 1 ? b64tab[cccc.charAt(1)] << 12 : 0) + | (len > 2 ? b64tab[cccc.charAt(2)] << 6 : 0) + | (len > 3 ? b64tab[cccc.charAt(3)] : 0), + chars = [ + fromCharCode( n >>> 16), + fromCharCode((n >>> 8) & 0xff), + fromCharCode( n & 0xff) + ]; + chars.length -= [0, 0, 2, 1][padlen]; + return chars.join(''); + }; + var atob = global.atob ? function(a) { + return global.atob(a); + } : function(a){ + return a.replace(/[\s\S]{1,4}/g, cb_decode); + }; + var _decode = buffer ? function(a) { + return (a.constructor === buffer.constructor + ? a : new buffer(a, 'base64')).toString(); + } + : function(a) { return btou(atob(a)) }; + var decode = function(a){ + return _decode( + String(a).replace(/[-_]/g, function(m0) { return m0 == '-' ? '+' : '/' }) + .replace(/[^A-Za-z0-9\+\/]/g, '') + ); + }; + var noConflict = function() { + var Base64 = global.Base64; + global.Base64 = _Base64; + return Base64; + }; + // export Base64 + global.Base64 = { + VERSION: version, + atob: atob, + btoa: btoa, + fromBase64: decode, + toBase64: encode, + utob: utob, + encode: encode, + encodeURI: encodeURI, + btou: btou, + decode: decode, + noConflict: noConflict + }; + // if ES5 is available, make Base64.extendString() available + if (typeof Object.defineProperty === 'function') { + var noEnum = function(v){ + return {value:v,enumerable:false,writable:true,configurable:true}; + }; + global.Base64.extendString = function () { + Object.defineProperty( + String.prototype, 'fromBase64', noEnum(function () { + return decode(this) + })); + Object.defineProperty( + String.prototype, 'toBase64', noEnum(function (urisafe) { + return encode(this, urisafe) + })); + Object.defineProperty( + String.prototype, 'toBase64URI', noEnum(function () { + return encode(this, true) + })); + }; + } + // that's it! + if (global['Meteor']) { + Base64 = global.Base64; // for normal export in Meteor.js + } +})(this); + +},{"buffer":39}],45:[function(require,module,exports){ +/** + * Helpers. + */ + +var s = 1000 +var m = s * 60 +var h = m * 60 +var d = h * 24 +var y = d * 365.25 + +/** + * Parse or format the given `val`. + * + * Options: + * + * - `long` verbose formatting [false] + * + * @param {String|Number} val + * @param {Object} options + * @throws {Error} throw an error if val is not a non-empty string or a number + * @return {String|Number} + * @api public + */ + +module.exports = function (val, options) { + options = options || {} + var type = typeof val + if (type === 'string' && val.length > 0) { + return parse(val) + } else if (type === 'number' && isNaN(val) === false) { + return options.long ? + fmtLong(val) : + fmtShort(val) + } + throw new Error('val is not a non-empty string or a valid number. val=' + JSON.stringify(val)) +} + +/** + * Parse the given `str` and return milliseconds. + * + * @param {String} str + * @return {Number} + * @api private + */ + +function parse(str) { + str = String(str) + if (str.length > 10000) { + return + } + var match = /^((?:\d+)?\.?\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|years?|yrs?|y)?$/i.exec(str) + if (!match) { + return + } + var n = parseFloat(match[1]) + var type = (match[2] || 'ms').toLowerCase() + switch (type) { + case 'years': + case 'year': + case 'yrs': + case 'yr': + case 'y': + return n * y + case 'days': + case 'day': + case 'd': + return n * d + case 'hours': + case 'hour': + case 'hrs': + case 'hr': + case 'h': + return n * h + case 'minutes': + case 'minute': + case 'mins': + case 'min': + case 'm': + return n * m + case 'seconds': + case 'second': + case 'secs': + case 'sec': + case 's': + return n * s + case 'milliseconds': + case 'millisecond': + case 'msecs': + case 'msec': + case 'ms': + return n + default: + return undefined + } +} + +/** + * Short format for `ms`. + * + * @param {Number} ms + * @return {String} + * @api private + */ + +function fmtShort(ms) { + if (ms >= d) { + return Math.round(ms / d) + 'd' + } + if (ms >= h) { + return Math.round(ms / h) + 'h' + } + if (ms >= m) { + return Math.round(ms / m) + 'm' + } + if (ms >= s) { + return Math.round(ms / s) + 's' + } + return ms + 'ms' +} + +/** + * Long format for `ms`. + * + * @param {Number} ms + * @return {String} + * @api private + */ + +function fmtLong(ms) { + return plural(ms, d, 'day') || + plural(ms, h, 'hour') || + plural(ms, m, 'minute') || + plural(ms, s, 'second') || + ms + ' ms' +} + +/** + * Pluralization helper. + */ + +function plural(ms, n, name) { + if (ms < n) { + return + } + if (ms < n * 1.5) { + return Math.floor(ms / n) + ' ' + name + } + return Math.ceil(ms / n) + ' ' + name + 's' +} + +},{}],46:[function(require,module,exports){ +// shim for using process in browser +var process = module.exports = {}; + +// cached from whatever global is present so that test runners that stub it +// don't break things. But we need to wrap it in a try catch in case it is +// wrapped in strict mode code which doesn't define any globals. It's inside a +// function because try/catches deoptimize in certain engines. + +var cachedSetTimeout; +var cachedClearTimeout; + +function defaultSetTimout() { + throw new Error('setTimeout has not been defined'); +} +function defaultClearTimeout () { + throw new Error('clearTimeout has not been defined'); +} +(function () { + try { + if (typeof setTimeout === 'function') { + cachedSetTimeout = setTimeout; + } else { + cachedSetTimeout = defaultSetTimout; + } + } catch (e) { + cachedSetTimeout = defaultSetTimout; + } + try { + if (typeof clearTimeout === 'function') { + cachedClearTimeout = clearTimeout; + } else { + cachedClearTimeout = defaultClearTimeout; + } + } catch (e) { + cachedClearTimeout = defaultClearTimeout; + } +} ()) +function runTimeout(fun) { + if (cachedSetTimeout === setTimeout) { + //normal enviroments in sane situations + return setTimeout(fun, 0); + } + // if setTimeout wasn't available but was latter defined + if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) { + cachedSetTimeout = setTimeout; + return setTimeout(fun, 0); + } + try { + // when when somebody has screwed with setTimeout but no I.E. maddness + return cachedSetTimeout(fun, 0); + } catch(e){ + try { + // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally + return cachedSetTimeout.call(null, fun, 0); + } catch(e){ + // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error + return cachedSetTimeout.call(this, fun, 0); + } + } + + +} +function runClearTimeout(marker) { + if (cachedClearTimeout === clearTimeout) { + //normal enviroments in sane situations + return clearTimeout(marker); + } + // if clearTimeout wasn't available but was latter defined + if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) { + cachedClearTimeout = clearTimeout; + return clearTimeout(marker); + } + try { + // when when somebody has screwed with setTimeout but no I.E. maddness + return cachedClearTimeout(marker); + } catch (e){ + try { + // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally + return cachedClearTimeout.call(null, marker); + } catch (e){ + // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error. + // Some versions of I.E. have different rules for clearTimeout vs setTimeout + return cachedClearTimeout.call(this, marker); + } + } + + + +} +var queue = []; +var draining = false; +var currentQueue; +var queueIndex = -1; + +function cleanUpNextTick() { + if (!draining || !currentQueue) { + return; + } + draining = false; + if (currentQueue.length) { + queue = currentQueue.concat(queue); + } else { + queueIndex = -1; + } + if (queue.length) { + drainQueue(); + } +} + +function drainQueue() { + if (draining) { + return; + } + var timeout = runTimeout(cleanUpNextTick); + draining = true; + + var len = queue.length; + while(len) { + currentQueue = queue; + queue = []; + while (++queueIndex < len) { + if (currentQueue) { + currentQueue[queueIndex].run(); + } + } + queueIndex = -1; + len = queue.length; + } + currentQueue = null; + draining = false; + runClearTimeout(timeout); +} + +process.nextTick = function (fun) { + var args = new Array(arguments.length - 1); + if (arguments.length > 1) { + for (var i = 1; i < arguments.length; i++) { + args[i - 1] = arguments[i]; + } + } + queue.push(new Item(fun, args)); + if (queue.length === 1 && !draining) { + runTimeout(drainQueue); + } +}; + +// v8 likes predictible objects +function Item(fun, array) { + this.fun = fun; + this.array = array; +} +Item.prototype.run = function () { + this.fun.apply(null, this.array); +}; +process.title = 'browser'; +process.browser = true; +process.env = {}; +process.argv = []; +process.version = ''; // empty string to avoid regexp issues +process.versions = {}; + +function noop() {} + +process.on = noop; +process.addListener = noop; +process.once = noop; +process.off = noop; +process.removeListener = noop; +process.removeAllListeners = noop; +process.emit = noop; + +process.binding = function (name) { + throw new Error('process.binding is not supported'); +}; + +process.cwd = function () { return '/' }; +process.chdir = function (dir) { + throw new Error('process.chdir is not supported'); +}; +process.umask = function() { return 0; }; + +},{}],47:[function(require,module,exports){ +(function (global){ +/*! https://mths.be/utf8js v2.1.2 by @mathias */ +;(function(root) { + + // Detect free variables `exports` + var freeExports = typeof exports == 'object' && exports; + + // Detect free variable `module` + var freeModule = typeof module == 'object' && 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; + } + + /*--------------------------------------------------------------------------*/ + + var stringFromCharCode = String.fromCharCode; + + // Taken from https://mths.be/punycode + function ucs2decode(string) { + var output = []; + var counter = 0; + var length = string.length; + var value; + var extra; + while (counter < length) { + value = string.charCodeAt(counter++); + if (value >= 0xD800 && value <= 0xDBFF && counter < length) { + // high surrogate, and there is a next character + extra = string.charCodeAt(counter++); + if ((extra & 0xFC00) == 0xDC00) { // low surrogate + output.push(((value & 0x3FF) << 10) + (extra & 0x3FF) + 0x10000); + } else { + // unmatched surrogate; only append this code unit, in case the next + // code unit is the high surrogate of a surrogate pair + output.push(value); + counter--; + } + } else { + output.push(value); + } + } + return output; + } + + // Taken from https://mths.be/punycode + function ucs2encode(array) { + var length = array.length; + var index = -1; + var value; + var output = ''; + while (++index < length) { + value = array[index]; + if (value > 0xFFFF) { + value -= 0x10000; + output += stringFromCharCode(value >>> 10 & 0x3FF | 0xD800); + value = 0xDC00 | value & 0x3FF; + } + output += stringFromCharCode(value); + } + return output; + } + + function checkScalarValue(codePoint) { + if (codePoint >= 0xD800 && codePoint <= 0xDFFF) { + throw Error( + 'Lone surrogate U+' + codePoint.toString(16).toUpperCase() + + ' is not a scalar value' + ); + } + } + /*--------------------------------------------------------------------------*/ + + function createByte(codePoint, shift) { + return stringFromCharCode(((codePoint >> shift) & 0x3F) | 0x80); + } + + function encodeCodePoint(codePoint) { + if ((codePoint & 0xFFFFFF80) == 0) { // 1-byte sequence + return stringFromCharCode(codePoint); + } + var symbol = ''; + if ((codePoint & 0xFFFFF800) == 0) { // 2-byte sequence + symbol = stringFromCharCode(((codePoint >> 6) & 0x1F) | 0xC0); + } + else if ((codePoint & 0xFFFF0000) == 0) { // 3-byte sequence + checkScalarValue(codePoint); + symbol = stringFromCharCode(((codePoint >> 12) & 0x0F) | 0xE0); + symbol += createByte(codePoint, 6); + } + else if ((codePoint & 0xFFE00000) == 0) { // 4-byte sequence + symbol = stringFromCharCode(((codePoint >> 18) & 0x07) | 0xF0); + symbol += createByte(codePoint, 12); + symbol += createByte(codePoint, 6); + } + symbol += stringFromCharCode((codePoint & 0x3F) | 0x80); + return symbol; + } + + function utf8encode(string) { + var codePoints = ucs2decode(string); + var length = codePoints.length; + var index = -1; + var codePoint; + var byteString = ''; + while (++index < length) { + codePoint = codePoints[index]; + byteString += encodeCodePoint(codePoint); + } + return byteString; + } + + /*--------------------------------------------------------------------------*/ + + function readContinuationByte() { + if (byteIndex >= byteCount) { + throw Error('Invalid byte index'); + } + + var continuationByte = byteArray[byteIndex] & 0xFF; + byteIndex++; + + if ((continuationByte & 0xC0) == 0x80) { + return continuationByte & 0x3F; + } + + // If we end up here, it’s not a continuation byte + throw Error('Invalid continuation byte'); + } + + function decodeSymbol() { + var byte1; + var byte2; + var byte3; + var byte4; + var codePoint; + + if (byteIndex > byteCount) { + throw Error('Invalid byte index'); + } + + if (byteIndex == byteCount) { + return false; + } + + // Read first byte + byte1 = byteArray[byteIndex] & 0xFF; + byteIndex++; + + // 1-byte sequence (no continuation bytes) + if ((byte1 & 0x80) == 0) { + return byte1; + } + + // 2-byte sequence + if ((byte1 & 0xE0) == 0xC0) { + byte2 = readContinuationByte(); + codePoint = ((byte1 & 0x1F) << 6) | byte2; + if (codePoint >= 0x80) { + return codePoint; + } else { + throw Error('Invalid continuation byte'); + } + } + + // 3-byte sequence (may include unpaired surrogates) + if ((byte1 & 0xF0) == 0xE0) { + byte2 = readContinuationByte(); + byte3 = readContinuationByte(); + codePoint = ((byte1 & 0x0F) << 12) | (byte2 << 6) | byte3; + if (codePoint >= 0x0800) { + checkScalarValue(codePoint); + return codePoint; + } else { + throw Error('Invalid continuation byte'); + } + } + + // 4-byte sequence + if ((byte1 & 0xF8) == 0xF0) { + byte2 = readContinuationByte(); + byte3 = readContinuationByte(); + byte4 = readContinuationByte(); + codePoint = ((byte1 & 0x07) << 0x12) | (byte2 << 0x0C) | + (byte3 << 0x06) | byte4; + if (codePoint >= 0x010000 && codePoint <= 0x10FFFF) { + return codePoint; + } + } + + throw Error('Invalid UTF-8 detected'); + } + + var byteArray; + var byteCount; + var byteIndex; + function utf8decode(byteString) { + byteArray = ucs2decode(byteString); + byteCount = byteArray.length; + byteIndex = 0; + var codePoints = []; + var tmp; + while ((tmp = decodeSymbol()) !== false) { + codePoints.push(tmp); + } + return ucs2encode(codePoints); + } + + /*--------------------------------------------------------------------------*/ + + var utf8 = { + 'version': '2.1.2', + 'encode': utf8encode, + 'decode': utf8decode + }; + + // 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 utf8; + }); + } else if (freeExports && !freeExports.nodeType) { + if (freeModule) { // in Node.js or RingoJS v0.8.0+ + freeModule.exports = utf8; + } else { // in Narwhal or RingoJS v0.7.0- + var object = {}; + var hasOwnProperty = object.hasOwnProperty; + for (var key in utf8) { + hasOwnProperty.call(utf8, key) && (freeExports[key] = utf8[key]); + } + } + } else { // in Rhino or a web browser + root.utf8 = utf8; + } + +}(this)); + +}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {}) + +},{}]},{},[2])(2) +}); + +//# sourceMappingURL=GitHub.bundle.js.map diff --git a/dist/GitHub.bundle.js.map b/dist/GitHub.bundle.js.map new file mode 100644 index 00000000..245e776f --- /dev/null +++ b/dist/GitHub.bundle.js.map @@ -0,0 +1 @@ +{"version":3,"sources":["node_modules/browser-pack/_prelude.js","lib/Gist.js","lib/GitHub.js","lib/Issue.js","lib/Markdown.js","lib/Organization.js","lib/Project.js","lib/RateLimit.js","lib/Repository.js","lib/Requestable.js","lib/Search.js","lib/Team.js","lib/User.js","node_modules/axios/index.js","node_modules/axios/lib/adapters/xhr.js","node_modules/axios/lib/axios.js","node_modules/axios/lib/cancel/Cancel.js","node_modules/axios/lib/cancel/CancelToken.js","node_modules/axios/lib/cancel/isCancel.js","node_modules/axios/lib/core/Axios.js","node_modules/axios/lib/core/InterceptorManager.js","node_modules/axios/lib/core/createError.js","node_modules/axios/lib/core/dispatchRequest.js","node_modules/axios/lib/core/enhanceError.js","node_modules/axios/lib/core/settle.js","node_modules/axios/lib/core/transformData.js","node_modules/axios/lib/defaults.js","node_modules/axios/lib/helpers/bind.js","node_modules/axios/lib/helpers/btoa.js","node_modules/axios/lib/helpers/buildURL.js","node_modules/axios/lib/helpers/combineURLs.js","node_modules/axios/lib/helpers/cookies.js","node_modules/axios/lib/helpers/isAbsoluteURL.js","node_modules/axios/lib/helpers/isURLSameOrigin.js","node_modules/axios/lib/helpers/normalizeHeaderName.js","node_modules/axios/lib/helpers/parseHeaders.js","node_modules/axios/lib/helpers/spread.js","node_modules/axios/lib/utils.js","node_modules/base64-js/index.js","node_modules/buffer/index.js","node_modules/debug/src/browser.js","node_modules/debug/src/debug.js","node_modules/ieee754/index.js","node_modules/isarray/index.js","node_modules/js-base64/base64.js","node_modules/ms/index.js","node_modules/process/browser.js","node_modules/utf8/utf8.js"],"names":[],"mappings":"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AAK,QAAL,CAAc,MAAd,EAAsB,aAAtB,EAAqC,OAArC,EAA8C,EAA9C,CAAP;AACF;;;;;;AAGJ,OAAO,OAAP,GAAiB,IAAjB;;;ACtMA;;;ACAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;ACjLA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACpDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACnBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACzDA;AACA;AACA;AACA;AACA;AACA;;ACLA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACrFA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACpDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC/EA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACnBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACzBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;ACpBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;AC7FA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACXA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACpCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACpEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACZA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACrDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACdA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACpEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACZA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACr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lHA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;AC7vDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;ACtLA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACvMA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACpFA;AACA;AACA;AACA;AACA;AACA;;ACLA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AClMA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACrJA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;ACpLA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA","file":"GitHub.bundle.js","sourcesContent":["(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require==\"function\"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error(\"Cannot find module '\"+o+\"'\");throw f.code=\"MODULE_NOT_FOUND\",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require==\"function\"&&require;for(var o=0;o {\n this.__id = response.data.id;\n return response;\n });\n }\n\n /**\n * Delete a gist.\n * @see https://developer.github.com/v3/gists/#delete-a-gist\n * @param {Requestable.callback} [cb] - will receive true if the request succeeds\n * @return {Promise} - the Promise for the http request\n */\n delete(cb) {\n return this._request('DELETE', `/gists/${this.__id}`, null, cb);\n }\n\n /**\n * Fork a gist.\n * @see https://developer.github.com/v3/gists/#fork-a-gist\n * @param {Requestable.callback} [cb] - the function that will receive the gist\n * @return {Promise} - the Promise for the http request\n */\n fork(cb) {\n return this._request('POST', `/gists/${this.__id}/forks`, null, cb);\n }\n\n /**\n * Update a gist.\n * @see https://developer.github.com/v3/gists/#edit-a-gist\n * @param {Object} gist - the new data for the gist\n * @param {Requestable.callback} [cb] - the function that receives the API result\n * @return {Promise} - the Promise for the http request\n */\n update(gist, cb) {\n return this._request('PATCH', `/gists/${this.__id}`, gist, cb);\n }\n\n /**\n * Star a gist.\n * @see https://developer.github.com/v3/gists/#star-a-gist\n * @param {Requestable.callback} [cb] - will receive true if the request is successful\n * @return {Promise} - the Promise for the http request\n */\n star(cb) {\n return this._request('PUT', `/gists/${this.__id}/star`, null, cb);\n }\n\n /**\n * Unstar a gist.\n * @see https://developer.github.com/v3/gists/#unstar-a-gist\n * @param {Requestable.callback} [cb] - will receive true if the request is successful\n * @return {Promise} - the Promise for the http request\n */\n unstar(cb) {\n return this._request('DELETE', `/gists/${this.__id}/star`, null, cb);\n }\n\n /**\n * Check if a gist is starred by the user.\n * @see https://developer.github.com/v3/gists/#check-if-a-gist-is-starred\n * @param {Requestable.callback} [cb] - will receive true if the gist is starred and false if the gist is not starred\n * @return {Promise} - the Promise for the http request\n */\n isStarred(cb) {\n return this._request204or404(`/gists/${this.__id}/star`, null, cb);\n }\n\n /**\n * List the gist's commits\n * @see https://developer.github.com/v3/gists/#list-gist-commits\n * @param {Requestable.callback} [cb] - will receive the array of commits\n * @return {Promise} - the Promise for the http request\n */\n listCommits(cb) {\n return this._requestAllPages(`/gists/${this.__id}/commits`, null, cb);\n }\n\n /**\n * Fetch one of the gist's revision.\n * @see https://developer.github.com/v3/gists/#get-a-specific-revision-of-a-gist\n * @param {string} revision - the id of the revision\n * @param {Requestable.callback} [cb] - will receive the revision\n * @return {Promise} - the Promise for the http request\n */\n getRevision(revision, cb) {\n return this._request('GET', `/gists/${this.__id}/${revision}`, null, cb);\n }\n\n /**\n * List the gist's comments\n * @see https://developer.github.com/v3/gists/comments/#list-comments-on-a-gist\n * @param {Requestable.callback} [cb] - will receive the array of comments\n * @return {Promise} - the promise for the http request\n */\n listComments(cb) {\n return this._requestAllPages(`/gists/${this.__id}/comments`, null, cb);\n }\n\n /**\n * Fetch one of the gist's comments\n * @see https://developer.github.com/v3/gists/comments/#get-a-single-comment\n * @param {number} comment - the id of the comment\n * @param {Requestable.callback} [cb] - will receive the comment\n * @return {Promise} - the Promise for the http request\n */\n getComment(comment, cb) {\n return this._request('GET', `/gists/${this.__id}/comments/${comment}`, null, cb);\n }\n\n /**\n * Comment on a gist\n * @see https://developer.github.com/v3/gists/comments/#create-a-comment\n * @param {string} comment - the comment to add\n * @param {Requestable.callback} [cb] - the function that receives the API result\n * @return {Promise} - the Promise for the http request\n */\n createComment(comment, cb) {\n return this._request('POST', `/gists/${this.__id}/comments`, {body: comment}, cb);\n }\n\n /**\n * Edit a comment on the gist\n * @see https://developer.github.com/v3/gists/comments/#edit-a-comment\n * @param {number} comment - the id of the comment\n * @param {string} body - the new comment\n * @param {Requestable.callback} [cb] - will receive the modified comment\n * @return {Promise} - the promise for the http request\n */\n editComment(comment, body, cb) {\n return this._request('PATCH', `/gists/${this.__id}/comments/${comment}`, {body: body}, cb);\n }\n\n /**\n * Delete a comment on the gist.\n * @see https://developer.github.com/v3/gists/comments/#delete-a-comment\n * @param {number} comment - the id of the comment\n * @param {Requestable.callback} [cb] - will receive true if the request succeeds\n * @return {Promise} - the Promise for the http request\n */\n deleteComment(comment, cb) {\n return this._request('DELETE', `/gists/${this.__id}/comments/${comment}`, null, cb);\n }\n}\n\nmodule.exports = Gist;\n","/**\n * @file\n * @copyright 2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n * Github.js is freely distributable.\n */\n/* eslint valid-jsdoc: [\"error\", {\"requireReturnDescription\": false}] */\n\nimport Gist from './Gist';\nimport User from './User';\nimport Issue from './Issue';\nimport Search from './Search';\nimport RateLimit from './RateLimit';\nimport Repository from './Repository';\nimport Organization from './Organization';\nimport Team from './Team';\nimport Markdown from './Markdown';\nimport Project from './Project';\n\n/**\n * GitHub encapsulates the functionality to create various API wrapper objects.\n */\nclass GitHub {\n /**\n * Create a new GitHub.\n * @param {Requestable.auth} [auth] - the credentials to authenticate to Github. If auth is\n * not provided requests will be made unauthenticated\n * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n */\n constructor(auth, apiBase = 'https://api.github.com') {\n this.__apiBase = apiBase;\n this.__auth = auth || {};\n }\n\n /**\n * Create a new Gist wrapper\n * @param {number} [id] - the id for the gist, leave undefined when creating a new gist\n * @return {Gist}\n */\n getGist(id) {\n return new Gist(id, this.__auth, this.__apiBase);\n }\n\n /**\n * Create a new User wrapper\n * @param {string} [user] - the name of the user to get information about\n * leave undefined for the authenticated user\n * @return {User}\n */\n getUser(user) {\n return new User(user, this.__auth, this.__apiBase);\n }\n\n /**\n * Create a new Organization wrapper\n * @param {string} organization - the name of the organization\n * @return {Organization}\n */\n getOrganization(organization) {\n return new Organization(organization, this.__auth, this.__apiBase);\n }\n\n /**\n * create a new Team wrapper\n * @param {string} teamId - the name of the team\n * @return {team}\n */\n getTeam(teamId) {\n return new Team(teamId, this.__auth, this.__apiBase);\n }\n\n /**\n * Create a new Repository wrapper\n * @param {string} user - the user who owns the respository\n * @param {string} repo - the name of the repository\n * @return {Repository}\n */\n getRepo(user, repo) {\n return new Repository(this._getFullName(user, repo), this.__auth, this.__apiBase);\n }\n\n /**\n * Create a new Issue wrapper\n * @param {string} user - the user who owns the respository\n * @param {string} repo - the name of the repository\n * @return {Issue}\n */\n getIssues(user, repo) {\n return new Issue(this._getFullName(user, repo), this.__auth, this.__apiBase);\n }\n\n /**\n * Create a new Search wrapper\n * @param {string} query - the query to search for\n * @return {Search}\n */\n search(query) {\n return new Search(query, this.__auth, this.__apiBase);\n }\n\n /**\n * Create a new RateLimit wrapper\n * @return {RateLimit}\n */\n getRateLimit() {\n return new RateLimit(this.__auth, this.__apiBase);\n }\n\n /**\n * Create a new Markdown wrapper\n * @return {Markdown}\n */\n getMarkdown() {\n return new Markdown(this.__auth, this.__apiBase);\n }\n\n /**\n * Create a new Project wrapper\n * @param {string} id - the id of the project\n * @return {Markdown}\n */\n getProject(id) {\n return new Project(id, this.__auth, this.__apiBase);\n }\n\n /**\n * Computes the full repository name\n * @param {string} user - the username (or the full name)\n * @param {string} repo - the repository name, must not be passed if `user` is the full name\n * @return {string} the repository's full name\n */\n _getFullName(user, repo) {\n let fullname = user;\n\n if (repo) {\n fullname = `${user}/${repo}`;\n }\n\n return fullname;\n }\n}\n\nmodule.exports = GitHub;\n","/**\n * @file\n * @copyright 2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n * Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\n\n/**\n * Issue wraps the functionality to get issues for repositories\n */\nclass Issue extends Requestable {\n /**\n * Create a new Issue\n * @param {string} repository - the full name of the repository (`:user/:repo`) to get issues for\n * @param {Requestable.auth} [auth] - information required to authenticate to Github\n * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n */\n constructor(repository, auth, apiBase) {\n super(auth, apiBase);\n this.__repository = repository;\n }\n\n /**\n * Create a new issue\n * @see https://developer.github.com/v3/issues/#create-an-issue\n * @param {Object} issueData - the issue to create\n * @param {Requestable.callback} [cb] - will receive the created issue\n * @return {Promise} - the promise for the http request\n */\n createIssue(issueData, cb) {\n return this._request('POST', `/repos/${this.__repository}/issues`, issueData, cb);\n }\n\n /**\n * List the issues for the repository\n * @see https://developer.github.com/v3/issues/#list-issues-for-a-repository\n * @param {Object} options - filtering options\n * @param {Requestable.callback} [cb] - will receive the array of issues\n * @return {Promise} - the promise for the http request\n */\n listIssues(options, cb) {\n return this._requestAllPages(`/repos/${this.__repository}/issues`, options, cb);\n }\n\n /**\n * List the events for an issue\n * @see https://developer.github.com/v3/issues/events/#list-events-for-an-issue\n * @param {number} issue - the issue to get events for\n * @param {Requestable.callback} [cb] - will receive the list of events\n * @return {Promise} - the promise for the http request\n */\n listIssueEvents(issue, cb) {\n return this._request('GET', `/repos/${this.__repository}/issues/${issue}/events`, null, cb);\n }\n\n /**\n * List comments on an issue\n * @see https://developer.github.com/v3/issues/comments/#list-comments-on-an-issue\n * @param {number} issue - the id of the issue to get comments from\n * @param {Requestable.callback} [cb] - will receive the comments\n * @return {Promise} - the promise for the http request\n */\n listIssueComments(issue, cb) {\n return this._request('GET', `/repos/${this.__repository}/issues/${issue}/comments`, null, cb);\n }\n\n /**\n * Get a single comment on an issue\n * @see https://developer.github.com/v3/issues/comments/#get-a-single-comment\n * @param {number} id - the comment id to get\n * @param {Requestable.callback} [cb] - will receive the comment\n * @return {Promise} - the promise for the http request\n */\n getIssueComment(id, cb) {\n return this._request('GET', `/repos/${this.__repository}/issues/comments/${id}`, null, cb);\n }\n\n /**\n * Comment on an issue\n * @see https://developer.github.com/v3/issues/comments/#create-a-comment\n * @param {number} issue - the id of the issue to comment on\n * @param {string} comment - the comment to add\n * @param {Requestable.callback} [cb] - will receive the created comment\n * @return {Promise} - the promise for the http request\n */\n createIssueComment(issue, comment, cb) {\n return this._request('POST', `/repos/${this.__repository}/issues/${issue}/comments`, {body: comment}, cb);\n }\n\n /**\n * Edit a comment on an issue\n * @see https://developer.github.com/v3/issues/comments/#edit-a-comment\n * @param {number} id - the comment id to edit\n * @param {string} comment - the comment to edit\n * @param {Requestable.callback} [cb] - will receive the edited comment\n * @return {Promise} - the promise for the http request\n */\n editIssueComment(id, comment, cb) {\n return this._request('PATCH', `/repos/${this.__repository}/issues/comments/${id}`, {body: comment}, cb);\n }\n\n /**\n * Delete a comment on an issue\n * @see https://developer.github.com/v3/issues/comments/#delete-a-comment\n * @param {number} id - the comment id to delete\n * @param {Requestable.callback} [cb] - will receive true if the request is successful\n * @return {Promise} - the promise for the http request\n */\n deleteIssueComment(id, cb) {\n return this._request('DELETE', `/repos/${this.__repository}/issues/comments/${id}`, null, cb);\n }\n\n /**\n * Edit an issue\n * @see https://developer.github.com/v3/issues/#edit-an-issue\n * @param {number} issue - the issue number to edit\n * @param {Object} issueData - the new issue data\n * @param {Requestable.callback} [cb] - will receive the modified issue\n * @return {Promise} - the promise for the http request\n */\n editIssue(issue, issueData, cb) {\n return this._request('PATCH', `/repos/${this.__repository}/issues/${issue}`, issueData, cb);\n }\n\n /**\n * Get a particular issue\n * @see https://developer.github.com/v3/issues/#get-a-single-issue\n * @param {number} issue - the issue number to fetch\n * @param {Requestable.callback} [cb] - will receive the issue\n * @return {Promise} - the promise for the http request\n */\n getIssue(issue, cb) {\n return this._request('GET', `/repos/${this.__repository}/issues/${issue}`, null, cb);\n }\n\n /**\n * List the milestones for the repository\n * @see https://developer.github.com/v3/issues/milestones/#list-milestones-for-a-repository\n * @param {Object} options - filtering options\n * @param {Requestable.callback} [cb] - will receive the array of milestones\n * @return {Promise} - the promise for the http request\n */\n listMilestones(options, cb) {\n return this._request('GET', `/repos/${this.__repository}/milestones`, options, cb);\n }\n\n /**\n * Get a milestone\n * @see https://developer.github.com/v3/issues/milestones/#get-a-single-milestone\n * @param {string} milestone - the id of the milestone to fetch\n * @param {Requestable.callback} [cb] - will receive the milestone\n * @return {Promise} - the promise for the http request\n */\n getMilestone(milestone, cb) {\n return this._request('GET', `/repos/${this.__repository}/milestones/${milestone}`, null, cb);\n }\n\n /**\n * Create a new milestone\n * @see https://developer.github.com/v3/issues/milestones/#create-a-milestone\n * @param {Object} milestoneData - the milestone definition\n * @param {Requestable.callback} [cb] - will receive the milestone\n * @return {Promise} - the promise for the http request\n */\n createMilestone(milestoneData, cb) {\n return this._request('POST', `/repos/${this.__repository}/milestones`, milestoneData, cb);\n }\n\n /**\n * Edit a milestone\n * @see https://developer.github.com/v3/issues/milestones/#update-a-milestone\n * @param {string} milestone - the id of the milestone to edit\n * @param {Object} milestoneData - the updates to make to the milestone\n * @param {Requestable.callback} [cb] - will receive the updated milestone\n * @return {Promise} - the promise for the http request\n */\n editMilestone(milestone, milestoneData, cb) {\n return this._request('PATCH', `/repos/${this.__repository}/milestones/${milestone}`, milestoneData, cb);\n }\n\n /**\n * Delete a milestone (this is distinct from closing a milestone)\n * @see https://developer.github.com/v3/issues/milestones/#delete-a-milestone\n * @param {string} milestone - the id of the milestone to delete\n * @param {Requestable.callback} [cb] - will receive the status\n * @return {Promise} - the promise for the http request\n */\n deleteMilestone(milestone, cb) {\n return this._request('DELETE', `/repos/${this.__repository}/milestones/${milestone}`, null, cb);\n }\n\n /**\n * Create a new label\n * @see https://developer.github.com/v3/issues/labels/#create-a-label\n * @param {Object} labelData - the label definition\n * @param {Requestable.callback} [cb] - will receive the object representing the label\n * @return {Promise} - the promise for the http request\n */\n createLabel(labelData, cb) {\n return this._request('POST', `/repos/${this.__repository}/labels`, labelData, cb);\n }\n\n /**\n * List the labels for the repository\n * @see https://developer.github.com/v3/issues/labels/#list-all-labels-for-this-repository\n * @param {Object} options - filtering options\n * @param {Requestable.callback} [cb] - will receive the array of labels\n * @return {Promise} - the promise for the http request\n */\n listLabels(options, cb) {\n return this._request('GET', `/repos/${this.__repository}/labels`, options, cb);\n }\n\n /**\n * Get a label\n * @see https://developer.github.com/v3/issues/labels/#get-a-single-label\n * @param {string} label - the name of the label to fetch\n * @param {Requestable.callback} [cb] - will receive the label\n * @return {Promise} - the promise for the http request\n */\n getLabel(label, cb) {\n return this._request('GET', `/repos/${this.__repository}/labels/${label}`, null, cb);\n }\n\n /**\n * Edit a label\n * @see https://developer.github.com/v3/issues/labels/#update-a-label\n * @param {string} label - the name of the label to edit\n * @param {Object} labelData - the updates to make to the label\n * @param {Requestable.callback} [cb] - will receive the updated label\n * @return {Promise} - the promise for the http request\n */\n editLabel(label, labelData, cb) {\n return this._request('PATCH', `/repos/${this.__repository}/labels/${label}`, labelData, cb);\n }\n\n /**\n * Delete a label\n * @see https://developer.github.com/v3/issues/labels/#delete-a-label\n * @param {string} label - the name of the label to delete\n * @param {Requestable.callback} [cb] - will receive the status\n * @return {Promise} - the promise for the http request\n */\n deleteLabel(label, cb) {\n return this._request('DELETE', `/repos/${this.__repository}/labels/${label}`, null, cb);\n }\n}\n\nmodule.exports = Issue;\n","/**\n * @file\n * @copyright 2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n * Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\n\n/**\n * Renders html from Markdown text\n */\nclass Markdown extends Requestable {\n /**\n * construct a Markdown\n * @param {Requestable.auth} auth - the credentials to authenticate to GitHub\n * @param {string} [apiBase] - the base Github API URL\n * @return {Promise} - the promise for the http request\n */\n constructor(auth, apiBase) {\n super(auth, apiBase);\n }\n\n /**\n * Render html from Markdown text.\n * @see https://developer.github.com/v3/markdown/#render-an-arbitrary-markdown-document\n * @param {Object} options - conversion options\n * @param {string} [options.text] - the markdown text to convert\n * @param {string} [options.mode=markdown] - can be either `markdown` or `gfm`\n * @param {string} [options.context] - repository name if mode is gfm\n * @param {Requestable.callback} [cb] - will receive the converted html\n * @return {Promise} - the promise for the http request\n */\n render(options, cb) {\n return this._request('POST', '/markdown', options, cb);\n }\n}\n\nmodule.exports = Markdown;\n","/**\n * @file\n * @copyright 2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n * Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\n\n/**\n * Organization encapsulates the functionality to create repositories in organizations\n */\nclass Organization extends Requestable {\n /**\n * Create a new Organization\n * @param {string} organization - the name of the organization\n * @param {Requestable.auth} [auth] - information required to authenticate to Github\n * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n */\n constructor(organization, auth, apiBase) {\n super(auth, apiBase);\n this.__name = organization;\n }\n\n /**\n * Create a repository in an organization\n * @see https://developer.github.com/v3/repos/#create\n * @param {Object} options - the repository definition\n * @param {Requestable.callback} [cb] - will receive the created repository\n * @return {Promise} - the promise for the http request\n */\n createRepo(options, cb) {\n return this._request('POST', `/orgs/${this.__name}/repos`, options, cb);\n }\n\n /**\n * List the repositories in an organization\n * @see https://developer.github.com/v3/repos/#list-organization-repositories\n * @param {Requestable.callback} [cb] - will receive the list of repositories\n * @return {Promise} - the promise for the http request\n */\n getRepos(cb) {\n let requestOptions = this._getOptionsWithDefaults({direction: 'desc'});\n\n return this._requestAllPages(`/orgs/${this.__name}/repos`, requestOptions, cb);\n }\n\n /**\n * Query if the user is a member or not\n * @param {string} username - the user in question\n * @param {Requestable.callback} [cb] - will receive true if the user is a member\n * @return {Promise} - the promise for the http request\n */\n isMember(username, cb) {\n return this._request204or404(`/orgs/${this.__name}/members/${username}`, null, cb);\n }\n\n /**\n * List the users who are members of the company\n * @see https://developer.github.com/v3/orgs/members/#members-list\n * @param {object} options - filtering options\n * @param {string} [options.filter=all] - can be either `2fa_disabled` or `all`\n * @param {string} [options.role=all] - can be one of: `all`, `admin`, or `member`\n * @param {Requestable.callback} [cb] - will receive the list of users\n * @return {Promise} - the promise for the http request\n */\n listMembers(options, cb) {\n return this._request('GET', `/orgs/${this.__name}/members`, options, cb);\n }\n\n /**\n * List the Teams in the Organization\n * @see https://developer.github.com/v3/orgs/teams/#list-teams\n * @param {Requestable.callback} [cb] - will receive the list of teams\n * @return {Promise} - the promise for the http request\n */\n getTeams(cb) {\n return this._requestAllPages(`/orgs/${this.__name}/teams`, undefined, cb);\n }\n\n /**\n * Create a team\n * @see https://developer.github.com/v3/orgs/teams/#create-team\n * @param {object} options - Team creation parameters\n * @param {string} options.name - The name of the team\n * @param {string} [options.description] - Team description\n * @param {string} [options.repo_names] - Repos to add the team to\n * @param {string} [options.privacy=secret] - The level of privacy the team should have. Can be either one\n * of: `secret`, or `closed`\n * @param {Requestable.callback} [cb] - will receive the created team\n * @return {Promise} - the promise for the http request\n */\n createTeam(options, cb) {\n return this._request('POST', `/orgs/${this.__name}/teams`, options, cb);\n }\n\n /**\n * Get information about all projects\n * @see https://developer.github.com/v3/projects/#list-organization-projects\n * @param {Requestable.callback} [cb] - will receive the list of projects\n * @return {Promise} - the promise for the http request\n */\n listProjects(cb) {\n return this._requestAllPages(`/orgs/${this.__name}/projects`, {AcceptHeader: 'inertia-preview'}, cb);\n }\n\n /**\n * Create a new project\n * @see https://developer.github.com/v3/repos/projects/#create-a-project\n * @param {Object} options - the description of the project\n * @param {Requestable.callback} cb - will receive the newly created project\n * @return {Promise} - the promise for the http request\n */\n createProject(options, cb) {\n options = options || {};\n options.AcceptHeader = 'inertia-preview';\n return this._request('POST', `/orgs/${this.__name}/projects`, options, cb);\n }\n}\n\nmodule.exports = Organization;\n","/**\n * @file\n * @copyright 2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n * Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\n\n/**\n * Project encapsulates the functionality to create, query, and modify cards and columns.\n */\nclass Project extends Requestable {\n /**\n * Create a Project.\n * @param {string} id - the id of the project\n * @param {Requestable.auth} [auth] - information required to authenticate to Github\n * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n */\n constructor(id, auth, apiBase) {\n super(auth, apiBase, 'inertia-preview');\n this.__id = id;\n }\n\n /**\n * Get information about a project\n * @see https://developer.github.com/v3/projects/#get-a-project\n * @param {Requestable.callback} cb - will receive the project information\n * @return {Promise} - the promise for the http request\n */\n getProject(cb) {\n return this._request('GET', `/projects/${this.__id}`, null, cb);\n }\n\n /**\n * Edit a project\n * @see https://developer.github.com/v3/projects/#update-a-project\n * @param {Object} options - the description of the project\n * @param {Requestable.callback} cb - will receive the modified project\n * @return {Promise} - the promise for the http request\n */\n updateProject(options, cb) {\n return this._request('PATCH', `/projects/${this.__id}`, options, cb);\n }\n\n /**\n * Delete a project\n * @see https://developer.github.com/v3/projects/#delete-a-project\n * @param {Requestable.callback} cb - will receive true if the operation is successful\n * @return {Promise} - the promise for the http request\n */\n deleteProject(cb) {\n return this._request('DELETE', `/projects/${this.__id}`, null, cb);\n }\n\n /**\n * Get information about all columns of a project\n * @see https://developer.github.com/v3/projects/columns/#list-project-columns\n * @param {Requestable.callback} [cb] - will receive the list of columns\n * @return {Promise} - the promise for the http request\n */\n listProjectColumns(cb) {\n return this._requestAllPages(`/projects/${this.__id}/columns`, null, cb);\n }\n\n /**\n * Get information about a column\n * @see https://developer.github.com/v3/projects/columns/#get-a-project-column\n * @param {string} colId - the id of the column\n * @param {Requestable.callback} cb - will receive the column information\n * @return {Promise} - the promise for the http request\n */\n getProjectColumn(colId, cb) {\n return this._request('GET', `/projects/columns/${colId}`, null, cb);\n }\n\n /**\n * Create a new column\n * @see https://developer.github.com/v3/projects/columns/#create-a-project-column\n * @param {Object} options - the description of the column\n * @param {Requestable.callback} cb - will receive the newly created column\n * @return {Promise} - the promise for the http request\n */\n createProjectColumn(options, cb) {\n return this._request('POST', `/projects/${this.__id}/columns`, options, cb);\n }\n\n /**\n * Edit a column\n * @see https://developer.github.com/v3/projects/columns/#update-a-project-column\n * @param {string} colId - the column id\n * @param {Object} options - the description of the column\n * @param {Requestable.callback} cb - will receive the modified column\n * @return {Promise} - the promise for the http request\n */\n updateProjectColumn(colId, options, cb) {\n return this._request('PATCH', `/projects/columns/${colId}`, options, cb);\n }\n\n /**\n * Delete a column\n * @see https://developer.github.com/v3/projects/columns/#delete-a-project-column\n * @param {string} colId - the column to be deleted\n * @param {Requestable.callback} cb - will receive true if the operation is successful\n * @return {Promise} - the promise for the http request\n */\n deleteProjectColumn(colId, cb) {\n return this._request('DELETE', `/projects/columns/${colId}`, null, cb);\n }\n\n /**\n * Move a column\n * @see https://developer.github.com/v3/projects/columns/#move-a-project-column\n * @param {string} colId - the column to be moved\n * @param {string} position - can be one of first, last, or after:,\n * where is the id value of a column in the same project.\n * @param {Requestable.callback} cb - will receive true if the operation is successful\n * @return {Promise} - the promise for the http request\n */\n moveProjectColumn(colId, position, cb) {\n return this._request(\n 'POST',\n `/projects/columns/${colId}/moves`,\n {position: position},\n cb\n );\n }\n\n /**\n * Get information about all cards of a project\n * @see https://developer.github.com/v3/projects/cards/#list-project-cards\n * @param {Requestable.callback} [cb] - will receive the list of cards\n * @return {Promise} - the promise for the http request\n */\n listProjectCards(cb) {\n return this.listProjectColumns()\n .then(({data}) => {\n return Promise.all(data.map((column) => {\n return this._requestAllPages(`/projects/columns/${column.id}/cards`, null);\n }));\n }).then((cardsInColumns) => {\n const cards = cardsInColumns.reduce((prev, {data}) => {\n prev.push(...data);\n return prev;\n }, []);\n if (cb) {\n cb(null, cards);\n }\n return cards;\n }).catch((err) => {\n if (cb) {\n cb(err);\n return;\n }\n throw err;\n });\n }\n\n /**\n * Get information about all cards of a column\n * @see https://developer.github.com/v3/projects/cards/#list-project-cards\n * @param {string} colId - the id of the column\n * @param {Requestable.callback} [cb] - will receive the list of cards\n * @return {Promise} - the promise for the http request\n */\n listColumnCards(colId, cb) {\n return this._requestAllPages(`/projects/columns/${colId}/cards`, null, cb);\n }\n\n /**\n * Get information about a card\n * @see https://developer.github.com/v3/projects/cards/#get-a-project-card\n * @param {string} cardId - the id of the card\n * @param {Requestable.callback} cb - will receive the card information\n * @return {Promise} - the promise for the http request\n */\n getProjectCard(cardId, cb) {\n return this._request('GET', `/projects/columns/cards/${cardId}`, null, cb);\n }\n\n /**\n * Create a new card\n * @see https://developer.github.com/v3/projects/cards/#create-a-project-card\n * @param {string} colId - the column id\n * @param {Object} options - the description of the card\n * @param {Requestable.callback} cb - will receive the newly created card\n * @return {Promise} - the promise for the http request\n */\n createProjectCard(colId, options, cb) {\n return this._request('POST', `/projects/columns/${colId}/cards`, options, cb);\n }\n\n /**\n * Edit a card\n * @see https://developer.github.com/v3/projects/cards/#update-a-project-card\n * @param {string} cardId - the card id\n * @param {Object} options - the description of the card\n * @param {Requestable.callback} cb - will receive the modified card\n * @return {Promise} - the promise for the http request\n */\n updateProjectCard(cardId, options, cb) {\n return this._request('PATCH', `/projects/columns/cards/${cardId}`, options, cb);\n }\n\n /**\n * Delete a card\n * @see https://developer.github.com/v3/projects/cards/#delete-a-project-card\n * @param {string} cardId - the card to be deleted\n * @param {Requestable.callback} cb - will receive true if the operation is successful\n * @return {Promise} - the promise for the http request\n */\n deleteProjectCard(cardId, cb) {\n return this._request('DELETE', `/projects/columns/cards/${cardId}`, null, cb);\n }\n\n /**\n * Move a card\n * @see https://developer.github.com/v3/projects/cards/#move-a-project-card\n * @param {string} cardId - the card to be moved\n * @param {string} position - can be one of top, bottom, or after:,\n * where is the id value of a card in the same project.\n * @param {string} colId - the id value of a column in the same project.\n * @param {Requestable.callback} cb - will receive true if the operation is successful\n * @return {Promise} - the promise for the http request\n */\n moveProjectCard(cardId, position, colId, cb) {\n return this._request(\n 'POST',\n `/projects/columns/cards/${cardId}/moves`,\n {position: position, column_id: colId}, // eslint-disable-line camelcase\n cb\n );\n }\n}\n\nmodule.exports = Project;\n","/**\n * @file\n * @copyright 2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n * Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\n\n/**\n * RateLimit allows users to query their rate-limit status\n */\nclass RateLimit extends Requestable {\n /**\n * construct a RateLimit\n * @param {Requestable.auth} auth - the credentials to authenticate to GitHub\n * @param {string} [apiBase] - the base Github API URL\n * @return {Promise} - the promise for the http request\n */\n constructor(auth, apiBase) {\n super(auth, apiBase);\n }\n\n /**\n * Query the current rate limit\n * @see https://developer.github.com/v3/rate_limit/\n * @param {Requestable.callback} [cb] - will receive the rate-limit data\n * @return {Promise} - the promise for the http request\n */\n getRateLimit(cb) {\n return this._request('GET', '/rate_limit', null, cb);\n }\n}\n\nmodule.exports = RateLimit;\n","/**\n * @file\n * @copyright 2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n * Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\nimport Utf8 from 'utf8';\nimport {\n Base64,\n} from 'js-base64';\nimport debug from 'debug';\nconst log = debug('github:repository');\n\n/**\n * Respository encapsulates the functionality to create, query, and modify files.\n */\nclass Repository extends Requestable {\n /**\n * Create a Repository.\n * @param {string} fullname - the full name of the repository\n * @param {Requestable.auth} [auth] - information required to authenticate to Github\n * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n */\n constructor(fullname, auth, apiBase) {\n super(auth, apiBase);\n this.__fullname = fullname;\n this.__currentTree = {\n branch: null,\n sha: null,\n };\n }\n\n /**\n * Get a reference\n * @see https://developer.github.com/v3/git/refs/#get-a-reference\n * @param {string} ref - the reference to get\n * @param {Requestable.callback} [cb] - will receive the reference's refSpec or a list of refSpecs that match `ref`\n * @return {Promise} - the promise for the http request\n */\n getRef(ref, cb) {\n return this._request('GET', `/repos/${this.__fullname}/git/refs/${ref}`, null, cb);\n }\n\n /**\n * Create a reference\n * @see https://developer.github.com/v3/git/refs/#create-a-reference\n * @param {Object} options - the object describing the ref\n * @param {Requestable.callback} [cb] - will receive the ref\n * @return {Promise} - the promise for the http request\n */\n createRef(options, cb) {\n return this._request('POST', `/repos/${this.__fullname}/git/refs`, options, cb);\n }\n\n /**\n * Delete a reference\n * @see https://developer.github.com/v3/git/refs/#delete-a-reference\n * @param {string} ref - the name of the ref to delte\n * @param {Requestable.callback} [cb] - will receive true if the request is successful\n * @return {Promise} - the promise for the http request\n */\n deleteRef(ref, cb) {\n return this._request('DELETE', `/repos/${this.__fullname}/git/refs/${ref}`, null, cb);\n }\n\n /**\n * Delete a repository\n * @see https://developer.github.com/v3/repos/#delete-a-repository\n * @param {Requestable.callback} [cb] - will receive true if the request is successful\n * @return {Promise} - the promise for the http request\n */\n deleteRepo(cb) {\n return this._request('DELETE', `/repos/${this.__fullname}`, null, cb);\n }\n\n /**\n * List the tags on a repository\n * @see https://developer.github.com/v3/repos/#list-tags\n * @param {Requestable.callback} [cb] - will receive the tag data\n * @return {Promise} - the promise for the http request\n */\n listTags(cb) {\n return this._request('GET', `/repos/${this.__fullname}/tags`, null, cb);\n }\n\n /**\n * List the open pull requests on the repository\n * @see https://developer.github.com/v3/pulls/#list-pull-requests\n * @param {Object} options - options to filter the search\n * @param {Requestable.callback} [cb] - will receive the list of PRs\n * @return {Promise} - the promise for the http request\n */\n listPullRequests(options, cb) {\n options = options || {};\n return this._request('GET', `/repos/${this.__fullname}/pulls`, options, cb);\n }\n\n /**\n * Get information about a specific pull request\n * @see https://developer.github.com/v3/pulls/#get-a-single-pull-request\n * @param {number} number - the PR you wish to fetch\n * @param {Requestable.callback} [cb] - will receive the PR from the API\n * @return {Promise} - the promise for the http request\n */\n getPullRequest(number, cb) {\n return this._request('GET', `/repos/${this.__fullname}/pulls/${number}`, null, cb);\n }\n\n /**\n * List the files of a specific pull request\n * @see https://developer.github.com/v3/pulls/#list-pull-requests-files\n * @param {number|string} number - the PR you wish to fetch\n * @param {Requestable.callback} [cb] - will receive the list of files from the API\n * @return {Promise} - the promise for the http request\n */\n listPullRequestFiles(number, cb) {\n return this._request('GET', `/repos/${this.__fullname}/pulls/${number}/files`, null, cb);\n }\n\n /**\n * Compare two branches/commits/repositories\n * @see https://developer.github.com/v3/repos/commits/#compare-two-commits\n * @param {string} base - the base commit\n * @param {string} head - the head commit\n * @param {Requestable.callback} cb - will receive the comparison\n * @return {Promise} - the promise for the http request\n */\n compareBranches(base, head, cb) {\n return this._request('GET', `/repos/${this.__fullname}/compare/${base}...${head}`, null, cb);\n }\n\n /**\n * List all the branches for the repository\n * @see https://developer.github.com/v3/repos/#list-branches\n * @param {Requestable.callback} cb - will receive the list of branches\n * @return {Promise} - the promise for the http request\n */\n listBranches(cb) {\n return this._request('GET', `/repos/${this.__fullname}/branches`, null, cb);\n }\n\n /**\n * Get a raw blob from the repository\n * @see https://developer.github.com/v3/git/blobs/#get-a-blob\n * @param {string} sha - the sha of the blob to fetch\n * @param {Requestable.callback} cb - will receive the blob from the API\n * @return {Promise} - the promise for the http request\n */\n getBlob(sha, cb) {\n return this._request('GET', `/repos/${this.__fullname}/git/blobs/${sha}`, null, cb, 'raw');\n }\n\n /**\n * Get a single branch\n * @see https://developer.github.com/v3/repos/branches/#get-branch\n * @param {string} branch - the name of the branch to fetch\n * @param {Requestable.callback} cb - will receive the branch from the API\n * @returns {Promise} - the promise for the http request\n */\n getBranch(branch, cb) {\n return this._request('GET', `/repos/${this.__fullname}/branches/${branch}`, null, cb);\n }\n\n /**\n * Get a commit from the repository\n * @see https://developer.github.com/v3/repos/commits/#get-a-single-commit\n * @param {string} sha - the sha for the commit to fetch\n * @param {Requestable.callback} cb - will receive the commit data\n * @return {Promise} - the promise for the http request\n */\n getCommit(sha, cb) {\n return this._request('GET', `/repos/${this.__fullname}/git/commits/${sha}`, null, cb);\n }\n\n /**\n * List the commits on a repository, optionally filtering by path, author or time range\n * @see https://developer.github.com/v3/repos/commits/#list-commits-on-a-repository\n * @param {Object} [options] - the filtering options for commits\n * @param {string} [options.sha] - the SHA or branch to start from\n * @param {string} [options.path] - the path to search on\n * @param {string} [options.author] - the commit author\n * @param {(Date|string)} [options.since] - only commits after this date will be returned\n * @param {(Date|string)} [options.until] - only commits before this date will be returned\n * @param {Requestable.callback} cb - will receive the list of commits found matching the criteria\n * @return {Promise} - the promise for the http request\n */\n listCommits(options, cb) {\n options = options || {};\n\n options.since = this._dateToISO(options.since);\n options.until = this._dateToISO(options.until);\n\n return this._request('GET', `/repos/${this.__fullname}/commits`, options, cb);\n }\n\n /**\n * Gets a single commit information for a repository\n * @see https://developer.github.com/v3/repos/commits/#get-a-single-commit\n * @param {string} ref - the reference for the commit-ish\n * @param {Requestable.callback} cb - will receive the commit information\n * @return {Promise} - the promise for the http request\n */\n getSingleCommit(ref, cb) {\n ref = ref || '';\n return this._request('GET', `/repos/${this.__fullname}/commits/${ref}`, null, cb);\n }\n\n /**\n * Get tha sha for a particular object in the repository. This is a convenience function\n * @see https://developer.github.com/v3/repos/contents/#get-contents\n * @param {string} [branch] - the branch to look in, or the repository's default branch if omitted\n * @param {string} path - the path of the file or directory\n * @param {Requestable.callback} cb - will receive a description of the requested object, including a `SHA` property\n * @return {Promise} - the promise for the http request\n */\n getSha(branch, path, cb) {\n branch = branch ? `?ref=${branch}` : '';\n return this._request('GET', `/repos/${this.__fullname}/contents/${path}${branch}`, null, cb);\n }\n\n /**\n * List the commit statuses for a particular sha, branch, or tag\n * @see https://developer.github.com/v3/repos/statuses/#list-statuses-for-a-specific-ref\n * @param {string} sha - the sha, branch, or tag to get statuses for\n * @param {Requestable.callback} cb - will receive the list of statuses\n * @return {Promise} - the promise for the http request\n */\n listStatuses(sha, cb) {\n return this._request('GET', `/repos/${this.__fullname}/commits/${sha}/statuses`, null, cb);\n }\n\n /**\n * Get a description of a git tree\n * @see https://developer.github.com/v3/git/trees/#get-a-tree\n * @param {string} treeSHA - the SHA of the tree to fetch\n * @param {Requestable.callback} cb - will receive the callback data\n * @return {Promise} - the promise for the http request\n */\n getTree(treeSHA, cb) {\n return this._request('GET', `/repos/${this.__fullname}/git/trees/${treeSHA}`, null, cb);\n }\n\n /**\n * Create a blob\n * @see https://developer.github.com/v3/git/blobs/#create-a-blob\n * @param {(string|Buffer|Blob)} content - the content to add to the repository\n * @param {Requestable.callback} cb - will receive the details of the created blob\n * @return {Promise} - the promise for the http request\n */\n createBlob(content, cb) {\n let postBody = this._getContentObject(content);\n\n log('sending content', postBody);\n return this._request('POST', `/repos/${this.__fullname}/git/blobs`, postBody, cb);\n }\n\n /**\n * Get the object that represents the provided content\n * @param {string|Buffer|Blob} content - the content to send to the server\n * @return {Object} the representation of `content` for the GitHub API\n */\n _getContentObject(content) {\n if (typeof content === 'string') {\n log('contet is a string');\n return {\n content: Utf8.encode(content),\n encoding: 'utf-8',\n };\n\n } else if (typeof Buffer !== 'undefined' && content instanceof Buffer) {\n log('We appear to be in Node');\n return {\n content: content.toString('base64'),\n encoding: 'base64',\n };\n\n } else if (typeof Blob !== 'undefined' && content instanceof Blob) {\n log('We appear to be in the browser');\n return {\n content: Base64.encode(content),\n encoding: 'base64',\n };\n\n } else { // eslint-disable-line\n log(`Not sure what this content is: ${typeof content}, ${JSON.stringify(content)}`);\n throw new Error('Unknown content passed to postBlob. Must be string or Buffer (node) or Blob (web)');\n }\n }\n\n /**\n * Update a tree in Git\n * @see https://developer.github.com/v3/git/trees/#create-a-tree\n * @param {string} baseTreeSHA - the SHA of the tree to update\n * @param {string} path - the path for the new file\n * @param {string} blobSHA - the SHA for the blob to put at `path`\n * @param {Requestable.callback} cb - will receive the new tree that is created\n * @return {Promise} - the promise for the http request\n * @deprecated use {@link Repository#createTree} instead\n */\n updateTree(baseTreeSHA, path, blobSHA, cb) {\n let newTree = {\n base_tree: baseTreeSHA, // eslint-disable-line\n tree: [{\n path: path,\n sha: blobSHA,\n mode: '100644',\n type: 'blob',\n }],\n };\n\n return this._request('POST', `/repos/${this.__fullname}/git/trees`, newTree, cb);\n }\n\n /**\n * Create a new tree in git\n * @see https://developer.github.com/v3/git/trees/#create-a-tree\n * @param {Object} tree - the tree to create\n * @param {string} baseSHA - the root sha of the tree\n * @param {Requestable.callback} cb - will receive the new tree that is created\n * @return {Promise} - the promise for the http request\n */\n createTree(tree, baseSHA, cb) {\n return this._request('POST', `/repos/${this.__fullname}/git/trees`, {\n tree,\n base_tree: baseSHA, // eslint-disable-line camelcase\n }, cb);\n }\n\n /**\n * Add a commit to the repository\n * @see https://developer.github.com/v3/git/commits/#create-a-commit\n * @param {string} parent - the SHA of the parent commit\n * @param {string} tree - the SHA of the tree for this commit\n * @param {string} message - the commit message\n * @param {Requestable.callback} cb - will receive the commit that is created\n * @return {Promise} - the promise for the http request\n */\n commit(parent, tree, message, cb) {\n let data = {\n message,\n tree,\n parents: [parent],\n };\n\n return this._request('POST', `/repos/${this.__fullname}/git/commits`, data, cb)\n .then((response) => {\n this.__currentTree.sha = response.data.sha; // Update latest commit\n return response;\n });\n }\n\n /**\n * Update a ref\n * @see https://developer.github.com/v3/git/refs/#update-a-reference\n * @param {string} ref - the ref to update\n * @param {string} commitSHA - the SHA to point the reference to\n * @param {boolean} force - indicates whether to force or ensure a fast-forward update\n * @param {Requestable.callback} cb - will receive the updated ref back\n * @return {Promise} - the promise for the http request\n */\n updateHead(ref, commitSHA, force, cb) {\n return this._request('PATCH', `/repos/${this.__fullname}/git/refs/${ref}`, {\n sha: commitSHA,\n force: force,\n }, cb);\n }\n\n /**\n * Update commit status\n * @see https://developer.github.com/v3/repos/statuses/\n * @param {string} commitSHA - the SHA of the commit that should be updated\n * @param {object} options - Commit status parameters\n * @param {string} options.state - The state of the status. Can be one of: pending, success, error, or failure.\n * @param {string} [options.target_url] - The target URL to associate with this status.\n * @param {string} [options.description] - A short description of the status.\n * @param {string} [options.context] - A string label to differentiate this status among CI systems.\n * @param {Requestable.callback} cb - will receive the updated commit back\n * @return {Promise} - the promise for the http request\n */\n updateStatus(commitSHA, options, cb) {\n return this._request('POST', `/repos/${this.__fullname}/statuses/${commitSHA}`, options, cb);\n }\n\n /**\n * Update repository information\n * @see https://developer.github.com/v3/repos/#edit\n * @param {object} options - New parameters that will be set to the repository\n * @param {string} options.name - Name of the repository\n * @param {string} [options.description] - A short description of the repository\n * @param {string} [options.homepage] - A URL with more information about the repository\n * @param {boolean} [options.private] - Either true to make the repository private, or false to make it public.\n * @param {boolean} [options.has_issues] - Either true to enable issues for this repository, false to disable them.\n * @param {boolean} [options.has_wiki] - Either true to enable the wiki for this repository, false to disable it.\n * @param {boolean} [options.has_downloads] - Either true to enable downloads, false to disable them.\n * @param {string} [options.default_branch] - Updates the default branch for this repository.\n * @param {Requestable.callback} cb - will receive the updated repository back\n * @return {Promise} - the promise for the http request\n */\n updateRepository(options, cb) {\n return this._request('PATCH', `/repos/${this.__fullname}`, options, cb);\n }\n\n /**\n * Get information about the repository\n * @see https://developer.github.com/v3/repos/#get\n * @param {Requestable.callback} cb - will receive the information about the repository\n * @return {Promise} - the promise for the http request\n */\n getDetails(cb) {\n return this._request('GET', `/repos/${this.__fullname}`, null, cb);\n }\n\n /**\n * List the contributors to the repository\n * @see https://developer.github.com/v3/repos/#list-contributors\n * @param {Requestable.callback} cb - will receive the list of contributors\n * @return {Promise} - the promise for the http request\n */\n getContributors(cb) {\n return this._request('GET', `/repos/${this.__fullname}/contributors`, null, cb);\n }\n\n /**\n * List the contributor stats to the repository\n * @see https://developer.github.com/v3/repos/#list-contributors\n * @param {Requestable.callback} cb - will receive the list of contributors\n * @return {Promise} - the promise for the http request\n */\n getContributorStats(cb) {\n return this._request('GET', `/repos/${this.__fullname}/stats/contributors`, null, cb);\n }\n\n /**\n * List the users who are collaborators on the repository. The currently authenticated user must have\n * push access to use this method\n * @see https://developer.github.com/v3/repos/collaborators/#list-collaborators\n * @param {Requestable.callback} cb - will receive the list of collaborators\n * @return {Promise} - the promise for the http request\n */\n getCollaborators(cb) {\n return this._request('GET', `/repos/${this.__fullname}/collaborators`, null, cb);\n }\n\n /**\n * Check if a user is a collaborator on the repository\n * @see https://developer.github.com/v3/repos/collaborators/#check-if-a-user-is-a-collaborator\n * @param {string} username - the user to check\n * @param {Requestable.callback} cb - will receive true if the user is a collaborator and false if they are not\n * @return {Promise} - the promise for the http request {Boolean} [description]\n */\n isCollaborator(username, cb) {\n return this._request('GET', `/repos/${this.__fullname}/collaborators/${username}`, null, cb);\n }\n\n /**\n * Get the contents of a repository\n * @see https://developer.github.com/v3/repos/contents/#get-contents\n * @param {string} ref - the ref to check\n * @param {string} path - the path containing the content to fetch\n * @param {boolean} raw - `true` if the results should be returned raw instead of GitHub's normalized format\n * @param {Requestable.callback} cb - will receive the fetched data\n * @return {Promise} - the promise for the http request\n */\n getContents(ref, path, raw, cb) {\n path = path ? `${encodeURI(path)}` : '';\n return this._request('GET', `/repos/${this.__fullname}/contents/${path}`, {\n ref,\n }, cb, raw);\n }\n\n /**\n * Get the README of a repository\n * @see https://developer.github.com/v3/repos/contents/#get-the-readme\n * @param {string} ref - the ref to check\n * @param {boolean} raw - `true` if the results should be returned raw instead of GitHub's normalized format\n * @param {Requestable.callback} cb - will receive the fetched data\n * @return {Promise} - the promise for the http request\n */\n getReadme(ref, raw, cb) {\n return this._request('GET', `/repos/${this.__fullname}/readme`, {\n ref,\n }, cb, raw);\n }\n\n /**\n * Fork a repository\n * @see https://developer.github.com/v3/repos/forks/#create-a-fork\n * @param {Requestable.callback} cb - will receive the information about the newly created fork\n * @return {Promise} - the promise for the http request\n */\n fork(cb) {\n return this._request('POST', `/repos/${this.__fullname}/forks`, null, cb);\n }\n\n /**\n * List a repository's forks\n * @see https://developer.github.com/v3/repos/forks/#list-forks\n * @param {Requestable.callback} cb - will receive the list of repositories forked from this one\n * @return {Promise} - the promise for the http request\n */\n listForks(cb) {\n return this._request('GET', `/repos/${this.__fullname}/forks`, null, cb);\n }\n\n /**\n * Create a new branch from an existing branch.\n * @param {string} [oldBranch=master] - the name of the existing branch\n * @param {string} newBranch - the name of the new branch\n * @param {Requestable.callback} cb - will receive the commit data for the head of the new branch\n * @return {Promise} - the promise for the http request\n */\n createBranch(oldBranch, newBranch, cb) {\n if (typeof newBranch === 'function') {\n cb = newBranch;\n newBranch = oldBranch;\n oldBranch = 'master';\n }\n\n return this.getRef(`heads/${oldBranch}`)\n .then((response) => {\n let sha = response.data.object.sha;\n return this.createRef({\n sha,\n ref: `refs/heads/${newBranch}`,\n }, cb);\n });\n }\n\n /**\n * Create a new pull request\n * @see https://developer.github.com/v3/pulls/#create-a-pull-request\n * @param {Object} options - the pull request description\n * @param {Requestable.callback} cb - will receive the new pull request\n * @return {Promise} - the promise for the http request\n */\n createPullRequest(options, cb) {\n return this._request('POST', `/repos/${this.__fullname}/pulls`, options, cb);\n }\n\n /**\n * Update a pull request\n * @see https://developer.github.com/v3/pulls/#update-a-pull-request\n * @param {number|string} number - the number of the pull request to update\n * @param {Object} options - the pull request description\n * @param {Requestable.callback} [cb] - will receive the pull request information\n * @return {Promise} - the promise for the http request\n */\n updatePullRequest(number, options, cb) {\n return this._request('PATCH', `/repos/${this.__fullname}/pulls/${number}`, options, cb);\n }\n\n /**\n * List the hooks for the repository\n * @see https://developer.github.com/v3/repos/hooks/#list-hooks\n * @param {Requestable.callback} cb - will receive the list of hooks\n * @return {Promise} - the promise for the http request\n */\n listHooks(cb) {\n return this._request('GET', `/repos/${this.__fullname}/hooks`, null, cb);\n }\n\n /**\n * Get a hook for the repository\n * @see https://developer.github.com/v3/repos/hooks/#get-single-hook\n * @param {number} id - the id of the webook\n * @param {Requestable.callback} cb - will receive the details of the webook\n * @return {Promise} - the promise for the http request\n */\n getHook(id, cb) {\n return this._request('GET', `/repos/${this.__fullname}/hooks/${id}`, null, cb);\n }\n\n /**\n * Add a new hook to the repository\n * @see https://developer.github.com/v3/repos/hooks/#create-a-hook\n * @param {Object} options - the configuration describing the new hook\n * @param {Requestable.callback} cb - will receive the new webhook\n * @return {Promise} - the promise for the http request\n */\n createHook(options, cb) {\n return this._request('POST', `/repos/${this.__fullname}/hooks`, options, cb);\n }\n\n /**\n * Edit an existing webhook\n * @see https://developer.github.com/v3/repos/hooks/#edit-a-hook\n * @param {number} id - the id of the webhook\n * @param {Object} options - the new description of the webhook\n * @param {Requestable.callback} cb - will receive the updated webhook\n * @return {Promise} - the promise for the http request\n */\n updateHook(id, options, cb) {\n return this._request('PATCH', `/repos/${this.__fullname}/hooks/${id}`, options, cb);\n }\n\n /**\n * Delete a webhook\n * @see https://developer.github.com/v3/repos/hooks/#delete-a-hook\n * @param {number} id - the id of the webhook to be deleted\n * @param {Requestable.callback} cb - will receive true if the call is successful\n * @return {Promise} - the promise for the http request\n */\n deleteHook(id, cb) {\n return this._request('DELETE', `/repos/${this.__fullname}/hooks/${id}`, null, cb);\n }\n\n /**\n * List the deploy keys for the repository\n * @see https://developer.github.com/v3/repos/keys/#list-deploy-keys\n * @param {Requestable.callback} cb - will receive the list of deploy keys\n * @return {Promise} - the promise for the http request\n */\n listKeys(cb) {\n return this._request('GET', `/repos/${this.__fullname}/keys`, null, cb);\n }\n\n /**\n * Get a deploy key for the repository\n * @see https://developer.github.com/v3/repos/keys/#get-a-deploy-key\n * @param {number} id - the id of the deploy key\n * @param {Requestable.callback} cb - will receive the details of the deploy key\n * @return {Promise} - the promise for the http request\n */\n getKey(id, cb) {\n return this._request('GET', `/repos/${this.__fullname}/keys/${id}`, null, cb);\n }\n\n /**\n * Add a new deploy key to the repository\n * @see https://developer.github.com/v3/repos/keys/#add-a-new-deploy-key\n * @param {Object} options - the configuration describing the new deploy key\n * @param {Requestable.callback} cb - will receive the new deploy key\n * @return {Promise} - the promise for the http request\n */\n createKey(options, cb) {\n return this._request('POST', `/repos/${this.__fullname}/keys`, options, cb);\n }\n\n /**\n * Delete a deploy key\n * @see https://developer.github.com/v3/repos/keys/#remove-a-deploy-key\n * @param {number} id - the id of the deploy key to be deleted\n * @param {Requestable.callback} cb - will receive true if the call is successful\n * @return {Promise} - the promise for the http request\n */\n deleteKey(id, cb) {\n return this._request('DELETE', `/repos/${this.__fullname}/keys/${id}`, null, cb);\n }\n\n /**\n * Delete a file from a branch\n * @see https://developer.github.com/v3/repos/contents/#delete-a-file\n * @param {string} branch - the branch to delete from, or the default branch if not specified\n * @param {string} path - the path of the file to remove\n * @param {Requestable.callback} cb - will receive the commit in which the delete occurred\n * @return {Promise} - the promise for the http request\n */\n deleteFile(branch, path, cb) {\n return this.getSha(branch, path)\n .then((response) => {\n const deleteCommit = {\n message: `Delete the file at '${path}'`,\n sha: response.data.sha,\n branch,\n };\n return this._request('DELETE', `/repos/${this.__fullname}/contents/${path}`, deleteCommit, cb);\n });\n }\n\n /**\n * Change all references in a repo from oldPath to new_path\n * @param {string} branch - the branch to carry out the reference change, or the default branch if not specified\n * @param {string} oldPath - original path\n * @param {string} newPath - new reference path\n * @param {Requestable.callback} cb - will receive the commit in which the move occurred\n * @return {Promise} - the promise for the http request\n */\n move(branch, oldPath, newPath, cb) {\n let oldSha;\n return this.getRef(`heads/${branch}`)\n .then(({data: {object}}) => this.getTree(`${object.sha}?recursive=true`))\n .then(({data: {tree, sha}}) => {\n oldSha = sha;\n let newTree = tree.map((ref) => {\n if (ref.path === oldPath) {\n ref.path = newPath;\n }\n if (ref.type === 'tree') {\n delete ref.sha;\n }\n return ref;\n });\n return this.createTree(newTree);\n })\n .then(({data: tree}) => this.commit(oldSha, tree.sha, `Renamed '${oldPath}' to '${newPath}'`))\n .then(({data: commit}) => this.updateHead(`heads/${branch}`, commit.sha, true, cb));\n }\n\n /**\n * Write a file to the repository\n * @see https://developer.github.com/v3/repos/contents/#update-a-file\n * @param {string} branch - the name of the branch\n * @param {string} path - the path for the file\n * @param {string} content - the contents of the file\n * @param {string} message - the commit message\n * @param {Object} [options] - commit options\n * @param {Object} [options.author] - the author of the commit\n * @param {Object} [options.commiter] - the committer\n * @param {boolean} [options.encode] - true if the content should be base64 encoded\n * @param {Requestable.callback} cb - will receive the new commit\n * @return {Promise} - the promise for the http request\n */\n writeFile(branch, path, content, message, options, cb) {\n if (typeof options === 'function') {\n cb = options;\n options = {};\n }\n let filePath = path ? encodeURI(path) : '';\n let shouldEncode = options.encode !== false;\n let commit = {\n branch,\n message,\n author: options.author,\n committer: options.committer,\n content: shouldEncode ? Base64.encode(content) : content,\n };\n\n return this.getSha(branch, filePath)\n .then((response) => {\n commit.sha = response.data.sha;\n return this._request('PUT', `/repos/${this.__fullname}/contents/${filePath}`, commit, cb);\n }, () => {\n return this._request('PUT', `/repos/${this.__fullname}/contents/${filePath}`, commit, cb);\n });\n }\n\n /**\n * Check if a repository is starred by you\n * @see https://developer.github.com/v3/activity/starring/#check-if-you-are-starring-a-repository\n * @param {Requestable.callback} cb - will receive true if the repository is starred and false if the repository\n * is not starred\n * @return {Promise} - the promise for the http request {Boolean} [description]\n */\n isStarred(cb) {\n return this._request204or404(`/user/starred/${this.__fullname}`, null, cb);\n }\n\n /**\n * Star a repository\n * @see https://developer.github.com/v3/activity/starring/#star-a-repository\n * @param {Requestable.callback} cb - will receive true if the repository is starred\n * @return {Promise} - the promise for the http request\n */\n star(cb) {\n return this._request('PUT', `/user/starred/${this.__fullname}`, null, cb);\n }\n\n /**\n * Unstar a repository\n * @see https://developer.github.com/v3/activity/starring/#unstar-a-repository\n * @param {Requestable.callback} cb - will receive true if the repository is unstarred\n * @return {Promise} - the promise for the http request\n */\n unstar(cb) {\n return this._request('DELETE', `/user/starred/${this.__fullname}`, null, cb);\n }\n\n /**\n * Create a new release\n * @see https://developer.github.com/v3/repos/releases/#create-a-release\n * @param {Object} options - the description of the release\n * @param {Requestable.callback} cb - will receive the newly created release\n * @return {Promise} - the promise for the http request\n */\n createRelease(options, cb) {\n return this._request('POST', `/repos/${this.__fullname}/releases`, options, cb);\n }\n\n /**\n * Edit a release\n * @see https://developer.github.com/v3/repos/releases/#edit-a-release\n * @param {string} id - the id of the release\n * @param {Object} options - the description of the release\n * @param {Requestable.callback} cb - will receive the modified release\n * @return {Promise} - the promise for the http request\n */\n updateRelease(id, options, cb) {\n return this._request('PATCH', `/repos/${this.__fullname}/releases/${id}`, options, cb);\n }\n\n /**\n * Get information about all releases\n * @see https://developer.github.com/v3/repos/releases/#list-releases-for-a-repository\n * @param {Requestable.callback} cb - will receive the release information\n * @return {Promise} - the promise for the http request\n */\n listReleases(cb) {\n return this._request('GET', `/repos/${this.__fullname}/releases`, null, cb);\n }\n\n /**\n * Get information about a release\n * @see https://developer.github.com/v3/repos/releases/#get-a-single-release\n * @param {string} id - the id of the release\n * @param {Requestable.callback} cb - will receive the release information\n * @return {Promise} - the promise for the http request\n */\n getRelease(id, cb) {\n return this._request('GET', `/repos/${this.__fullname}/releases/${id}`, null, cb);\n }\n\n /**\n * Delete a release\n * @see https://developer.github.com/v3/repos/releases/#delete-a-release\n * @param {string} id - the release to be deleted\n * @param {Requestable.callback} cb - will receive true if the operation is successful\n * @return {Promise} - the promise for the http request\n */\n deleteRelease(id, cb) {\n return this._request('DELETE', `/repos/${this.__fullname}/releases/${id}`, null, cb);\n }\n\n /**\n * Merge a pull request\n * @see https://developer.github.com/v3/pulls/#merge-a-pull-request-merge-button\n * @param {number|string} number - the number of the pull request to merge\n * @param {Object} options - the merge options for the pull request\n * @param {Requestable.callback} [cb] - will receive the merge information if the operation is successful\n * @return {Promise} - the promise for the http request\n */\n mergePullRequest(number, options, cb) {\n return this._request('PUT', `/repos/${this.__fullname}/pulls/${number}/merge`, options, cb);\n }\n\n /**\n * Get information about all projects\n * @see https://developer.github.com/v3/projects/#list-repository-projects\n * @param {Requestable.callback} [cb] - will receive the list of projects\n * @return {Promise} - the promise for the http request\n */\n listProjects(cb) {\n return this._requestAllPages(`/repos/${this.__fullname}/projects`, {AcceptHeader: 'inertia-preview'}, cb);\n }\n\n /**\n * Create a new project\n * @see https://developer.github.com/v3/projects/#create-a-repository-project\n * @param {Object} options - the description of the project\n * @param {Requestable.callback} cb - will receive the newly created project\n * @return {Promise} - the promise for the http request\n */\n createProject(options, cb) {\n options = options || {};\n options.AcceptHeader = 'inertia-preview';\n return this._request('POST', `/repos/${this.__fullname}/projects`, options, cb);\n }\n\n}\n\nmodule.exports = Repository;\n","/**\n * @file\n * @copyright 2016 Yahoo Inc.\n * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n * Github.js is freely distributable.\n */\n\nimport axios from 'axios';\nimport debug from 'debug';\nimport {Base64} from 'js-base64';\n\nconst log = debug('github:request');\n\n/**\n * The error structure returned when a network call fails\n */\nclass ResponseError extends Error {\n /**\n * Construct a new ResponseError\n * @param {string} message - an message to return instead of the the default error message\n * @param {string} path - the requested path\n * @param {Object} response - the object returned by Axios\n */\n constructor(message, path, response) {\n super(message);\n this.path = path;\n this.request = response.config;\n this.response = (response || {}).response || response;\n this.status = response.status;\n }\n}\n\n/**\n * Requestable wraps the logic for making http requests to the API\n */\nclass Requestable {\n /**\n * Either a username and password or an oauth token for Github\n * @typedef {Object} Requestable.auth\n * @prop {string} [username] - the Github username\n * @prop {string} [password] - the user's password\n * @prop {token} [token] - an OAuth token\n */\n /**\n * Initialize the http internals.\n * @param {Requestable.auth} [auth] - the credentials to authenticate to Github. If auth is\n * not provided request will be made unauthenticated\n * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n * @param {string} [AcceptHeader=v3] - the accept header for the requests\n */\n constructor(auth, apiBase, AcceptHeader) {\n this.__apiBase = apiBase || 'https://api.github.com';\n this.__auth = {\n token: auth.token,\n username: auth.username,\n password: auth.password,\n };\n this.__AcceptHeader = AcceptHeader || 'v3';\n\n if (auth.token) {\n this.__authorizationHeader = 'token ' + auth.token;\n } else if (auth.username && auth.password) {\n this.__authorizationHeader = 'Basic ' + Base64.encode(auth.username + ':' + auth.password);\n }\n }\n\n /**\n * Compute the URL to use to make a request.\n * @private\n * @param {string} path - either a URL relative to the API base or an absolute URL\n * @return {string} - the URL to use\n */\n __getURL(path) {\n let url = path;\n\n if (path.indexOf('//') === -1) {\n url = this.__apiBase + path;\n }\n\n let newCacheBuster = 'timestamp=' + new Date().getTime();\n return url.replace(/(timestamp=\\d+)/, newCacheBuster);\n }\n\n /**\n * Compute the headers required for an API request.\n * @private\n * @param {boolean} raw - if the request should be treated as JSON or as a raw request\n * @param {string} AcceptHeader - the accept header for the request\n * @return {Object} - the headers to use in the request\n */\n __getRequestHeaders(raw, AcceptHeader) {\n let headers = {\n 'Content-Type': 'application/json;charset=UTF-8',\n 'Accept': 'application/vnd.github.' + (AcceptHeader || this.__AcceptHeader),\n };\n\n if (raw) {\n headers.Accept += '.raw';\n }\n headers.Accept += '+json';\n\n if (this.__authorizationHeader) {\n headers.Authorization = this.__authorizationHeader;\n }\n\n return headers;\n }\n\n /**\n * Sets the default options for API requests\n * @protected\n * @param {Object} [requestOptions={}] - the current options for the request\n * @return {Object} - the options to pass to the request\n */\n _getOptionsWithDefaults(requestOptions = {}) {\n if (!(requestOptions.visibility || requestOptions.affiliation)) {\n requestOptions.type = requestOptions.type || 'all';\n }\n requestOptions.sort = requestOptions.sort || 'updated';\n requestOptions.per_page = requestOptions.per_page || '100'; // eslint-disable-line\n\n return requestOptions;\n }\n\n /**\n * if a `Date` is passed to this function it will be converted to an ISO string\n * @param {*} date - the object to attempt to cooerce into an ISO date string\n * @return {string} - the ISO representation of `date` or whatever was passed in if it was not a date\n */\n _dateToISO(date) {\n if (date && (date instanceof Date)) {\n date = date.toISOString();\n }\n\n return date;\n }\n\n /**\n * A function that receives the result of the API request.\n * @callback Requestable.callback\n * @param {Requestable.Error} error - the error returned by the API or `null`\n * @param {(Object|true)} result - the data returned by the API or `true` if the API returns `204 No Content`\n * @param {Object} request - the raw {@linkcode https://github.com/mzabriskie/axios#response-schema Response}\n */\n /**\n * Make a request.\n * @param {string} method - the method for the request (GET, PUT, POST, DELETE)\n * @param {string} path - the path for the request\n * @param {*} [data] - the data to send to the server. For HTTP methods that don't have a body the data\n * will be sent as query parameters\n * @param {Requestable.callback} [cb] - the callback for the request\n * @param {boolean} [raw=false] - if the request should be sent as raw. If this is a falsy value then the\n * request will be made as JSON\n * @return {Promise} - the Promise for the http request\n */\n _request(method, path, data, cb, raw) {\n const url = this.__getURL(path);\n\n const AcceptHeader = (data || {}).AcceptHeader;\n if (AcceptHeader) {\n delete data.AcceptHeader;\n }\n const headers = this.__getRequestHeaders(raw, AcceptHeader);\n\n let queryParams = {};\n\n const shouldUseDataAsParams = data && (typeof data === 'object') && methodHasNoBody(method);\n if (shouldUseDataAsParams) {\n queryParams = data;\n data = undefined;\n }\n\n const config = {\n url: url,\n method: method,\n headers: headers,\n params: queryParams,\n data: data,\n responseType: raw ? 'text' : 'json',\n };\n\n log(`${config.method} to ${config.url}`);\n const requestPromise = axios(config).catch(callbackErrorOrThrow(cb, path));\n\n if (cb) {\n requestPromise.then((response) => {\n if (response.data && Object.keys(response.data).length > 0) {\n // When data has results\n cb(null, response.data, response);\n } else if (config.method !== 'GET' && Object.keys(response.data).length < 1) {\n // True when successful submit a request and receive a empty object\n cb(null, (response.status < 300), response);\n } else {\n cb(null, response.data, response);\n }\n });\n }\n\n return requestPromise;\n }\n\n /**\n * Make a request to an endpoint the returns 204 when true and 404 when false\n * @param {string} path - the path to request\n * @param {Object} data - any query parameters for the request\n * @param {Requestable.callback} cb - the callback that will receive `true` or `false`\n * @param {method} [method=GET] - HTTP Method to use\n * @return {Promise} - the promise for the http request\n */\n _request204or404(path, data, cb, method = 'GET') {\n return this._request(method, path, data)\n .then(function success(response) {\n if (cb) {\n cb(null, true, response);\n }\n return true;\n }, function failure(response) {\n if (response.response.status === 404) {\n if (cb) {\n cb(null, false, response);\n }\n return false;\n }\n\n if (cb) {\n cb(response);\n }\n throw response;\n });\n }\n\n /**\n * Make a request and fetch all the available data. Github will paginate responses so for queries\n * that might span multiple pages this method is preferred to {@link Requestable#request}\n * @param {string} path - the path to request\n * @param {Object} options - the query parameters to include\n * @param {Requestable.callback} [cb] - the function to receive the data. The returned data will always be an array.\n * @param {Object[]} results - the partial results. This argument is intended for interal use only.\n * @return {Promise} - a promise which will resolve when all pages have been fetched\n * @deprecated This will be folded into {@link Requestable#_request} in the 2.0 release.\n */\n _requestAllPages(path, options, cb, results) {\n results = results || [];\n\n return this._request('GET', path, options)\n .then((response) => {\n let thisGroup;\n if (response.data instanceof Array) {\n thisGroup = response.data;\n } else if (response.data.items instanceof Array) {\n thisGroup = response.data.items;\n } else {\n let message = `cannot figure out how to append ${response.data} to the result set`;\n throw new ResponseError(message, path, response);\n }\n results.push(...thisGroup);\n\n const nextUrl = getNextPage(response.headers.link);\n if (nextUrl && typeof options.page !== 'number') {\n log(`getting next page: ${nextUrl}`);\n return this._requestAllPages(nextUrl, options, cb, results);\n }\n\n if (cb) {\n cb(null, results, response);\n }\n\n response.data = results;\n return response;\n }).catch(callbackErrorOrThrow(cb, path));\n }\n}\n\nmodule.exports = Requestable;\n\n// ////////////////////////// //\n// Private helper functions //\n// ////////////////////////// //\nconst METHODS_WITH_NO_BODY = ['GET', 'HEAD', 'DELETE'];\nfunction methodHasNoBody(method) {\n return METHODS_WITH_NO_BODY.indexOf(method) !== -1;\n}\n\nfunction getNextPage(linksHeader = '') {\n const links = linksHeader.split(/\\s*,\\s*/); // splits and strips the urls\n return links.reduce(function(nextUrl, link) {\n if (link.search(/rel=\"next\"/) !== -1) {\n return (link.match(/<(.*)>/) || [])[1];\n }\n\n return nextUrl;\n }, undefined);\n}\n\nfunction callbackErrorOrThrow(cb, path) {\n return function handler(object) {\n let error;\n if (object.hasOwnProperty('config')) {\n const {response: {status, statusText}, config: {method, url}} = object;\n let message = (`${status} error making request ${method} ${url}: \"${statusText}\"`);\n error = new ResponseError(message, path, object);\n log(`${message} ${JSON.stringify(object.data)}`);\n } else {\n error = object;\n }\n if (cb) {\n log('going to error callback');\n cb(error);\n } else {\n log('throwing error');\n throw error;\n }\n };\n}\n","/**\n * @file\n * @copyright 2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n * Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\nimport debug from 'debug';\nconst log = debug('github:search');\n\n/**\n * Wrap the Search API\n */\nclass Search extends Requestable {\n /**\n * Create a Search\n * @param {Object} defaults - defaults for the search\n * @param {Requestable.auth} [auth] - information required to authenticate to Github\n * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n */\n constructor(defaults, auth, apiBase) {\n super(auth, apiBase);\n this.__defaults = this._getOptionsWithDefaults(defaults);\n }\n\n /**\n * Available search options\n * @see https://developer.github.com/v3/search/#parameters\n * @typedef {Object} Search.Params\n * @param {string} q - the query to make\n * @param {string} sort - the sort field, one of `stars`, `forks`, or `updated`.\n * Default is [best match](https://developer.github.com/v3/search/#ranking-search-results)\n * @param {string} order - the ordering, either `asc` or `desc`\n */\n /**\n * Perform a search on the GitHub API\n * @private\n * @param {string} path - the scope of the search\n * @param {Search.Params} [withOptions] - additional parameters for the search\n * @param {Requestable.callback} [cb] - will receive the results of the search\n * @return {Promise} - the promise for the http request\n */\n _search(path, withOptions = {}, cb = undefined) {\n let requestOptions = {};\n Object.keys(this.__defaults).forEach((prop) => {\n requestOptions[prop] = this.__defaults[prop];\n });\n Object.keys(withOptions).forEach((prop) => {\n requestOptions[prop] = withOptions[prop];\n });\n\n log(`searching ${path} with options:`, requestOptions);\n return this._requestAllPages(`/search/${path}`, requestOptions, cb);\n }\n\n /**\n * Search for repositories\n * @see https://developer.github.com/v3/search/#search-repositories\n * @param {Search.Params} [options] - additional parameters for the search\n * @param {Requestable.callback} [cb] - will receive the results of the search\n * @return {Promise} - the promise for the http request\n */\n forRepositories(options, cb) {\n return this._search('repositories', options, cb);\n }\n\n /**\n * Search for code\n * @see https://developer.github.com/v3/search/#search-code\n * @param {Search.Params} [options] - additional parameters for the search\n * @param {Requestable.callback} [cb] - will receive the results of the search\n * @return {Promise} - the promise for the http request\n */\n forCode(options, cb) {\n return this._search('code', options, cb);\n }\n\n /**\n * Search for issues\n * @see https://developer.github.com/v3/search/#search-issues\n * @param {Search.Params} [options] - additional parameters for the search\n * @param {Requestable.callback} [cb] - will receive the results of the search\n * @return {Promise} - the promise for the http request\n */\n forIssues(options, cb) {\n return this._search('issues', options, cb);\n }\n\n /**\n * Search for users\n * @see https://developer.github.com/v3/search/#search-users\n * @param {Search.Params} [options] - additional parameters for the search\n * @param {Requestable.callback} [cb] - will receive the results of the search\n * @return {Promise} - the promise for the http request\n */\n forUsers(options, cb) {\n return this._search('users', options, cb);\n }\n}\n\nmodule.exports = Search;\n","/**\n * @file\n * @copyright 2016 Matt Smith (Development Seed)\n * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n * Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\nimport debug from 'debug';\nconst log = debug('github:team');\n\n/**\n * A Team allows scoping of API requests to a particular Github Organization Team.\n */\nclass Team extends Requestable {\n /**\n * Create a Team.\n * @param {string} [teamId] - the id for the team\n * @param {Requestable.auth} [auth] - information required to authenticate to Github\n * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n */\n constructor(teamId, auth, apiBase) {\n super(auth, apiBase);\n this.__teamId = teamId;\n }\n\n /**\n * Get Team information\n * @see https://developer.github.com/v3/orgs/teams/#get-team\n * @param {Requestable.callback} [cb] - will receive the team\n * @return {Promise} - the promise for the http request\n */\n getTeam(cb) {\n log(`Fetching Team ${this.__teamId}`);\n return this._request('Get', `/teams/${this.__teamId}`, undefined, cb);\n }\n\n /**\n * List the Team's repositories\n * @see https://developer.github.com/v3/orgs/teams/#list-team-repos\n * @param {Requestable.callback} [cb] - will receive the list of repositories\n * @return {Promise} - the promise for the http request\n */\n listRepos(cb) {\n log(`Fetching repositories for Team ${this.__teamId}`);\n return this._requestAllPages(`/teams/${this.__teamId}/repos`, undefined, cb);\n }\n\n /**\n * Edit Team information\n * @see https://developer.github.com/v3/orgs/teams/#edit-team\n * @param {object} options - Parameters for team edit\n * @param {string} options.name - The name of the team\n * @param {string} [options.description] - Team description\n * @param {string} [options.repo_names] - Repos to add the team to\n * @param {string} [options.privacy=secret] - The level of privacy the team should have. Can be either one\n * of: `secret`, or `closed`\n * @param {Requestable.callback} [cb] - will receive the updated team\n * @return {Promise} - the promise for the http request\n */\n editTeam(options, cb) {\n log(`Editing Team ${this.__teamId}`);\n return this._request('PATCH', `/teams/${this.__teamId}`, options, cb);\n }\n\n /**\n * List the users who are members of the Team\n * @see https://developer.github.com/v3/orgs/teams/#list-team-members\n * @param {object} options - Parameters for listing team users\n * @param {string} [options.role=all] - can be one of: `all`, `maintainer`, or `member`\n * @param {Requestable.callback} [cb] - will receive the list of users\n * @return {Promise} - the promise for the http request\n */\n listMembers(options, cb) {\n log(`Getting members of Team ${this.__teamId}`);\n return this._requestAllPages(`/teams/${this.__teamId}/members`, options, cb);\n }\n\n /**\n * Get Team membership status for a user\n * @see https://developer.github.com/v3/orgs/teams/#get-team-membership\n * @param {string} username - can be one of: `all`, `maintainer`, or `member`\n * @param {Requestable.callback} [cb] - will receive the membership status of a user\n * @return {Promise} - the promise for the http request\n */\n getMembership(username, cb) {\n log(`Getting membership of user ${username} in Team ${this.__teamId}`);\n return this._request('GET', `/teams/${this.__teamId}/memberships/${username}`, undefined, cb);\n }\n\n /**\n * Add a member to the Team\n * @see https://developer.github.com/v3/orgs/teams/#add-team-membership\n * @param {string} username - can be one of: `all`, `maintainer`, or `member`\n * @param {object} options - Parameters for adding a team member\n * @param {string} [options.role=member] - The role that this user should have in the team. Can be one\n * of: `member`, or `maintainer`\n * @param {Requestable.callback} [cb] - will receive the membership status of added user\n * @return {Promise} - the promise for the http request\n */\n addMembership(username, options, cb) {\n log(`Adding user ${username} to Team ${this.__teamId}`);\n return this._request('PUT', `/teams/${this.__teamId}/memberships/${username}`, options, cb);\n }\n\n /**\n * Get repo management status for team\n * @see https://developer.github.com/v3/orgs/teams/#remove-team-membership\n * @param {string} owner - Organization name\n * @param {string} repo - Repo name\n * @param {Requestable.callback} [cb] - will receive the membership status of added user\n * @return {Promise} - the promise for the http request\n */\n isManagedRepo(owner, repo, cb) {\n log(`Getting repo management by Team ${this.__teamId} for repo ${owner}/${repo}`);\n return this._request204or404(`/teams/${this.__teamId}/repos/${owner}/${repo}`, undefined, cb);\n }\n\n /**\n * Add or Update repo management status for team\n * @see https://developer.github.com/v3/orgs/teams/#add-or-update-team-repository\n * @param {string} owner - Organization name\n * @param {string} repo - Repo name\n * @param {object} options - Parameters for adding or updating repo management for the team\n * @param {string} [options.permission] - The permission to grant the team on this repository. Can be one\n * of: `pull`, `push`, or `admin`\n * @param {Requestable.callback} [cb] - will receive the membership status of added user\n * @return {Promise} - the promise for the http request\n */\n manageRepo(owner, repo, options, cb) {\n log(`Adding or Updating repo management by Team ${this.__teamId} for repo ${owner}/${repo}`);\n return this._request204or404(`/teams/${this.__teamId}/repos/${owner}/${repo}`, options, cb, 'PUT');\n }\n\n /**\n * Remove repo management status for team\n * @see https://developer.github.com/v3/orgs/teams/#remove-team-repository\n * @param {string} owner - Organization name\n * @param {string} repo - Repo name\n * @param {Requestable.callback} [cb] - will receive the membership status of added user\n * @return {Promise} - the promise for the http request\n */\n unmanageRepo(owner, repo, cb) {\n log(`Remove repo management by Team ${this.__teamId} for repo ${owner}/${repo}`);\n return this._request204or404(`/teams/${this.__teamId}/repos/${owner}/${repo}`, undefined, cb, 'DELETE');\n }\n\n /**\n * Delete Team\n * @see https://developer.github.com/v3/orgs/teams/#delete-team\n * @param {Requestable.callback} [cb] - will receive the list of repositories\n * @return {Promise} - the promise for the http request\n */\n deleteTeam(cb) {\n log(`Deleting Team ${this.__teamId}`);\n return this._request204or404(`/teams/${this.__teamId}`, undefined, cb, 'DELETE');\n }\n}\n\nmodule.exports = Team;\n","/**\n * @file\n * @copyright 2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n * Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\nimport debug from 'debug';\nconst log = debug('github:user');\n\n/**\n * A User allows scoping of API requests to a particular Github user.\n */\nclass User extends Requestable {\n /**\n * Create a User.\n * @param {string} [username] - the user to use for user-scoped queries\n * @param {Requestable.auth} [auth] - information required to authenticate to Github\n * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n */\n constructor(username, auth, apiBase) {\n super(auth, apiBase);\n this.__user = username;\n }\n\n /**\n * Get the url for the request. (dependent on if we're requesting for the authenticated user or not)\n * @private\n * @param {string} endpoint - the endpoint being requested\n * @return {string} - the resolved endpoint\n */\n __getScopedUrl(endpoint) {\n if (this.__user) {\n return endpoint ?\n `/users/${this.__user}/${endpoint}` :\n `/users/${this.__user}`\n ;\n\n } else { // eslint-disable-line\n switch (endpoint) {\n case '':\n return '/user';\n\n case 'notifications':\n case 'gists':\n return `/${endpoint}`;\n\n default:\n return `/user/${endpoint}`;\n }\n }\n }\n\n /**\n * List the user's repositories\n * @see https://developer.github.com/v3/repos/#list-user-repositories\n * @param {Object} [options={}] - any options to refine the search\n * @param {Requestable.callback} [cb] - will receive the list of repositories\n * @return {Promise} - the promise for the http request\n */\n listRepos(options, cb) {\n if (typeof options === 'function') {\n cb = options;\n options = {};\n }\n\n options = this._getOptionsWithDefaults(options);\n\n log(`Fetching repositories with options: ${JSON.stringify(options)}`);\n return this._requestAllPages(this.__getScopedUrl('repos'), options, cb);\n }\n\n /**\n * List the orgs that the user belongs to\n * @see https://developer.github.com/v3/orgs/#list-user-organizations\n * @param {Requestable.callback} [cb] - will receive the list of organizations\n * @return {Promise} - the promise for the http request\n */\n listOrgs(cb) {\n return this._request('GET', this.__getScopedUrl('orgs'), null, cb);\n }\n\n /**\n * List the user's gists\n * @see https://developer.github.com/v3/gists/#list-a-users-gists\n * @param {Requestable.callback} [cb] - will receive the list of gists\n * @return {Promise} - the promise for the http request\n */\n listGists(cb) {\n return this._request('GET', this.__getScopedUrl('gists'), null, cb);\n }\n\n /**\n * List the user's starred gists\n * @see https://developer.github.com/v3/gists/#list-starred-gists\n * @param {Requestable.callback} [cb] - will receive the list of gists\n * @return {Promise} - the promise for the http request\n */\n listStarredGists(cb) {\n return this._request('GET', this.__getScopedUrl('gists/starred'), null, cb);\n }\n\n /**\n * List the user's gists\n * @see https://developer.github.com/v3/gists/#list-a-users-gists\n * @param {Requestable.callback} [cb] - will receive the list of gists\n * @return {Promise} - the promise for the http request\n */\n listStarredGists(cb) {\n return this._request('GET', this.__getScopedUrl('gists'), null, cb);\n }\n\n /**\n * List the user's notifications\n * @see https://developer.github.com/v3/activity/notifications/#list-your-notifications\n * @param {Object} [options={}] - any options to refine the search\n * @param {Requestable.callback} [cb] - will receive the list of repositories\n * @return {Promise} - the promise for the http request\n */\n listNotifications(options, cb) {\n options = options || {};\n if (typeof options === 'function') {\n cb = options;\n options = {};\n }\n\n options.since = this._dateToISO(options.since);\n options.before = this._dateToISO(options.before);\n\n return this._request('GET', this.__getScopedUrl('notifications'), options, cb);\n }\n\n /**\n * Show the user's profile\n * @see https://developer.github.com/v3/users/#get-a-single-user\n * @param {Requestable.callback} [cb] - will receive the user's information\n * @return {Promise} - the promise for the http request\n */\n getProfile(cb) {\n return this._request('GET', this.__getScopedUrl(''), null, cb);\n }\n\n /**\n * Gets the list of starred repositories for the user\n * @see https://developer.github.com/v3/activity/starring/#list-repositories-being-starred\n * @param {Requestable.callback} [cb] - will receive the list of starred repositories\n * @return {Promise} - the promise for the http request\n */\n listStarredRepos(cb) {\n let requestOptions = this._getOptionsWithDefaults();\n return this._requestAllPages(this.__getScopedUrl('starred'), requestOptions, cb);\n }\n\n /**\n * List email addresses for a user\n * @see https://developer.github.com/v3/users/emails/#list-email-addresses-for-a-user\n * @param {Requestable.callback} [cb] - will receive the list of emails\n * @return {Promise} - the promise for the http request\n */\n getEmails(cb) {\n return this._request('GET', '/user/emails', null, cb);\n }\n\n /**\n * Have the authenticated user follow this user\n * @see https://developer.github.com/v3/users/followers/#follow-a-user\n * @param {string} username - the user to follow\n * @param {Requestable.callback} [cb] - will receive true if the request succeeds\n * @return {Promise} - the promise for the http request\n */\n follow(username, cb) {\n return this._request('PUT', `/user/following/${this.__user}`, null, cb);\n }\n\n /**\n * Have the currently authenticated user unfollow this user\n * @see https://developer.github.com/v3/users/followers/#follow-a-user\n * @param {string} username - the user to unfollow\n * @param {Requestable.callback} [cb] - receives true if the request succeeds\n * @return {Promise} - the promise for the http request\n */\n unfollow(username, cb) {\n return this._request('DELETE', `/user/following/${this.__user}`, null, cb);\n }\n\n /**\n * Create a new repository for the currently authenticated user\n * @see https://developer.github.com/v3/repos/#create\n * @param {object} options - the repository definition\n * @param {Requestable.callback} [cb] - will receive the API response\n * @return {Promise} - the promise for the http request\n */\n createRepo(options, cb) {\n return this._request('POST', '/user/repos', options, cb);\n }\n}\n\nmodule.exports = User;\n","module.exports = require('./lib/axios');","'use strict';\n\nvar utils = require('./../utils');\nvar settle = require('./../core/settle');\nvar buildURL = require('./../helpers/buildURL');\nvar parseHeaders = require('./../helpers/parseHeaders');\nvar isURLSameOrigin = require('./../helpers/isURLSameOrigin');\nvar createError = require('../core/createError');\nvar btoa = (typeof window !== 'undefined' && window.btoa && window.btoa.bind(window)) || require('./../helpers/btoa');\n\nmodule.exports = function xhrAdapter(config) {\n return new Promise(function dispatchXhrRequest(resolve, reject) {\n var requestData = config.data;\n var requestHeaders = config.headers;\n\n if (utils.isFormData(requestData)) {\n delete requestHeaders['Content-Type']; // Let the browser set it\n }\n\n var request = new XMLHttpRequest();\n var loadEvent = 'onreadystatechange';\n var xDomain = false;\n\n // For IE 8/9 CORS support\n // Only supports POST and GET calls and doesn't returns the response headers.\n // DON'T do this for testing b/c XMLHttpRequest is mocked, not XDomainRequest.\n if (process.env.NODE_ENV !== 'test' &&\n typeof window !== 'undefined' &&\n window.XDomainRequest && !('withCredentials' in request) &&\n !isURLSameOrigin(config.url)) {\n request = new window.XDomainRequest();\n loadEvent = 'onload';\n xDomain = true;\n request.onprogress = function handleProgress() {};\n request.ontimeout = function handleTimeout() {};\n }\n\n // HTTP basic authentication\n if (config.auth) {\n var username = config.auth.username || '';\n var password = config.auth.password || '';\n requestHeaders.Authorization = 'Basic ' + btoa(username + ':' + password);\n }\n\n request.open(config.method.toUpperCase(), buildURL(config.url, config.params, config.paramsSerializer), true);\n\n // Set the request timeout in MS\n request.timeout = config.timeout;\n\n // Listen for ready state\n request[loadEvent] = function handleLoad() {\n if (!request || (request.readyState !== 4 && !xDomain)) {\n return;\n }\n\n // The request errored out and we didn't get a response, this will be\n // handled by onerror instead\n // With one exception: request that using file: protocol, most browsers\n // will return status as 0 even though it's a successful request\n if (request.status === 0 && !(request.responseURL && request.responseURL.indexOf('file:') === 0)) {\n return;\n }\n\n // Prepare the response\n var responseHeaders = 'getAllResponseHeaders' in request ? parseHeaders(request.getAllResponseHeaders()) : null;\n var responseData = !config.responseType || config.responseType === 'text' ? request.responseText : request.response;\n var response = {\n data: responseData,\n // IE sends 1223 instead of 204 (https://github.com/mzabriskie/axios/issues/201)\n status: request.status === 1223 ? 204 : request.status,\n statusText: request.status === 1223 ? 'No Content' : request.statusText,\n headers: responseHeaders,\n config: config,\n request: request\n };\n\n settle(resolve, reject, response);\n\n // Clean up request\n request = null;\n };\n\n // Handle low level network errors\n request.onerror = function handleError() {\n // Real errors are hidden from us by the browser\n // onerror should only fire if it's a network error\n reject(createError('Network Error', config));\n\n // Clean up request\n request = null;\n };\n\n // Handle timeout\n request.ontimeout = function handleTimeout() {\n reject(createError('timeout of ' + config.timeout + 'ms exceeded', config, 'ECONNABORTED'));\n\n // Clean up request\n request = null;\n };\n\n // Add xsrf header\n // This is only done if running in a standard browser environment.\n // Specifically not if we're in a web worker, or react-native.\n if (utils.isStandardBrowserEnv()) {\n var cookies = require('./../helpers/cookies');\n\n // Add xsrf header\n var xsrfValue = (config.withCredentials || isURLSameOrigin(config.url)) && config.xsrfCookieName ?\n cookies.read(config.xsrfCookieName) :\n undefined;\n\n if (xsrfValue) {\n requestHeaders[config.xsrfHeaderName] = xsrfValue;\n }\n }\n\n // Add headers to the request\n if ('setRequestHeader' in request) {\n utils.forEach(requestHeaders, function setRequestHeader(val, key) {\n if (typeof requestData === 'undefined' && key.toLowerCase() === 'content-type') {\n // Remove Content-Type if data is undefined\n delete requestHeaders[key];\n } else {\n // Otherwise add header to the request\n request.setRequestHeader(key, val);\n }\n });\n }\n\n // Add withCredentials to request if needed\n if (config.withCredentials) {\n request.withCredentials = true;\n }\n\n // Add responseType to request if needed\n if (config.responseType) {\n try {\n request.responseType = config.responseType;\n } catch (e) {\n if (request.responseType !== 'json') {\n throw e;\n }\n }\n }\n\n // Handle progress if needed\n if (typeof config.onDownloadProgress === 'function') {\n request.addEventListener('progress', config.onDownloadProgress);\n }\n\n // Not all browsers support upload events\n if (typeof config.onUploadProgress === 'function' && request.upload) {\n request.upload.addEventListener('progress', config.onUploadProgress);\n }\n\n if (config.cancelToken) {\n // Handle cancellation\n config.cancelToken.promise.then(function onCanceled(cancel) {\n if (!request) {\n return;\n }\n\n request.abort();\n reject(cancel);\n // Clean up request\n request = null;\n });\n }\n\n if (requestData === undefined) {\n requestData = null;\n }\n\n // Send the request\n request.send(requestData);\n });\n};\n","'use strict';\n\nvar utils = require('./utils');\nvar bind = require('./helpers/bind');\nvar Axios = require('./core/Axios');\nvar defaults = require('./defaults');\n\n/**\n * Create an instance of Axios\n *\n * @param {Object} defaultConfig The default config for the instance\n * @return {Axios} A new instance of Axios\n */\nfunction createInstance(defaultConfig) {\n var context = new Axios(defaultConfig);\n var instance = bind(Axios.prototype.request, context);\n\n // Copy axios.prototype to instance\n utils.extend(instance, Axios.prototype, context);\n\n // Copy context to instance\n utils.extend(instance, context);\n\n return instance;\n}\n\n// Create the default instance to be exported\nvar axios = createInstance(defaults);\n\n// Expose Axios class to allow class inheritance\naxios.Axios = Axios;\n\n// Factory for creating new instances\naxios.create = function create(instanceConfig) {\n return createInstance(utils.merge(defaults, instanceConfig));\n};\n\n// Expose Cancel & CancelToken\naxios.Cancel = require('./cancel/Cancel');\naxios.CancelToken = require('./cancel/CancelToken');\naxios.isCancel = require('./cancel/isCancel');\n\n// Expose all/spread\naxios.all = function all(promises) {\n return Promise.all(promises);\n};\naxios.spread = require('./helpers/spread');\n\nmodule.exports = axios;\n\n// Allow use of default import syntax in TypeScript\nmodule.exports.default = axios;\n","'use strict';\n\n/**\n * A `Cancel` is an object that is thrown when an operation is canceled.\n *\n * @class\n * @param {string=} message The message.\n */\nfunction Cancel(message) {\n this.message = message;\n}\n\nCancel.prototype.toString = function toString() {\n return 'Cancel' + (this.message ? ': ' + this.message : '');\n};\n\nCancel.prototype.__CANCEL__ = true;\n\nmodule.exports = Cancel;\n","'use strict';\n\nvar Cancel = require('./Cancel');\n\n/**\n * A `CancelToken` is an object that can be used to request cancellation of an operation.\n *\n * @class\n * @param {Function} executor The executor function.\n */\nfunction CancelToken(executor) {\n if (typeof executor !== 'function') {\n throw new TypeError('executor must be a function.');\n }\n\n var resolvePromise;\n this.promise = new Promise(function promiseExecutor(resolve) {\n resolvePromise = resolve;\n });\n\n var token = this;\n executor(function cancel(message) {\n if (token.reason) {\n // Cancellation has already been requested\n return;\n }\n\n token.reason = new Cancel(message);\n resolvePromise(token.reason);\n });\n}\n\n/**\n * Throws a `Cancel` if cancellation has been requested.\n */\nCancelToken.prototype.throwIfRequested = function throwIfRequested() {\n if (this.reason) {\n throw this.reason;\n }\n};\n\n/**\n * Returns an object that contains a new `CancelToken` and a function that, when called,\n * cancels the `CancelToken`.\n */\nCancelToken.source = function source() {\n var cancel;\n var token = new CancelToken(function executor(c) {\n cancel = c;\n });\n return {\n token: token,\n cancel: cancel\n };\n};\n\nmodule.exports = CancelToken;\n","'use strict';\n\nmodule.exports = function isCancel(value) {\n return !!(value && value.__CANCEL__);\n};\n","'use strict';\n\nvar defaults = require('./../defaults');\nvar utils = require('./../utils');\nvar InterceptorManager = require('./InterceptorManager');\nvar dispatchRequest = require('./dispatchRequest');\nvar isAbsoluteURL = require('./../helpers/isAbsoluteURL');\nvar combineURLs = require('./../helpers/combineURLs');\n\n/**\n * Create a new instance of Axios\n *\n * @param {Object} instanceConfig The default config for the instance\n */\nfunction Axios(instanceConfig) {\n this.defaults = instanceConfig;\n this.interceptors = {\n request: new InterceptorManager(),\n response: new InterceptorManager()\n };\n}\n\n/**\n * Dispatch a request\n *\n * @param {Object} config The config specific for this request (merged with this.defaults)\n */\nAxios.prototype.request = function request(config) {\n /*eslint no-param-reassign:0*/\n // Allow for axios('example/url'[, config]) a la fetch API\n if (typeof config === 'string') {\n config = utils.merge({\n url: arguments[0]\n }, arguments[1]);\n }\n\n config = utils.merge(defaults, this.defaults, { method: 'get' }, config);\n\n // Support baseURL config\n if (config.baseURL && !isAbsoluteURL(config.url)) {\n config.url = combineURLs(config.baseURL, config.url);\n }\n\n // Hook up interceptors middleware\n var chain = [dispatchRequest, undefined];\n var promise = Promise.resolve(config);\n\n this.interceptors.request.forEach(function unshiftRequestInterceptors(interceptor) {\n chain.unshift(interceptor.fulfilled, interceptor.rejected);\n });\n\n this.interceptors.response.forEach(function pushResponseInterceptors(interceptor) {\n chain.push(interceptor.fulfilled, interceptor.rejected);\n });\n\n while (chain.length) {\n promise = promise.then(chain.shift(), chain.shift());\n }\n\n return promise;\n};\n\n// Provide aliases for supported request methods\nutils.forEach(['delete', 'get', 'head'], function forEachMethodNoData(method) {\n /*eslint func-names:0*/\n Axios.prototype[method] = function(url, config) {\n return this.request(utils.merge(config || {}, {\n method: method,\n url: url\n }));\n };\n});\n\nutils.forEach(['post', 'put', 'patch'], function forEachMethodWithData(method) {\n /*eslint func-names:0*/\n Axios.prototype[method] = function(url, data, config) {\n return this.request(utils.merge(config || {}, {\n method: method,\n url: url,\n data: data\n }));\n };\n});\n\nmodule.exports = Axios;\n","'use strict';\n\nvar utils = require('./../utils');\n\nfunction InterceptorManager() {\n this.handlers = [];\n}\n\n/**\n * Add a new interceptor to the stack\n *\n * @param {Function} fulfilled The function to handle `then` for a `Promise`\n * @param {Function} rejected The function to handle `reject` for a `Promise`\n *\n * @return {Number} An ID used to remove interceptor later\n */\nInterceptorManager.prototype.use = function use(fulfilled, rejected) {\n this.handlers.push({\n fulfilled: fulfilled,\n rejected: rejected\n });\n return this.handlers.length - 1;\n};\n\n/**\n * Remove an interceptor from the stack\n *\n * @param {Number} id The ID that was returned by `use`\n */\nInterceptorManager.prototype.eject = function eject(id) {\n if (this.handlers[id]) {\n this.handlers[id] = null;\n }\n};\n\n/**\n * Iterate over all the registered interceptors\n *\n * This method is particularly useful for skipping over any\n * interceptors that may have become `null` calling `eject`.\n *\n * @param {Function} fn The function to call for each interceptor\n */\nInterceptorManager.prototype.forEach = function forEach(fn) {\n utils.forEach(this.handlers, function forEachHandler(h) {\n if (h !== null) {\n fn(h);\n }\n });\n};\n\nmodule.exports = InterceptorManager;\n","'use strict';\n\nvar enhanceError = require('./enhanceError');\n\n/**\n * Create an Error with the specified message, config, error code, and response.\n *\n * @param {string} message The error message.\n * @param {Object} config The config.\n * @param {string} [code] The error code (for example, 'ECONNABORTED').\n @ @param {Object} [response] The response.\n * @returns {Error} The created error.\n */\nmodule.exports = function createError(message, config, code, response) {\n var error = new Error(message);\n return enhanceError(error, config, code, response);\n};\n","'use strict';\n\nvar utils = require('./../utils');\nvar transformData = require('./transformData');\nvar isCancel = require('../cancel/isCancel');\nvar defaults = require('../defaults');\n\n/**\n * Throws a `Cancel` if cancellation has been requested.\n */\nfunction throwIfCancellationRequested(config) {\n if (config.cancelToken) {\n config.cancelToken.throwIfRequested();\n }\n}\n\n/**\n * Dispatch a request to the server using the configured adapter.\n *\n * @param {object} config The config that is to be used for the request\n * @returns {Promise} The Promise to be fulfilled\n */\nmodule.exports = function dispatchRequest(config) {\n throwIfCancellationRequested(config);\n\n // Ensure headers exist\n config.headers = config.headers || {};\n\n // Transform request data\n config.data = transformData(\n config.data,\n config.headers,\n config.transformRequest\n );\n\n // Flatten headers\n config.headers = utils.merge(\n config.headers.common || {},\n config.headers[config.method] || {},\n config.headers || {}\n );\n\n utils.forEach(\n ['delete', 'get', 'head', 'post', 'put', 'patch', 'common'],\n function cleanHeaderConfig(method) {\n delete config.headers[method];\n }\n );\n\n var adapter = config.adapter || defaults.adapter;\n\n return adapter(config).then(function onAdapterResolution(response) {\n throwIfCancellationRequested(config);\n\n // Transform response data\n response.data = transformData(\n response.data,\n response.headers,\n config.transformResponse\n );\n\n return response;\n }, function onAdapterRejection(reason) {\n if (!isCancel(reason)) {\n throwIfCancellationRequested(config);\n\n // Transform response data\n if (reason && reason.response) {\n reason.response.data = transformData(\n reason.response.data,\n reason.response.headers,\n config.transformResponse\n );\n }\n }\n\n return Promise.reject(reason);\n });\n};\n","'use strict';\n\n/**\n * Update an Error with the specified config, error code, and response.\n *\n * @param {Error} error The error to update.\n * @param {Object} config The config.\n * @param {string} [code] The error code (for example, 'ECONNABORTED').\n @ @param {Object} [response] The response.\n * @returns {Error} The error.\n */\nmodule.exports = function enhanceError(error, config, code, response) {\n error.config = config;\n if (code) {\n error.code = code;\n }\n error.response = response;\n return error;\n};\n","'use strict';\n\nvar createError = require('./createError');\n\n/**\n * Resolve or reject a Promise based on response status.\n *\n * @param {Function} resolve A function that resolves the promise.\n * @param {Function} reject A function that rejects the promise.\n * @param {object} response The response.\n */\nmodule.exports = function settle(resolve, reject, response) {\n var validateStatus = response.config.validateStatus;\n // Note: status is not exposed by XDomainRequest\n if (!response.status || !validateStatus || validateStatus(response.status)) {\n resolve(response);\n } else {\n reject(createError(\n 'Request failed with status code ' + response.status,\n response.config,\n null,\n response\n ));\n }\n};\n","'use strict';\n\nvar utils = require('./../utils');\n\n/**\n * Transform the data for a request or a response\n *\n * @param {Object|String} data The data to be transformed\n * @param {Array} headers The headers for the request or response\n * @param {Array|Function} fns A single function or Array of functions\n * @returns {*} The resulting transformed data\n */\nmodule.exports = function transformData(data, headers, fns) {\n /*eslint no-param-reassign:0*/\n utils.forEach(fns, function transform(fn) {\n data = fn(data, headers);\n });\n\n return data;\n};\n","'use strict';\n\nvar utils = require('./utils');\nvar normalizeHeaderName = require('./helpers/normalizeHeaderName');\n\nvar PROTECTION_PREFIX = /^\\)\\]\\}',?\\n/;\nvar DEFAULT_CONTENT_TYPE = {\n 'Content-Type': 'application/x-www-form-urlencoded'\n};\n\nfunction setContentTypeIfUnset(headers, value) {\n if (!utils.isUndefined(headers) && utils.isUndefined(headers['Content-Type'])) {\n headers['Content-Type'] = value;\n }\n}\n\nfunction getDefaultAdapter() {\n var adapter;\n if (typeof XMLHttpRequest !== 'undefined') {\n // For browsers use XHR adapter\n adapter = require('./adapters/xhr');\n } else if (typeof process !== 'undefined') {\n // For node use HTTP adapter\n adapter = require('./adapters/http');\n }\n return adapter;\n}\n\nvar defaults = {\n adapter: getDefaultAdapter(),\n\n transformRequest: [function transformRequest(data, headers) {\n normalizeHeaderName(headers, 'Content-Type');\n if (utils.isFormData(data) ||\n utils.isArrayBuffer(data) ||\n utils.isStream(data) ||\n utils.isFile(data) ||\n utils.isBlob(data)\n ) {\n return data;\n }\n if (utils.isArrayBufferView(data)) {\n return data.buffer;\n }\n if (utils.isURLSearchParams(data)) {\n setContentTypeIfUnset(headers, 'application/x-www-form-urlencoded;charset=utf-8');\n return data.toString();\n }\n if (utils.isObject(data)) {\n setContentTypeIfUnset(headers, 'application/json;charset=utf-8');\n return JSON.stringify(data);\n }\n return data;\n }],\n\n transformResponse: [function transformResponse(data) {\n /*eslint no-param-reassign:0*/\n if (typeof data === 'string') {\n data = data.replace(PROTECTION_PREFIX, '');\n try {\n data = JSON.parse(data);\n } catch (e) { /* Ignore */ }\n }\n return data;\n }],\n\n timeout: 0,\n\n xsrfCookieName: 'XSRF-TOKEN',\n xsrfHeaderName: 'X-XSRF-TOKEN',\n\n maxContentLength: -1,\n\n validateStatus: function validateStatus(status) {\n return status >= 200 && status < 300;\n }\n};\n\ndefaults.headers = {\n common: {\n 'Accept': 'application/json, text/plain, */*'\n }\n};\n\nutils.forEach(['delete', 'get', 'head'], function forEachMehtodNoData(method) {\n defaults.headers[method] = {};\n});\n\nutils.forEach(['post', 'put', 'patch'], function forEachMethodWithData(method) {\n defaults.headers[method] = utils.merge(DEFAULT_CONTENT_TYPE);\n});\n\nmodule.exports = defaults;\n","'use strict';\n\nmodule.exports = function bind(fn, thisArg) {\n return function wrap() {\n var args = new Array(arguments.length);\n for (var i = 0; i < args.length; i++) {\n args[i] = arguments[i];\n }\n return fn.apply(thisArg, args);\n };\n};\n","'use strict';\n\n// btoa polyfill for IE<10 courtesy https://github.com/davidchambers/Base64.js\n\nvar chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=';\n\nfunction E() {\n this.message = 'String contains an invalid character';\n}\nE.prototype = new Error;\nE.prototype.code = 5;\nE.prototype.name = 'InvalidCharacterError';\n\nfunction btoa(input) {\n var str = String(input);\n var output = '';\n for (\n // initialize result and counter\n var block, charCode, idx = 0, map = chars;\n // if the next str index does not exist:\n // change the mapping table to \"=\"\n // check if d has no fractional digits\n str.charAt(idx | 0) || (map = '=', idx % 1);\n // \"8 - idx % 1 * 8\" generates the sequence 2, 4, 6, 8\n output += map.charAt(63 & block >> 8 - idx % 1 * 8)\n ) {\n charCode = str.charCodeAt(idx += 3 / 4);\n if (charCode > 0xFF) {\n throw new E();\n }\n block = block << 8 | charCode;\n }\n return output;\n}\n\nmodule.exports = btoa;\n","'use strict';\n\nvar utils = require('./../utils');\n\nfunction encode(val) {\n return encodeURIComponent(val).\n replace(/%40/gi, '@').\n replace(/%3A/gi, ':').\n replace(/%24/g, '$').\n replace(/%2C/gi, ',').\n replace(/%20/g, '+').\n replace(/%5B/gi, '[').\n replace(/%5D/gi, ']');\n}\n\n/**\n * Build a URL by appending params to the end\n *\n * @param {string} url The base of the url (e.g., http://www.google.com)\n * @param {object} [params] The params to be appended\n * @returns {string} The formatted url\n */\nmodule.exports = function buildURL(url, params, paramsSerializer) {\n /*eslint no-param-reassign:0*/\n if (!params) {\n return url;\n }\n\n var serializedParams;\n if (paramsSerializer) {\n serializedParams = paramsSerializer(params);\n } else if (utils.isURLSearchParams(params)) {\n serializedParams = params.toString();\n } else {\n var parts = [];\n\n utils.forEach(params, function serialize(val, key) {\n if (val === null || typeof val === 'undefined') {\n return;\n }\n\n if (utils.isArray(val)) {\n key = key + '[]';\n }\n\n if (!utils.isArray(val)) {\n val = [val];\n }\n\n utils.forEach(val, function parseValue(v) {\n if (utils.isDate(v)) {\n v = v.toISOString();\n } else if (utils.isObject(v)) {\n v = JSON.stringify(v);\n }\n parts.push(encode(key) + '=' + encode(v));\n });\n });\n\n serializedParams = parts.join('&');\n }\n\n if (serializedParams) {\n url += (url.indexOf('?') === -1 ? '?' : '&') + serializedParams;\n }\n\n return url;\n};\n","'use strict';\n\n/**\n * Creates a new URL by combining the specified URLs\n *\n * @param {string} baseURL The base URL\n * @param {string} relativeURL The relative URL\n * @returns {string} The combined URL\n */\nmodule.exports = function combineURLs(baseURL, relativeURL) {\n return baseURL.replace(/\\/+$/, '') + '/' + relativeURL.replace(/^\\/+/, '');\n};\n","'use strict';\n\nvar utils = require('./../utils');\n\nmodule.exports = (\n utils.isStandardBrowserEnv() ?\n\n // Standard browser envs support document.cookie\n (function standardBrowserEnv() {\n return {\n write: function write(name, value, expires, path, domain, secure) {\n var cookie = [];\n cookie.push(name + '=' + encodeURIComponent(value));\n\n if (utils.isNumber(expires)) {\n cookie.push('expires=' + new Date(expires).toGMTString());\n }\n\n if (utils.isString(path)) {\n cookie.push('path=' + path);\n }\n\n if (utils.isString(domain)) {\n cookie.push('domain=' + domain);\n }\n\n if (secure === true) {\n cookie.push('secure');\n }\n\n document.cookie = cookie.join('; ');\n },\n\n read: function read(name) {\n var match = document.cookie.match(new RegExp('(^|;\\\\s*)(' + name + ')=([^;]*)'));\n return (match ? decodeURIComponent(match[3]) : null);\n },\n\n remove: function remove(name) {\n this.write(name, '', Date.now() - 86400000);\n }\n };\n })() :\n\n // Non standard browser env (web workers, react-native) lack needed support.\n (function nonStandardBrowserEnv() {\n return {\n write: function write() {},\n read: function read() { return null; },\n remove: function remove() {}\n };\n })()\n);\n","'use strict';\n\n/**\n * Determines whether the specified URL is absolute\n *\n * @param {string} url The URL to test\n * @returns {boolean} True if the specified URL is absolute, otherwise false\n */\nmodule.exports = function isAbsoluteURL(url) {\n // A URL is considered absolute if it begins with \"://\" or \"//\" (protocol-relative URL).\n // RFC 3986 defines scheme name as a sequence of characters beginning with a letter and followed\n // by any combination of letters, digits, plus, period, or hyphen.\n return /^([a-z][a-z\\d\\+\\-\\.]*:)?\\/\\//i.test(url);\n};\n","'use strict';\n\nvar utils = require('./../utils');\n\nmodule.exports = (\n utils.isStandardBrowserEnv() ?\n\n // Standard browser envs have full support of the APIs needed to test\n // whether the request URL is of the same origin as current location.\n (function standardBrowserEnv() {\n var msie = /(msie|trident)/i.test(navigator.userAgent);\n var urlParsingNode = document.createElement('a');\n var originURL;\n\n /**\n * Parse a URL to discover it's components\n *\n * @param {String} url The URL to be parsed\n * @returns {Object}\n */\n function resolveURL(url) {\n var href = url;\n\n if (msie) {\n // IE needs attribute set twice to normalize properties\n urlParsingNode.setAttribute('href', href);\n href = urlParsingNode.href;\n }\n\n urlParsingNode.setAttribute('href', href);\n\n // urlParsingNode provides the UrlUtils interface - http://url.spec.whatwg.org/#urlutils\n return {\n href: urlParsingNode.href,\n protocol: urlParsingNode.protocol ? urlParsingNode.protocol.replace(/:$/, '') : '',\n host: urlParsingNode.host,\n search: urlParsingNode.search ? urlParsingNode.search.replace(/^\\?/, '') : '',\n hash: urlParsingNode.hash ? urlParsingNode.hash.replace(/^#/, '') : '',\n hostname: urlParsingNode.hostname,\n port: urlParsingNode.port,\n pathname: (urlParsingNode.pathname.charAt(0) === '/') ?\n urlParsingNode.pathname :\n '/' + urlParsingNode.pathname\n };\n }\n\n originURL = resolveURL(window.location.href);\n\n /**\n * Determine if a URL shares the same origin as the current location\n *\n * @param {String} requestURL The URL to test\n * @returns {boolean} True if URL shares the same origin, otherwise false\n */\n return function isURLSameOrigin(requestURL) {\n var parsed = (utils.isString(requestURL)) ? resolveURL(requestURL) : requestURL;\n return (parsed.protocol === originURL.protocol &&\n parsed.host === originURL.host);\n };\n })() :\n\n // Non standard browser envs (web workers, react-native) lack needed support.\n (function nonStandardBrowserEnv() {\n return function isURLSameOrigin() {\n return true;\n };\n })()\n);\n","'use strict';\n\nvar utils = require('../utils');\n\nmodule.exports = function normalizeHeaderName(headers, normalizedName) {\n utils.forEach(headers, function processHeader(value, name) {\n if (name !== normalizedName && name.toUpperCase() === normalizedName.toUpperCase()) {\n headers[normalizedName] = value;\n delete headers[name];\n }\n });\n};\n","'use strict';\n\nvar utils = require('./../utils');\n\n/**\n * Parse headers into an object\n *\n * ```\n * Date: Wed, 27 Aug 2014 08:58:49 GMT\n * Content-Type: application/json\n * Connection: keep-alive\n * Transfer-Encoding: chunked\n * ```\n *\n * @param {String} headers Headers needing to be parsed\n * @returns {Object} Headers parsed into an object\n */\nmodule.exports = function parseHeaders(headers) {\n var parsed = {};\n var key;\n var val;\n var i;\n\n if (!headers) { return parsed; }\n\n utils.forEach(headers.split('\\n'), function parser(line) {\n i = line.indexOf(':');\n key = utils.trim(line.substr(0, i)).toLowerCase();\n val = utils.trim(line.substr(i + 1));\n\n if (key) {\n parsed[key] = parsed[key] ? parsed[key] + ', ' + val : val;\n }\n });\n\n return parsed;\n};\n","'use strict';\n\n/**\n * Syntactic sugar for invoking a function and expanding an array for arguments.\n *\n * Common use case would be to use `Function.prototype.apply`.\n *\n * ```js\n * function f(x, y, z) {}\n * var args = [1, 2, 3];\n * f.apply(null, args);\n * ```\n *\n * With `spread` this example can be re-written.\n *\n * ```js\n * spread(function(x, y, z) {})([1, 2, 3]);\n * ```\n *\n * @param {Function} callback\n * @returns {Function}\n */\nmodule.exports = function spread(callback) {\n return function wrap(arr) {\n return callback.apply(null, arr);\n };\n};\n","'use strict';\n\nvar bind = require('./helpers/bind');\n\n/*global toString:true*/\n\n// utils is a library of generic helper functions non-specific to axios\n\nvar toString = Object.prototype.toString;\n\n/**\n * Determine if a value is an Array\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if value is an Array, otherwise false\n */\nfunction isArray(val) {\n return toString.call(val) === '[object Array]';\n}\n\n/**\n * Determine if a value is an ArrayBuffer\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if value is an ArrayBuffer, otherwise false\n */\nfunction isArrayBuffer(val) {\n return toString.call(val) === '[object ArrayBuffer]';\n}\n\n/**\n * Determine if a value is a FormData\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if value is an FormData, otherwise false\n */\nfunction isFormData(val) {\n return (typeof FormData !== 'undefined') && (val instanceof FormData);\n}\n\n/**\n * Determine if a value is a view on an ArrayBuffer\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if value is a view on an ArrayBuffer, otherwise false\n */\nfunction isArrayBufferView(val) {\n var result;\n if ((typeof ArrayBuffer !== 'undefined') && (ArrayBuffer.isView)) {\n result = ArrayBuffer.isView(val);\n } else {\n result = (val) && (val.buffer) && (val.buffer instanceof ArrayBuffer);\n }\n return result;\n}\n\n/**\n * Determine if a value is a String\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if value is a String, otherwise false\n */\nfunction isString(val) {\n return typeof val === 'string';\n}\n\n/**\n * Determine if a value is a Number\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if value is a Number, otherwise false\n */\nfunction isNumber(val) {\n return typeof val === 'number';\n}\n\n/**\n * Determine if a value is undefined\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if the value is undefined, otherwise false\n */\nfunction isUndefined(val) {\n return typeof val === 'undefined';\n}\n\n/**\n * Determine if a value is an Object\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if value is an Object, otherwise false\n */\nfunction isObject(val) {\n return val !== null && typeof val === 'object';\n}\n\n/**\n * Determine if a value is a Date\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if value is a Date, otherwise false\n */\nfunction isDate(val) {\n return toString.call(val) === '[object Date]';\n}\n\n/**\n * Determine if a value is a File\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if value is a File, otherwise false\n */\nfunction isFile(val) {\n return toString.call(val) === '[object File]';\n}\n\n/**\n * Determine if a value is a Blob\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if value is a Blob, otherwise false\n */\nfunction isBlob(val) {\n return toString.call(val) === '[object Blob]';\n}\n\n/**\n * Determine if a value is a Function\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if value is a Function, otherwise false\n */\nfunction isFunction(val) {\n return toString.call(val) === '[object Function]';\n}\n\n/**\n * Determine if a value is a Stream\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if value is a Stream, otherwise false\n */\nfunction isStream(val) {\n return isObject(val) && isFunction(val.pipe);\n}\n\n/**\n * Determine if a value is a URLSearchParams object\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if value is a URLSearchParams object, otherwise false\n */\nfunction isURLSearchParams(val) {\n return typeof URLSearchParams !== 'undefined' && val instanceof URLSearchParams;\n}\n\n/**\n * Trim excess whitespace off the beginning and end of a string\n *\n * @param {String} str The String to trim\n * @returns {String} The String freed of excess whitespace\n */\nfunction trim(str) {\n return str.replace(/^\\s*/, '').replace(/\\s*$/, '');\n}\n\n/**\n * Determine if we're running in a standard browser environment\n *\n * This allows axios to run in a web worker, and react-native.\n * Both environments support XMLHttpRequest, but not fully standard globals.\n *\n * web workers:\n * typeof window -> undefined\n * typeof document -> undefined\n *\n * react-native:\n * typeof document.createElement -> undefined\n */\nfunction isStandardBrowserEnv() {\n return (\n typeof window !== 'undefined' &&\n typeof document !== 'undefined' &&\n typeof document.createElement === 'function'\n );\n}\n\n/**\n * Iterate over an Array or an Object invoking a function for each item.\n *\n * If `obj` is an Array callback will be called passing\n * the value, index, and complete array for each item.\n *\n * If 'obj' is an Object callback will be called passing\n * the value, key, and complete object for each property.\n *\n * @param {Object|Array} obj The object to iterate\n * @param {Function} fn The callback to invoke for each item\n */\nfunction forEach(obj, fn) {\n // Don't bother if no value provided\n if (obj === null || typeof obj === 'undefined') {\n return;\n }\n\n // Force an array if not already something iterable\n if (typeof obj !== 'object' && !isArray(obj)) {\n /*eslint no-param-reassign:0*/\n obj = [obj];\n }\n\n if (isArray(obj)) {\n // Iterate over array values\n for (var i = 0, l = obj.length; i < l; i++) {\n fn.call(null, obj[i], i, obj);\n }\n } else {\n // Iterate over object keys\n for (var key in obj) {\n if (Object.prototype.hasOwnProperty.call(obj, key)) {\n fn.call(null, obj[key], key, obj);\n }\n }\n }\n}\n\n/**\n * Accepts varargs expecting each argument to be an object, then\n * immutably merges the properties of each object and returns result.\n *\n * When multiple objects contain the same key the later object in\n * the arguments list will take precedence.\n *\n * Example:\n *\n * ```js\n * var result = merge({foo: 123}, {foo: 456});\n * console.log(result.foo); // outputs 456\n * ```\n *\n * @param {Object} obj1 Object to merge\n * @returns {Object} Result of all merge properties\n */\nfunction merge(/* obj1, obj2, obj3, ... */) {\n var result = {};\n function assignValue(val, key) {\n if (typeof result[key] === 'object' && typeof val === 'object') {\n result[key] = merge(result[key], val);\n } else {\n result[key] = val;\n }\n }\n\n for (var i = 0, l = arguments.length; i < l; i++) {\n forEach(arguments[i], assignValue);\n }\n return result;\n}\n\n/**\n * Extends object a by mutably adding to it the properties of object b.\n *\n * @param {Object} a The object to be extended\n * @param {Object} b The object to copy properties from\n * @param {Object} thisArg The object to bind function to\n * @return {Object} The resulting value of object a\n */\nfunction extend(a, b, thisArg) {\n forEach(b, function assignValue(val, key) {\n if (thisArg && typeof val === 'function') {\n a[key] = bind(val, thisArg);\n } else {\n a[key] = val;\n }\n });\n return a;\n}\n\nmodule.exports = {\n isArray: isArray,\n isArrayBuffer: isArrayBuffer,\n isFormData: isFormData,\n isArrayBufferView: isArrayBufferView,\n isString: isString,\n isNumber: isNumber,\n isObject: isObject,\n isUndefined: isUndefined,\n isDate: isDate,\n isFile: isFile,\n isBlob: isBlob,\n isFunction: isFunction,\n isStream: isStream,\n isURLSearchParams: isURLSearchParams,\n isStandardBrowserEnv: isStandardBrowserEnv,\n forEach: forEach,\n merge: merge,\n extend: extend,\n trim: trim\n};\n","'use strict'\n\nexports.byteLength = byteLength\nexports.toByteArray = toByteArray\nexports.fromByteArray = fromByteArray\n\nvar lookup = []\nvar revLookup = []\nvar Arr = typeof Uint8Array !== 'undefined' ? Uint8Array : Array\n\nvar code = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'\nfor (var i = 0, len = code.length; i < len; ++i) {\n lookup[i] = code[i]\n revLookup[code.charCodeAt(i)] = i\n}\n\nrevLookup['-'.charCodeAt(0)] = 62\nrevLookup['_'.charCodeAt(0)] = 63\n\nfunction placeHoldersCount (b64) {\n var len = b64.length\n if (len % 4 > 0) {\n throw new Error('Invalid string. Length must be a multiple of 4')\n }\n\n // the number of equal signs (place holders)\n // if there are two placeholders, than the two characters before it\n // represent one byte\n // if there is only one, then the three characters before it represent 2 bytes\n // this is just a cheap hack to not do indexOf twice\n return b64[len - 2] === '=' ? 2 : b64[len - 1] === '=' ? 1 : 0\n}\n\nfunction byteLength (b64) {\n // base64 is 4/3 + up to two characters of the original data\n return b64.length * 3 / 4 - placeHoldersCount(b64)\n}\n\nfunction toByteArray (b64) {\n var i, j, l, tmp, placeHolders, arr\n var len = b64.length\n placeHolders = placeHoldersCount(b64)\n\n arr = new Arr(len * 3 / 4 - placeHolders)\n\n // if there are placeholders, only get up to the last complete 4 chars\n l = placeHolders > 0 ? len - 4 : len\n\n var L = 0\n\n for (i = 0, j = 0; i < l; i += 4, j += 3) {\n tmp = (revLookup[b64.charCodeAt(i)] << 18) | (revLookup[b64.charCodeAt(i + 1)] << 12) | (revLookup[b64.charCodeAt(i + 2)] << 6) | revLookup[b64.charCodeAt(i + 3)]\n arr[L++] = (tmp >> 16) & 0xFF\n arr[L++] = (tmp >> 8) & 0xFF\n arr[L++] = tmp & 0xFF\n }\n\n if (placeHolders === 2) {\n tmp = (revLookup[b64.charCodeAt(i)] << 2) | (revLookup[b64.charCodeAt(i + 1)] >> 4)\n arr[L++] = tmp & 0xFF\n } else if (placeHolders === 1) {\n tmp = (revLookup[b64.charCodeAt(i)] << 10) | (revLookup[b64.charCodeAt(i + 1)] << 4) | (revLookup[b64.charCodeAt(i + 2)] >> 2)\n arr[L++] = (tmp >> 8) & 0xFF\n arr[L++] = tmp & 0xFF\n }\n\n return arr\n}\n\nfunction tripletToBase64 (num) {\n return lookup[num >> 18 & 0x3F] + lookup[num >> 12 & 0x3F] + lookup[num >> 6 & 0x3F] + lookup[num & 0x3F]\n}\n\nfunction encodeChunk (uint8, start, end) {\n var tmp\n var output = []\n for (var i = start; i < end; i += 3) {\n tmp = (uint8[i] << 16) + (uint8[i + 1] << 8) + (uint8[i + 2])\n output.push(tripletToBase64(tmp))\n }\n return output.join('')\n}\n\nfunction fromByteArray (uint8) {\n var tmp\n var len = uint8.length\n var extraBytes = len % 3 // if we have 1 byte left, pad 2 bytes\n var output = ''\n var parts = []\n var maxChunkLength = 16383 // must be multiple of 3\n\n // go through the array every three bytes, we'll deal with trailing stuff later\n for (var i = 0, len2 = len - extraBytes; i < len2; i += maxChunkLength) {\n parts.push(encodeChunk(uint8, i, (i + maxChunkLength) > len2 ? len2 : (i + maxChunkLength)))\n }\n\n // pad the end with zeros, but make sure to not forget the extra bytes\n if (extraBytes === 1) {\n tmp = uint8[len - 1]\n output += lookup[tmp >> 2]\n output += lookup[(tmp << 4) & 0x3F]\n output += '=='\n } else if (extraBytes === 2) {\n tmp = (uint8[len - 2] << 8) + (uint8[len - 1])\n output += lookup[tmp >> 10]\n output += lookup[(tmp >> 4) & 0x3F]\n output += lookup[(tmp << 2) & 0x3F]\n output += '='\n }\n\n parts.push(output)\n\n return parts.join('')\n}\n","/*!\n * The buffer module from node.js, for the browser.\n *\n * @author Feross Aboukhadijeh \n * @license MIT\n */\n/* eslint-disable no-proto */\n\n'use strict'\n\nvar base64 = require('base64-js')\nvar ieee754 = require('ieee754')\nvar isArray = require('isarray')\n\nexports.Buffer = Buffer\nexports.SlowBuffer = SlowBuffer\nexports.INSPECT_MAX_BYTES = 50\n\n/**\n * If `Buffer.TYPED_ARRAY_SUPPORT`:\n * === true Use Uint8Array implementation (fastest)\n * === false Use Object implementation (most compatible, even IE6)\n *\n * Browsers that support typed arrays are IE 10+, Firefox 4+, Chrome 7+, Safari 5.1+,\n * Opera 11.6+, iOS 4.2+.\n *\n * Due to various browser bugs, sometimes the Object implementation will be used even\n * when the browser supports typed arrays.\n *\n * Note:\n *\n * - Firefox 4-29 lacks support for adding new properties to `Uint8Array` instances,\n * See: https://bugzilla.mozilla.org/show_bug.cgi?id=695438.\n *\n * - Chrome 9-10 is missing the `TypedArray.prototype.subarray` function.\n *\n * - IE10 has a broken `TypedArray.prototype.subarray` function which returns arrays of\n * incorrect length in some situations.\n\n * We detect these buggy browsers and set `Buffer.TYPED_ARRAY_SUPPORT` to `false` so they\n * get the Object implementation, which is slower but behaves correctly.\n */\nBuffer.TYPED_ARRAY_SUPPORT = global.TYPED_ARRAY_SUPPORT !== undefined\n ? global.TYPED_ARRAY_SUPPORT\n : typedArraySupport()\n\n/*\n * Export kMaxLength after typed array support is determined.\n */\nexports.kMaxLength = kMaxLength()\n\nfunction typedArraySupport () {\n try {\n var arr = new Uint8Array(1)\n arr.__proto__ = {__proto__: Uint8Array.prototype, foo: function () { return 42 }}\n return arr.foo() === 42 && // typed array instances can be augmented\n typeof arr.subarray === 'function' && // chrome 9-10 lack `subarray`\n arr.subarray(1, 1).byteLength === 0 // ie10 has broken `subarray`\n } catch (e) {\n return false\n }\n}\n\nfunction kMaxLength () {\n return Buffer.TYPED_ARRAY_SUPPORT\n ? 0x7fffffff\n : 0x3fffffff\n}\n\nfunction createBuffer (that, length) {\n if (kMaxLength() < length) {\n throw new RangeError('Invalid typed array length')\n }\n if (Buffer.TYPED_ARRAY_SUPPORT) {\n // Return an augmented `Uint8Array` instance, for best performance\n that = new Uint8Array(length)\n that.__proto__ = Buffer.prototype\n } else {\n // Fallback: Return an object instance of the Buffer class\n if (that === null) {\n that = new Buffer(length)\n }\n that.length = length\n }\n\n return that\n}\n\n/**\n * The Buffer constructor returns instances of `Uint8Array` that have their\n * prototype changed to `Buffer.prototype`. Furthermore, `Buffer` is a subclass of\n * `Uint8Array`, so the returned instances will have all the node `Buffer` methods\n * and the `Uint8Array` methods. Square bracket notation works as expected -- it\n * returns a single octet.\n *\n * The `Uint8Array` prototype remains unmodified.\n */\n\nfunction Buffer (arg, encodingOrOffset, length) {\n if (!Buffer.TYPED_ARRAY_SUPPORT && !(this instanceof Buffer)) {\n return new Buffer(arg, encodingOrOffset, length)\n }\n\n // Common case.\n if (typeof arg === 'number') {\n if (typeof encodingOrOffset === 'string') {\n throw new Error(\n 'If encoding is specified then the first argument must be a string'\n )\n }\n return allocUnsafe(this, arg)\n }\n return from(this, arg, encodingOrOffset, length)\n}\n\nBuffer.poolSize = 8192 // not used by this implementation\n\n// TODO: Legacy, not needed anymore. Remove in next major version.\nBuffer._augment = function (arr) {\n arr.__proto__ = Buffer.prototype\n return arr\n}\n\nfunction from (that, value, encodingOrOffset, length) {\n if (typeof value === 'number') {\n throw new TypeError('\"value\" argument must not be a number')\n }\n\n if (typeof ArrayBuffer !== 'undefined' && value instanceof ArrayBuffer) {\n return fromArrayBuffer(that, value, encodingOrOffset, length)\n }\n\n if (typeof value === 'string') {\n return fromString(that, value, encodingOrOffset)\n }\n\n return fromObject(that, value)\n}\n\n/**\n * Functionally equivalent to Buffer(arg, encoding) but throws a TypeError\n * if value is a number.\n * Buffer.from(str[, encoding])\n * Buffer.from(array)\n * Buffer.from(buffer)\n * Buffer.from(arrayBuffer[, byteOffset[, length]])\n **/\nBuffer.from = function (value, encodingOrOffset, length) {\n return from(null, value, encodingOrOffset, length)\n}\n\nif (Buffer.TYPED_ARRAY_SUPPORT) {\n Buffer.prototype.__proto__ = Uint8Array.prototype\n Buffer.__proto__ = Uint8Array\n if (typeof Symbol !== 'undefined' && Symbol.species &&\n Buffer[Symbol.species] === Buffer) {\n // Fix subarray() in ES2016. See: https://github.com/feross/buffer/pull/97\n Object.defineProperty(Buffer, Symbol.species, {\n value: null,\n configurable: true\n })\n }\n}\n\nfunction assertSize (size) {\n if (typeof size !== 'number') {\n throw new TypeError('\"size\" argument must be a number')\n } else if (size < 0) {\n throw new RangeError('\"size\" argument must not be negative')\n }\n}\n\nfunction alloc (that, size, fill, encoding) {\n assertSize(size)\n if (size <= 0) {\n return createBuffer(that, size)\n }\n if (fill !== undefined) {\n // Only pay attention to encoding if it's a string. This\n // prevents accidentally sending in a number that would\n // be interpretted as a start offset.\n return typeof encoding === 'string'\n ? createBuffer(that, size).fill(fill, encoding)\n : createBuffer(that, size).fill(fill)\n }\n return createBuffer(that, size)\n}\n\n/**\n * Creates a new filled Buffer instance.\n * alloc(size[, fill[, encoding]])\n **/\nBuffer.alloc = function (size, fill, encoding) {\n return alloc(null, size, fill, encoding)\n}\n\nfunction allocUnsafe (that, size) {\n assertSize(size)\n that = createBuffer(that, size < 0 ? 0 : checked(size) | 0)\n if (!Buffer.TYPED_ARRAY_SUPPORT) {\n for (var i = 0; i < size; ++i) {\n that[i] = 0\n }\n }\n return that\n}\n\n/**\n * Equivalent to Buffer(num), by default creates a non-zero-filled Buffer instance.\n * */\nBuffer.allocUnsafe = function (size) {\n return allocUnsafe(null, size)\n}\n/**\n * Equivalent to SlowBuffer(num), by default creates a non-zero-filled Buffer instance.\n */\nBuffer.allocUnsafeSlow = function (size) {\n return allocUnsafe(null, size)\n}\n\nfunction fromString (that, string, encoding) {\n if (typeof encoding !== 'string' || encoding === '') {\n encoding = 'utf8'\n }\n\n if (!Buffer.isEncoding(encoding)) {\n throw new TypeError('\"encoding\" must be a valid string encoding')\n }\n\n var length = byteLength(string, encoding) | 0\n that = createBuffer(that, length)\n\n var actual = that.write(string, encoding)\n\n if (actual !== length) {\n // Writing a hex string, for example, that contains invalid characters will\n // cause everything after the first invalid character to be ignored. (e.g.\n // 'abxxcd' will be treated as 'ab')\n that = that.slice(0, actual)\n }\n\n return that\n}\n\nfunction fromArrayLike (that, array) {\n var length = array.length < 0 ? 0 : checked(array.length) | 0\n that = createBuffer(that, length)\n for (var i = 0; i < length; i += 1) {\n that[i] = array[i] & 255\n }\n return that\n}\n\nfunction fromArrayBuffer (that, array, byteOffset, length) {\n array.byteLength // this throws if `array` is not a valid ArrayBuffer\n\n if (byteOffset < 0 || array.byteLength < byteOffset) {\n throw new RangeError('\\'offset\\' is out of bounds')\n }\n\n if (array.byteLength < byteOffset + (length || 0)) {\n throw new RangeError('\\'length\\' is out of bounds')\n }\n\n if (byteOffset === undefined && length === undefined) {\n array = new Uint8Array(array)\n } else if (length === undefined) {\n array = new Uint8Array(array, byteOffset)\n } else {\n array = new Uint8Array(array, byteOffset, length)\n }\n\n if (Buffer.TYPED_ARRAY_SUPPORT) {\n // Return an augmented `Uint8Array` instance, for best performance\n that = array\n that.__proto__ = Buffer.prototype\n } else {\n // Fallback: Return an object instance of the Buffer class\n that = fromArrayLike(that, array)\n }\n return that\n}\n\nfunction fromObject (that, obj) {\n if (Buffer.isBuffer(obj)) {\n var len = checked(obj.length) | 0\n that = createBuffer(that, len)\n\n if (that.length === 0) {\n return that\n }\n\n obj.copy(that, 0, 0, len)\n return that\n }\n\n if (obj) {\n if ((typeof ArrayBuffer !== 'undefined' &&\n obj.buffer instanceof ArrayBuffer) || 'length' in obj) {\n if (typeof obj.length !== 'number' || isnan(obj.length)) {\n return createBuffer(that, 0)\n }\n return fromArrayLike(that, obj)\n }\n\n if (obj.type === 'Buffer' && isArray(obj.data)) {\n return fromArrayLike(that, obj.data)\n }\n }\n\n throw new TypeError('First argument must be a string, Buffer, ArrayBuffer, Array, or array-like object.')\n}\n\nfunction checked (length) {\n // Note: cannot use `length < kMaxLength()` here because that fails when\n // length is NaN (which is otherwise coerced to zero.)\n if (length >= kMaxLength()) {\n throw new RangeError('Attempt to allocate Buffer larger than maximum ' +\n 'size: 0x' + kMaxLength().toString(16) + ' bytes')\n }\n return length | 0\n}\n\nfunction SlowBuffer (length) {\n if (+length != length) { // eslint-disable-line eqeqeq\n length = 0\n }\n return Buffer.alloc(+length)\n}\n\nBuffer.isBuffer = function isBuffer (b) {\n return !!(b != null && b._isBuffer)\n}\n\nBuffer.compare = function compare (a, b) {\n if (!Buffer.isBuffer(a) || !Buffer.isBuffer(b)) {\n throw new TypeError('Arguments must be Buffers')\n }\n\n if (a === b) return 0\n\n var x = a.length\n var y = b.length\n\n for (var i = 0, len = Math.min(x, y); i < len; ++i) {\n if (a[i] !== b[i]) {\n x = a[i]\n y = b[i]\n break\n }\n }\n\n if (x < y) return -1\n if (y < x) return 1\n return 0\n}\n\nBuffer.isEncoding = function isEncoding (encoding) {\n switch (String(encoding).toLowerCase()) {\n case 'hex':\n case 'utf8':\n case 'utf-8':\n case 'ascii':\n case 'latin1':\n case 'binary':\n case 'base64':\n case 'ucs2':\n case 'ucs-2':\n case 'utf16le':\n case 'utf-16le':\n return true\n default:\n return false\n }\n}\n\nBuffer.concat = function concat (list, length) {\n if (!isArray(list)) {\n throw new TypeError('\"list\" argument must be an Array of Buffers')\n }\n\n if (list.length === 0) {\n return Buffer.alloc(0)\n }\n\n var i\n if (length === undefined) {\n length = 0\n for (i = 0; i < list.length; ++i) {\n length += list[i].length\n }\n }\n\n var buffer = Buffer.allocUnsafe(length)\n var pos = 0\n for (i = 0; i < list.length; ++i) {\n var buf = list[i]\n if (!Buffer.isBuffer(buf)) {\n throw new TypeError('\"list\" argument must be an Array of Buffers')\n }\n buf.copy(buffer, pos)\n pos += buf.length\n }\n return buffer\n}\n\nfunction byteLength (string, encoding) {\n if (Buffer.isBuffer(string)) {\n return string.length\n }\n if (typeof ArrayBuffer !== 'undefined' && typeof ArrayBuffer.isView === 'function' &&\n (ArrayBuffer.isView(string) || string instanceof ArrayBuffer)) {\n return string.byteLength\n }\n if (typeof string !== 'string') {\n string = '' + string\n }\n\n var len = string.length\n if (len === 0) return 0\n\n // Use a for loop to avoid recursion\n var loweredCase = false\n for (;;) {\n switch (encoding) {\n case 'ascii':\n case 'latin1':\n case 'binary':\n return len\n case 'utf8':\n case 'utf-8':\n case undefined:\n return utf8ToBytes(string).length\n case 'ucs2':\n case 'ucs-2':\n case 'utf16le':\n case 'utf-16le':\n return len * 2\n case 'hex':\n return len >>> 1\n case 'base64':\n return base64ToBytes(string).length\n default:\n if (loweredCase) return utf8ToBytes(string).length // assume utf8\n encoding = ('' + encoding).toLowerCase()\n loweredCase = true\n }\n }\n}\nBuffer.byteLength = byteLength\n\nfunction slowToString (encoding, start, end) {\n var loweredCase = false\n\n // No need to verify that \"this.length <= MAX_UINT32\" since it's a read-only\n // property of a typed array.\n\n // This behaves neither like String nor Uint8Array in that we set start/end\n // to their upper/lower bounds if the value passed is out of range.\n // undefined is handled specially as per ECMA-262 6th Edition,\n // Section 13.3.3.7 Runtime Semantics: KeyedBindingInitialization.\n if (start === undefined || start < 0) {\n start = 0\n }\n // Return early if start > this.length. Done here to prevent potential uint32\n // coercion fail below.\n if (start > this.length) {\n return ''\n }\n\n if (end === undefined || end > this.length) {\n end = this.length\n }\n\n if (end <= 0) {\n return ''\n }\n\n // Force coersion to uint32. This will also coerce falsey/NaN values to 0.\n end >>>= 0\n start >>>= 0\n\n if (end <= start) {\n return ''\n }\n\n if (!encoding) encoding = 'utf8'\n\n while (true) {\n switch (encoding) {\n case 'hex':\n return hexSlice(this, start, end)\n\n case 'utf8':\n case 'utf-8':\n return utf8Slice(this, start, end)\n\n case 'ascii':\n return asciiSlice(this, start, end)\n\n case 'latin1':\n case 'binary':\n return latin1Slice(this, start, end)\n\n case 'base64':\n return base64Slice(this, start, end)\n\n case 'ucs2':\n case 'ucs-2':\n case 'utf16le':\n case 'utf-16le':\n return utf16leSlice(this, start, end)\n\n default:\n if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)\n encoding = (encoding + '').toLowerCase()\n loweredCase = true\n }\n }\n}\n\n// The property is used by `Buffer.isBuffer` and `is-buffer` (in Safari 5-7) to detect\n// Buffer instances.\nBuffer.prototype._isBuffer = true\n\nfunction swap (b, n, m) {\n var i = b[n]\n b[n] = b[m]\n b[m] = i\n}\n\nBuffer.prototype.swap16 = function swap16 () {\n var len = this.length\n if (len % 2 !== 0) {\n throw new RangeError('Buffer size must be a multiple of 16-bits')\n }\n for (var i = 0; i < len; i += 2) {\n swap(this, i, i + 1)\n }\n return this\n}\n\nBuffer.prototype.swap32 = function swap32 () {\n var len = this.length\n if (len % 4 !== 0) {\n throw new RangeError('Buffer size must be a multiple of 32-bits')\n }\n for (var i = 0; i < len; i += 4) {\n swap(this, i, i + 3)\n swap(this, i + 1, i + 2)\n }\n return this\n}\n\nBuffer.prototype.swap64 = function swap64 () {\n var len = this.length\n if (len % 8 !== 0) {\n throw new RangeError('Buffer size must be a multiple of 64-bits')\n }\n for (var i = 0; i < len; i += 8) {\n swap(this, i, i + 7)\n swap(this, i + 1, i + 6)\n swap(this, i + 2, i + 5)\n swap(this, i + 3, i + 4)\n }\n return this\n}\n\nBuffer.prototype.toString = function toString () {\n var length = this.length | 0\n if (length === 0) return ''\n if (arguments.length === 0) return utf8Slice(this, 0, length)\n return slowToString.apply(this, arguments)\n}\n\nBuffer.prototype.equals = function equals (b) {\n if (!Buffer.isBuffer(b)) throw new TypeError('Argument must be a Buffer')\n if (this === b) return true\n return Buffer.compare(this, b) === 0\n}\n\nBuffer.prototype.inspect = function inspect () {\n var str = ''\n var max = exports.INSPECT_MAX_BYTES\n if (this.length > 0) {\n str = this.toString('hex', 0, max).match(/.{2}/g).join(' ')\n if (this.length > max) str += ' ... '\n }\n return ''\n}\n\nBuffer.prototype.compare = function compare (target, start, end, thisStart, thisEnd) {\n if (!Buffer.isBuffer(target)) {\n throw new TypeError('Argument must be a Buffer')\n }\n\n if (start === undefined) {\n start = 0\n }\n if (end === undefined) {\n end = target ? target.length : 0\n }\n if (thisStart === undefined) {\n thisStart = 0\n }\n if (thisEnd === undefined) {\n thisEnd = this.length\n }\n\n if (start < 0 || end > target.length || thisStart < 0 || thisEnd > this.length) {\n throw new RangeError('out of range index')\n }\n\n if (thisStart >= thisEnd && start >= end) {\n return 0\n }\n if (thisStart >= thisEnd) {\n return -1\n }\n if (start >= end) {\n return 1\n }\n\n start >>>= 0\n end >>>= 0\n thisStart >>>= 0\n thisEnd >>>= 0\n\n if (this === target) return 0\n\n var x = thisEnd - thisStart\n var y = end - start\n var len = Math.min(x, y)\n\n var thisCopy = this.slice(thisStart, thisEnd)\n var targetCopy = target.slice(start, end)\n\n for (var i = 0; i < len; ++i) {\n if (thisCopy[i] !== targetCopy[i]) {\n x = thisCopy[i]\n y = targetCopy[i]\n break\n }\n }\n\n if (x < y) return -1\n if (y < x) return 1\n return 0\n}\n\n// Finds either the first index of `val` in `buffer` at offset >= `byteOffset`,\n// OR the last index of `val` in `buffer` at offset <= `byteOffset`.\n//\n// Arguments:\n// - buffer - a Buffer to search\n// - val - a string, Buffer, or number\n// - byteOffset - an index into `buffer`; will be clamped to an int32\n// - encoding - an optional encoding, relevant is val is a string\n// - dir - true for indexOf, false for lastIndexOf\nfunction bidirectionalIndexOf (buffer, val, byteOffset, encoding, dir) {\n // Empty buffer means no match\n if (buffer.length === 0) return -1\n\n // Normalize byteOffset\n if (typeof byteOffset === 'string') {\n encoding = byteOffset\n byteOffset = 0\n } else if (byteOffset > 0x7fffffff) {\n byteOffset = 0x7fffffff\n } else if (byteOffset < -0x80000000) {\n byteOffset = -0x80000000\n }\n byteOffset = +byteOffset // Coerce to Number.\n if (isNaN(byteOffset)) {\n // byteOffset: it it's undefined, null, NaN, \"foo\", etc, search whole buffer\n byteOffset = dir ? 0 : (buffer.length - 1)\n }\n\n // Normalize byteOffset: negative offsets start from the end of the buffer\n if (byteOffset < 0) byteOffset = buffer.length + byteOffset\n if (byteOffset >= buffer.length) {\n if (dir) return -1\n else byteOffset = buffer.length - 1\n } else if (byteOffset < 0) {\n if (dir) byteOffset = 0\n else return -1\n }\n\n // Normalize val\n if (typeof val === 'string') {\n val = Buffer.from(val, encoding)\n }\n\n // Finally, search either indexOf (if dir is true) or lastIndexOf\n if (Buffer.isBuffer(val)) {\n // Special case: looking for empty string/buffer always fails\n if (val.length === 0) {\n return -1\n }\n return arrayIndexOf(buffer, val, byteOffset, encoding, dir)\n } else if (typeof val === 'number') {\n val = val & 0xFF // Search for a byte value [0-255]\n if (Buffer.TYPED_ARRAY_SUPPORT &&\n typeof Uint8Array.prototype.indexOf === 'function') {\n if (dir) {\n return Uint8Array.prototype.indexOf.call(buffer, val, byteOffset)\n } else {\n return Uint8Array.prototype.lastIndexOf.call(buffer, val, byteOffset)\n }\n }\n return arrayIndexOf(buffer, [ val ], byteOffset, encoding, dir)\n }\n\n throw new TypeError('val must be string, number or Buffer')\n}\n\nfunction arrayIndexOf (arr, val, byteOffset, encoding, dir) {\n var indexSize = 1\n var arrLength = arr.length\n var valLength = val.length\n\n if (encoding !== undefined) {\n encoding = String(encoding).toLowerCase()\n if (encoding === 'ucs2' || encoding === 'ucs-2' ||\n encoding === 'utf16le' || encoding === 'utf-16le') {\n if (arr.length < 2 || val.length < 2) {\n return -1\n }\n indexSize = 2\n arrLength /= 2\n valLength /= 2\n byteOffset /= 2\n }\n }\n\n function read (buf, i) {\n if (indexSize === 1) {\n return buf[i]\n } else {\n return buf.readUInt16BE(i * indexSize)\n }\n }\n\n var i\n if (dir) {\n var foundIndex = -1\n for (i = byteOffset; i < arrLength; i++) {\n if (read(arr, i) === read(val, foundIndex === -1 ? 0 : i - foundIndex)) {\n if (foundIndex === -1) foundIndex = i\n if (i - foundIndex + 1 === valLength) return foundIndex * indexSize\n } else {\n if (foundIndex !== -1) i -= i - foundIndex\n foundIndex = -1\n }\n }\n } else {\n if (byteOffset + valLength > arrLength) byteOffset = arrLength - valLength\n for (i = byteOffset; i >= 0; i--) {\n var found = true\n for (var j = 0; j < valLength; j++) {\n if (read(arr, i + j) !== read(val, j)) {\n found = false\n break\n }\n }\n if (found) return i\n }\n }\n\n return -1\n}\n\nBuffer.prototype.includes = function includes (val, byteOffset, encoding) {\n return this.indexOf(val, byteOffset, encoding) !== -1\n}\n\nBuffer.prototype.indexOf = function indexOf (val, byteOffset, encoding) {\n return bidirectionalIndexOf(this, val, byteOffset, encoding, true)\n}\n\nBuffer.prototype.lastIndexOf = function lastIndexOf (val, byteOffset, encoding) {\n return bidirectionalIndexOf(this, val, byteOffset, encoding, false)\n}\n\nfunction hexWrite (buf, string, offset, length) {\n offset = Number(offset) || 0\n var remaining = buf.length - offset\n if (!length) {\n length = remaining\n } else {\n length = Number(length)\n if (length > remaining) {\n length = remaining\n }\n }\n\n // must be an even number of digits\n var strLen = string.length\n if (strLen % 2 !== 0) throw new TypeError('Invalid hex string')\n\n if (length > strLen / 2) {\n length = strLen / 2\n }\n for (var i = 0; i < length; ++i) {\n var parsed = parseInt(string.substr(i * 2, 2), 16)\n if (isNaN(parsed)) return i\n buf[offset + i] = parsed\n }\n return i\n}\n\nfunction utf8Write (buf, string, offset, length) {\n return blitBuffer(utf8ToBytes(string, buf.length - offset), buf, offset, length)\n}\n\nfunction asciiWrite (buf, string, offset, length) {\n return blitBuffer(asciiToBytes(string), buf, offset, length)\n}\n\nfunction latin1Write (buf, string, offset, length) {\n return asciiWrite(buf, string, offset, length)\n}\n\nfunction base64Write (buf, string, offset, length) {\n return blitBuffer(base64ToBytes(string), buf, offset, length)\n}\n\nfunction ucs2Write (buf, string, offset, length) {\n return blitBuffer(utf16leToBytes(string, buf.length - offset), buf, offset, length)\n}\n\nBuffer.prototype.write = function write (string, offset, length, encoding) {\n // Buffer#write(string)\n if (offset === undefined) {\n encoding = 'utf8'\n length = this.length\n offset = 0\n // Buffer#write(string, encoding)\n } else if (length === undefined && typeof offset === 'string') {\n encoding = offset\n length = this.length\n offset = 0\n // Buffer#write(string, offset[, length][, encoding])\n } else if (isFinite(offset)) {\n offset = offset | 0\n if (isFinite(length)) {\n length = length | 0\n if (encoding === undefined) encoding = 'utf8'\n } else {\n encoding = length\n length = undefined\n }\n // legacy write(string, encoding, offset, length) - remove in v0.13\n } else {\n throw new Error(\n 'Buffer.write(string, encoding, offset[, length]) is no longer supported'\n )\n }\n\n var remaining = this.length - offset\n if (length === undefined || length > remaining) length = remaining\n\n if ((string.length > 0 && (length < 0 || offset < 0)) || offset > this.length) {\n throw new RangeError('Attempt to write outside buffer bounds')\n }\n\n if (!encoding) encoding = 'utf8'\n\n var loweredCase = false\n for (;;) {\n switch (encoding) {\n case 'hex':\n return hexWrite(this, string, offset, length)\n\n case 'utf8':\n case 'utf-8':\n return utf8Write(this, string, offset, length)\n\n case 'ascii':\n return asciiWrite(this, string, offset, length)\n\n case 'latin1':\n case 'binary':\n return latin1Write(this, string, offset, length)\n\n case 'base64':\n // Warning: maxLength not taken into account in base64Write\n return base64Write(this, string, offset, length)\n\n case 'ucs2':\n case 'ucs-2':\n case 'utf16le':\n case 'utf-16le':\n return ucs2Write(this, string, offset, length)\n\n default:\n if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)\n encoding = ('' + encoding).toLowerCase()\n loweredCase = true\n }\n }\n}\n\nBuffer.prototype.toJSON = function toJSON () {\n return {\n type: 'Buffer',\n data: Array.prototype.slice.call(this._arr || this, 0)\n }\n}\n\nfunction base64Slice (buf, start, end) {\n if (start === 0 && end === buf.length) {\n return base64.fromByteArray(buf)\n } else {\n return base64.fromByteArray(buf.slice(start, end))\n }\n}\n\nfunction utf8Slice (buf, start, end) {\n end = Math.min(buf.length, end)\n var res = []\n\n var i = start\n while (i < end) {\n var firstByte = buf[i]\n var codePoint = null\n var bytesPerSequence = (firstByte > 0xEF) ? 4\n : (firstByte > 0xDF) ? 3\n : (firstByte > 0xBF) ? 2\n : 1\n\n if (i + bytesPerSequence <= end) {\n var secondByte, thirdByte, fourthByte, tempCodePoint\n\n switch (bytesPerSequence) {\n case 1:\n if (firstByte < 0x80) {\n codePoint = firstByte\n }\n break\n case 2:\n secondByte = buf[i + 1]\n if ((secondByte & 0xC0) === 0x80) {\n tempCodePoint = (firstByte & 0x1F) << 0x6 | (secondByte & 0x3F)\n if (tempCodePoint > 0x7F) {\n codePoint = tempCodePoint\n }\n }\n break\n case 3:\n secondByte = buf[i + 1]\n thirdByte = buf[i + 2]\n if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80) {\n tempCodePoint = (firstByte & 0xF) << 0xC | (secondByte & 0x3F) << 0x6 | (thirdByte & 0x3F)\n if (tempCodePoint > 0x7FF && (tempCodePoint < 0xD800 || tempCodePoint > 0xDFFF)) {\n codePoint = tempCodePoint\n }\n }\n break\n case 4:\n secondByte = buf[i + 1]\n thirdByte = buf[i + 2]\n fourthByte = buf[i + 3]\n if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80 && (fourthByte & 0xC0) === 0x80) {\n tempCodePoint = (firstByte & 0xF) << 0x12 | (secondByte & 0x3F) << 0xC | (thirdByte & 0x3F) << 0x6 | (fourthByte & 0x3F)\n if (tempCodePoint > 0xFFFF && tempCodePoint < 0x110000) {\n codePoint = tempCodePoint\n }\n }\n }\n }\n\n if (codePoint === null) {\n // we did not generate a valid codePoint so insert a\n // replacement char (U+FFFD) and advance only 1 byte\n codePoint = 0xFFFD\n bytesPerSequence = 1\n } else if (codePoint > 0xFFFF) {\n // encode to utf16 (surrogate pair dance)\n codePoint -= 0x10000\n res.push(codePoint >>> 10 & 0x3FF | 0xD800)\n codePoint = 0xDC00 | codePoint & 0x3FF\n }\n\n res.push(codePoint)\n i += bytesPerSequence\n }\n\n return decodeCodePointsArray(res)\n}\n\n// Based on http://stackoverflow.com/a/22747272/680742, the browser with\n// the lowest limit is Chrome, with 0x10000 args.\n// We go 1 magnitude less, for safety\nvar MAX_ARGUMENTS_LENGTH = 0x1000\n\nfunction decodeCodePointsArray (codePoints) {\n var len = codePoints.length\n if (len <= MAX_ARGUMENTS_LENGTH) {\n return String.fromCharCode.apply(String, codePoints) // avoid extra slice()\n }\n\n // Decode in chunks to avoid \"call stack size exceeded\".\n var res = ''\n var i = 0\n while (i < len) {\n res += String.fromCharCode.apply(\n String,\n codePoints.slice(i, i += MAX_ARGUMENTS_LENGTH)\n )\n }\n return res\n}\n\nfunction asciiSlice (buf, start, end) {\n var ret = ''\n end = Math.min(buf.length, end)\n\n for (var i = start; i < end; ++i) {\n ret += String.fromCharCode(buf[i] & 0x7F)\n }\n return ret\n}\n\nfunction latin1Slice (buf, start, end) {\n var ret = ''\n end = Math.min(buf.length, end)\n\n for (var i = start; i < end; ++i) {\n ret += String.fromCharCode(buf[i])\n }\n return ret\n}\n\nfunction hexSlice (buf, start, end) {\n var len = buf.length\n\n if (!start || start < 0) start = 0\n if (!end || end < 0 || end > len) end = len\n\n var out = ''\n for (var i = start; i < end; ++i) {\n out += toHex(buf[i])\n }\n return out\n}\n\nfunction utf16leSlice (buf, start, end) {\n var bytes = buf.slice(start, end)\n var res = ''\n for (var i = 0; i < bytes.length; i += 2) {\n res += String.fromCharCode(bytes[i] + bytes[i + 1] * 256)\n }\n return res\n}\n\nBuffer.prototype.slice = function slice (start, end) {\n var len = this.length\n start = ~~start\n end = end === undefined ? len : ~~end\n\n if (start < 0) {\n start += len\n if (start < 0) start = 0\n } else if (start > len) {\n start = len\n }\n\n if (end < 0) {\n end += len\n if (end < 0) end = 0\n } else if (end > len) {\n end = len\n }\n\n if (end < start) end = start\n\n var newBuf\n if (Buffer.TYPED_ARRAY_SUPPORT) {\n newBuf = this.subarray(start, end)\n newBuf.__proto__ = Buffer.prototype\n } else {\n var sliceLen = end - start\n newBuf = new Buffer(sliceLen, undefined)\n for (var i = 0; i < sliceLen; ++i) {\n newBuf[i] = this[i + start]\n }\n }\n\n return newBuf\n}\n\n/*\n * Need to make sure that buffer isn't trying to write out of bounds.\n */\nfunction checkOffset (offset, ext, length) {\n if ((offset % 1) !== 0 || offset < 0) throw new RangeError('offset is not uint')\n if (offset + ext > length) throw new RangeError('Trying to access beyond buffer length')\n}\n\nBuffer.prototype.readUIntLE = function readUIntLE (offset, byteLength, noAssert) {\n offset = offset | 0\n byteLength = byteLength | 0\n if (!noAssert) checkOffset(offset, byteLength, this.length)\n\n var val = this[offset]\n var mul = 1\n var i = 0\n while (++i < byteLength && (mul *= 0x100)) {\n val += this[offset + i] * mul\n }\n\n return val\n}\n\nBuffer.prototype.readUIntBE = function readUIntBE (offset, byteLength, noAssert) {\n offset = offset | 0\n byteLength = byteLength | 0\n if (!noAssert) {\n checkOffset(offset, byteLength, this.length)\n }\n\n var val = this[offset + --byteLength]\n var mul = 1\n while (byteLength > 0 && (mul *= 0x100)) {\n val += this[offset + --byteLength] * mul\n }\n\n return val\n}\n\nBuffer.prototype.readUInt8 = function readUInt8 (offset, noAssert) {\n if (!noAssert) checkOffset(offset, 1, this.length)\n return this[offset]\n}\n\nBuffer.prototype.readUInt16LE = function readUInt16LE (offset, noAssert) {\n if (!noAssert) checkOffset(offset, 2, this.length)\n return this[offset] | (this[offset + 1] << 8)\n}\n\nBuffer.prototype.readUInt16BE = function readUInt16BE (offset, noAssert) {\n if (!noAssert) checkOffset(offset, 2, this.length)\n return (this[offset] << 8) | this[offset + 1]\n}\n\nBuffer.prototype.readUInt32LE = function readUInt32LE (offset, noAssert) {\n if (!noAssert) checkOffset(offset, 4, this.length)\n\n return ((this[offset]) |\n (this[offset + 1] << 8) |\n (this[offset + 2] << 16)) +\n (this[offset + 3] * 0x1000000)\n}\n\nBuffer.prototype.readUInt32BE = function readUInt32BE (offset, noAssert) {\n if (!noAssert) checkOffset(offset, 4, this.length)\n\n return (this[offset] * 0x1000000) +\n ((this[offset + 1] << 16) |\n (this[offset + 2] << 8) |\n this[offset + 3])\n}\n\nBuffer.prototype.readIntLE = function readIntLE (offset, byteLength, noAssert) {\n offset = offset | 0\n byteLength = byteLength | 0\n if (!noAssert) checkOffset(offset, byteLength, this.length)\n\n var val = this[offset]\n var mul = 1\n var i = 0\n while (++i < byteLength && (mul *= 0x100)) {\n val += this[offset + i] * mul\n }\n mul *= 0x80\n\n if (val >= mul) val -= Math.pow(2, 8 * byteLength)\n\n return val\n}\n\nBuffer.prototype.readIntBE = function readIntBE (offset, byteLength, noAssert) {\n offset = offset | 0\n byteLength = byteLength | 0\n if (!noAssert) checkOffset(offset, byteLength, this.length)\n\n var i = byteLength\n var mul = 1\n var val = this[offset + --i]\n while (i > 0 && (mul *= 0x100)) {\n val += this[offset + --i] * mul\n }\n mul *= 0x80\n\n if (val >= mul) val -= Math.pow(2, 8 * byteLength)\n\n return val\n}\n\nBuffer.prototype.readInt8 = function readInt8 (offset, noAssert) {\n if (!noAssert) checkOffset(offset, 1, this.length)\n if (!(this[offset] & 0x80)) return (this[offset])\n return ((0xff - this[offset] + 1) * -1)\n}\n\nBuffer.prototype.readInt16LE = function readInt16LE (offset, noAssert) {\n if (!noAssert) checkOffset(offset, 2, this.length)\n var val = this[offset] | (this[offset + 1] << 8)\n return (val & 0x8000) ? val | 0xFFFF0000 : val\n}\n\nBuffer.prototype.readInt16BE = function readInt16BE (offset, noAssert) {\n if (!noAssert) checkOffset(offset, 2, this.length)\n var val = this[offset + 1] | (this[offset] << 8)\n return (val & 0x8000) ? val | 0xFFFF0000 : val\n}\n\nBuffer.prototype.readInt32LE = function readInt32LE (offset, noAssert) {\n if (!noAssert) checkOffset(offset, 4, this.length)\n\n return (this[offset]) |\n (this[offset + 1] << 8) |\n (this[offset + 2] << 16) |\n (this[offset + 3] << 24)\n}\n\nBuffer.prototype.readInt32BE = function readInt32BE (offset, noAssert) {\n if (!noAssert) checkOffset(offset, 4, this.length)\n\n return (this[offset] << 24) |\n (this[offset + 1] << 16) |\n (this[offset + 2] << 8) |\n (this[offset + 3])\n}\n\nBuffer.prototype.readFloatLE = function readFloatLE (offset, noAssert) {\n if (!noAssert) checkOffset(offset, 4, this.length)\n return ieee754.read(this, offset, true, 23, 4)\n}\n\nBuffer.prototype.readFloatBE = function readFloatBE (offset, noAssert) {\n if (!noAssert) checkOffset(offset, 4, this.length)\n return ieee754.read(this, offset, false, 23, 4)\n}\n\nBuffer.prototype.readDoubleLE = function readDoubleLE (offset, noAssert) {\n if (!noAssert) checkOffset(offset, 8, this.length)\n return ieee754.read(this, offset, true, 52, 8)\n}\n\nBuffer.prototype.readDoubleBE = function readDoubleBE (offset, noAssert) {\n if (!noAssert) checkOffset(offset, 8, this.length)\n return ieee754.read(this, offset, false, 52, 8)\n}\n\nfunction checkInt (buf, value, offset, ext, max, min) {\n if (!Buffer.isBuffer(buf)) throw new TypeError('\"buffer\" argument must be a Buffer instance')\n if (value > max || value < min) throw new RangeError('\"value\" argument is out of bounds')\n if (offset + ext > buf.length) throw new RangeError('Index out of range')\n}\n\nBuffer.prototype.writeUIntLE = function writeUIntLE (value, offset, byteLength, noAssert) {\n value = +value\n offset = offset | 0\n byteLength = byteLength | 0\n if (!noAssert) {\n var maxBytes = Math.pow(2, 8 * byteLength) - 1\n checkInt(this, value, offset, byteLength, maxBytes, 0)\n }\n\n var mul = 1\n var i = 0\n this[offset] = value & 0xFF\n while (++i < byteLength && (mul *= 0x100)) {\n this[offset + i] = (value / mul) & 0xFF\n }\n\n return offset + byteLength\n}\n\nBuffer.prototype.writeUIntBE = function writeUIntBE (value, offset, byteLength, noAssert) {\n value = +value\n offset = offset | 0\n byteLength = byteLength | 0\n if (!noAssert) {\n var maxBytes = Math.pow(2, 8 * byteLength) - 1\n checkInt(this, value, offset, byteLength, maxBytes, 0)\n }\n\n var i = byteLength - 1\n var mul = 1\n this[offset + i] = value & 0xFF\n while (--i >= 0 && (mul *= 0x100)) {\n this[offset + i] = (value / mul) & 0xFF\n }\n\n return offset + byteLength\n}\n\nBuffer.prototype.writeUInt8 = function writeUInt8 (value, offset, noAssert) {\n value = +value\n offset = offset | 0\n if (!noAssert) checkInt(this, value, offset, 1, 0xff, 0)\n if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value)\n this[offset] = (value & 0xff)\n return offset + 1\n}\n\nfunction objectWriteUInt16 (buf, value, offset, littleEndian) {\n if (value < 0) value = 0xffff + value + 1\n for (var i = 0, j = Math.min(buf.length - offset, 2); i < j; ++i) {\n buf[offset + i] = (value & (0xff << (8 * (littleEndian ? i : 1 - i)))) >>>\n (littleEndian ? i : 1 - i) * 8\n }\n}\n\nBuffer.prototype.writeUInt16LE = function writeUInt16LE (value, offset, noAssert) {\n value = +value\n offset = offset | 0\n if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)\n if (Buffer.TYPED_ARRAY_SUPPORT) {\n this[offset] = (value & 0xff)\n this[offset + 1] = (value >>> 8)\n } else {\n objectWriteUInt16(this, value, offset, true)\n }\n return offset + 2\n}\n\nBuffer.prototype.writeUInt16BE = function writeUInt16BE (value, offset, noAssert) {\n value = +value\n offset = offset | 0\n if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)\n if (Buffer.TYPED_ARRAY_SUPPORT) {\n this[offset] = (value >>> 8)\n this[offset + 1] = (value & 0xff)\n } else {\n objectWriteUInt16(this, value, offset, false)\n }\n return offset + 2\n}\n\nfunction objectWriteUInt32 (buf, value, offset, littleEndian) {\n if (value < 0) value = 0xffffffff + value + 1\n for (var i = 0, j = Math.min(buf.length - offset, 4); i < j; ++i) {\n buf[offset + i] = (value >>> (littleEndian ? i : 3 - i) * 8) & 0xff\n }\n}\n\nBuffer.prototype.writeUInt32LE = function writeUInt32LE (value, offset, noAssert) {\n value = +value\n offset = offset | 0\n if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)\n if (Buffer.TYPED_ARRAY_SUPPORT) {\n this[offset + 3] = (value >>> 24)\n this[offset + 2] = (value >>> 16)\n this[offset + 1] = (value >>> 8)\n this[offset] = (value & 0xff)\n } else {\n objectWriteUInt32(this, value, offset, true)\n }\n return offset + 4\n}\n\nBuffer.prototype.writeUInt32BE = function writeUInt32BE (value, offset, noAssert) {\n value = +value\n offset = offset | 0\n if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)\n if (Buffer.TYPED_ARRAY_SUPPORT) {\n this[offset] = (value >>> 24)\n this[offset + 1] = (value >>> 16)\n this[offset + 2] = (value >>> 8)\n this[offset + 3] = (value & 0xff)\n } else {\n objectWriteUInt32(this, value, offset, false)\n }\n return offset + 4\n}\n\nBuffer.prototype.writeIntLE = function writeIntLE (value, offset, byteLength, noAssert) {\n value = +value\n offset = offset | 0\n if (!noAssert) {\n var limit = Math.pow(2, 8 * byteLength - 1)\n\n checkInt(this, value, offset, byteLength, limit - 1, -limit)\n }\n\n var i = 0\n var mul = 1\n var sub = 0\n this[offset] = value & 0xFF\n while (++i < byteLength && (mul *= 0x100)) {\n if (value < 0 && sub === 0 && this[offset + i - 1] !== 0) {\n sub = 1\n }\n this[offset + i] = ((value / mul) >> 0) - sub & 0xFF\n }\n\n return offset + byteLength\n}\n\nBuffer.prototype.writeIntBE = function writeIntBE (value, offset, byteLength, noAssert) {\n value = +value\n offset = offset | 0\n if (!noAssert) {\n var limit = Math.pow(2, 8 * byteLength - 1)\n\n checkInt(this, value, offset, byteLength, limit - 1, -limit)\n }\n\n var i = byteLength - 1\n var mul = 1\n var sub = 0\n this[offset + i] = value & 0xFF\n while (--i >= 0 && (mul *= 0x100)) {\n if (value < 0 && sub === 0 && this[offset + i + 1] !== 0) {\n sub = 1\n }\n this[offset + i] = ((value / mul) >> 0) - sub & 0xFF\n }\n\n return offset + byteLength\n}\n\nBuffer.prototype.writeInt8 = function writeInt8 (value, offset, noAssert) {\n value = +value\n offset = offset | 0\n if (!noAssert) checkInt(this, value, offset, 1, 0x7f, -0x80)\n if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value)\n if (value < 0) value = 0xff + value + 1\n this[offset] = (value & 0xff)\n return offset + 1\n}\n\nBuffer.prototype.writeInt16LE = function writeInt16LE (value, offset, noAssert) {\n value = +value\n offset = offset | 0\n if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000)\n if (Buffer.TYPED_ARRAY_SUPPORT) {\n this[offset] = (value & 0xff)\n this[offset + 1] = (value >>> 8)\n } else {\n objectWriteUInt16(this, value, offset, true)\n }\n return offset + 2\n}\n\nBuffer.prototype.writeInt16BE = function writeInt16BE (value, offset, noAssert) {\n value = +value\n offset = offset | 0\n if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000)\n if (Buffer.TYPED_ARRAY_SUPPORT) {\n this[offset] = (value >>> 8)\n this[offset + 1] = (value & 0xff)\n } else {\n objectWriteUInt16(this, value, offset, false)\n }\n return offset + 2\n}\n\nBuffer.prototype.writeInt32LE = function writeInt32LE (value, offset, noAssert) {\n value = +value\n offset = offset | 0\n if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)\n if (Buffer.TYPED_ARRAY_SUPPORT) {\n this[offset] = (value & 0xff)\n this[offset + 1] = (value >>> 8)\n this[offset + 2] = (value >>> 16)\n this[offset + 3] = (value >>> 24)\n } else {\n objectWriteUInt32(this, value, offset, true)\n }\n return offset + 4\n}\n\nBuffer.prototype.writeInt32BE = function writeInt32BE (value, offset, noAssert) {\n value = +value\n offset = offset | 0\n if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)\n if (value < 0) value = 0xffffffff + value + 1\n if (Buffer.TYPED_ARRAY_SUPPORT) {\n this[offset] = (value >>> 24)\n this[offset + 1] = (value >>> 16)\n this[offset + 2] = (value >>> 8)\n this[offset + 3] = (value & 0xff)\n } else {\n objectWriteUInt32(this, value, offset, false)\n }\n return offset + 4\n}\n\nfunction checkIEEE754 (buf, value, offset, ext, max, min) {\n if (offset + ext > buf.length) throw new RangeError('Index out of range')\n if (offset < 0) throw new RangeError('Index out of range')\n}\n\nfunction writeFloat (buf, value, offset, littleEndian, noAssert) {\n if (!noAssert) {\n checkIEEE754(buf, value, offset, 4, 3.4028234663852886e+38, -3.4028234663852886e+38)\n }\n ieee754.write(buf, value, offset, littleEndian, 23, 4)\n return offset + 4\n}\n\nBuffer.prototype.writeFloatLE = function writeFloatLE (value, offset, noAssert) {\n return writeFloat(this, value, offset, true, noAssert)\n}\n\nBuffer.prototype.writeFloatBE = function writeFloatBE (value, offset, noAssert) {\n return writeFloat(this, value, offset, false, noAssert)\n}\n\nfunction writeDouble (buf, value, offset, littleEndian, noAssert) {\n if (!noAssert) {\n checkIEEE754(buf, value, offset, 8, 1.7976931348623157E+308, -1.7976931348623157E+308)\n }\n ieee754.write(buf, value, offset, littleEndian, 52, 8)\n return offset + 8\n}\n\nBuffer.prototype.writeDoubleLE = function writeDoubleLE (value, offset, noAssert) {\n return writeDouble(this, value, offset, true, noAssert)\n}\n\nBuffer.prototype.writeDoubleBE = function writeDoubleBE (value, offset, noAssert) {\n return writeDouble(this, value, offset, false, noAssert)\n}\n\n// copy(targetBuffer, targetStart=0, sourceStart=0, sourceEnd=buffer.length)\nBuffer.prototype.copy = function copy (target, targetStart, start, end) {\n if (!start) start = 0\n if (!end && end !== 0) end = this.length\n if (targetStart >= target.length) targetStart = target.length\n if (!targetStart) targetStart = 0\n if (end > 0 && end < start) end = start\n\n // Copy 0 bytes; we're done\n if (end === start) return 0\n if (target.length === 0 || this.length === 0) return 0\n\n // Fatal error conditions\n if (targetStart < 0) {\n throw new RangeError('targetStart out of bounds')\n }\n if (start < 0 || start >= this.length) throw new RangeError('sourceStart out of bounds')\n if (end < 0) throw new RangeError('sourceEnd out of bounds')\n\n // Are we oob?\n if (end > this.length) end = this.length\n if (target.length - targetStart < end - start) {\n end = target.length - targetStart + start\n }\n\n var len = end - start\n var i\n\n if (this === target && start < targetStart && targetStart < end) {\n // descending copy from end\n for (i = len - 1; i >= 0; --i) {\n target[i + targetStart] = this[i + start]\n }\n } else if (len < 1000 || !Buffer.TYPED_ARRAY_SUPPORT) {\n // ascending copy from start\n for (i = 0; i < len; ++i) {\n target[i + targetStart] = this[i + start]\n }\n } else {\n Uint8Array.prototype.set.call(\n target,\n this.subarray(start, start + len),\n targetStart\n )\n }\n\n return len\n}\n\n// Usage:\n// buffer.fill(number[, offset[, end]])\n// buffer.fill(buffer[, offset[, end]])\n// buffer.fill(string[, offset[, end]][, encoding])\nBuffer.prototype.fill = function fill (val, start, end, encoding) {\n // Handle string cases:\n if (typeof val === 'string') {\n if (typeof start === 'string') {\n encoding = start\n start = 0\n end = this.length\n } else if (typeof end === 'string') {\n encoding = end\n end = this.length\n }\n if (val.length === 1) {\n var code = val.charCodeAt(0)\n if (code < 256) {\n val = code\n }\n }\n if (encoding !== undefined && typeof encoding !== 'string') {\n throw new TypeError('encoding must be a string')\n }\n if (typeof encoding === 'string' && !Buffer.isEncoding(encoding)) {\n throw new TypeError('Unknown encoding: ' + encoding)\n }\n } else if (typeof val === 'number') {\n val = val & 255\n }\n\n // Invalid ranges are not set to a default, so can range check early.\n if (start < 0 || this.length < start || this.length < end) {\n throw new RangeError('Out of range index')\n }\n\n if (end <= start) {\n return this\n }\n\n start = start >>> 0\n end = end === undefined ? this.length : end >>> 0\n\n if (!val) val = 0\n\n var i\n if (typeof val === 'number') {\n for (i = start; i < end; ++i) {\n this[i] = val\n }\n } else {\n var bytes = Buffer.isBuffer(val)\n ? val\n : utf8ToBytes(new Buffer(val, encoding).toString())\n var len = bytes.length\n for (i = 0; i < end - start; ++i) {\n this[i + start] = bytes[i % len]\n }\n }\n\n return this\n}\n\n// HELPER FUNCTIONS\n// ================\n\nvar INVALID_BASE64_RE = /[^+\\/0-9A-Za-z-_]/g\n\nfunction base64clean (str) {\n // Node strips out invalid characters like \\n and \\t from the string, base64-js does not\n str = stringtrim(str).replace(INVALID_BASE64_RE, '')\n // Node converts strings with length < 2 to ''\n if (str.length < 2) return ''\n // Node allows for non-padded base64 strings (missing trailing ===), base64-js does not\n while (str.length % 4 !== 0) {\n str = str + '='\n }\n return str\n}\n\nfunction stringtrim (str) {\n if (str.trim) return str.trim()\n return str.replace(/^\\s+|\\s+$/g, '')\n}\n\nfunction toHex (n) {\n if (n < 16) return '0' + n.toString(16)\n return n.toString(16)\n}\n\nfunction utf8ToBytes (string, units) {\n units = units || Infinity\n var codePoint\n var length = string.length\n var leadSurrogate = null\n var bytes = []\n\n for (var i = 0; i < length; ++i) {\n codePoint = string.charCodeAt(i)\n\n // is surrogate component\n if (codePoint > 0xD7FF && codePoint < 0xE000) {\n // last char was a lead\n if (!leadSurrogate) {\n // no lead yet\n if (codePoint > 0xDBFF) {\n // unexpected trail\n if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n continue\n } else if (i + 1 === length) {\n // unpaired lead\n if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n continue\n }\n\n // valid lead\n leadSurrogate = codePoint\n\n continue\n }\n\n // 2 leads in a row\n if (codePoint < 0xDC00) {\n if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n leadSurrogate = codePoint\n continue\n }\n\n // valid surrogate pair\n codePoint = (leadSurrogate - 0xD800 << 10 | codePoint - 0xDC00) + 0x10000\n } else if (leadSurrogate) {\n // valid bmp char, but last char was a lead\n if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n }\n\n leadSurrogate = null\n\n // encode utf8\n if (codePoint < 0x80) {\n if ((units -= 1) < 0) break\n bytes.push(codePoint)\n } else if (codePoint < 0x800) {\n if ((units -= 2) < 0) break\n bytes.push(\n codePoint >> 0x6 | 0xC0,\n codePoint & 0x3F | 0x80\n )\n } else if (codePoint < 0x10000) {\n if ((units -= 3) < 0) break\n bytes.push(\n codePoint >> 0xC | 0xE0,\n codePoint >> 0x6 & 0x3F | 0x80,\n codePoint & 0x3F | 0x80\n )\n } else if (codePoint < 0x110000) {\n if ((units -= 4) < 0) break\n bytes.push(\n codePoint >> 0x12 | 0xF0,\n codePoint >> 0xC & 0x3F | 0x80,\n codePoint >> 0x6 & 0x3F | 0x80,\n codePoint & 0x3F | 0x80\n )\n } else {\n throw new Error('Invalid code point')\n }\n }\n\n return bytes\n}\n\nfunction asciiToBytes (str) {\n var byteArray = []\n for (var i = 0; i < str.length; ++i) {\n // Node's code seems to be doing this and not & 0x7F..\n byteArray.push(str.charCodeAt(i) & 0xFF)\n }\n return byteArray\n}\n\nfunction utf16leToBytes (str, units) {\n var c, hi, lo\n var byteArray = []\n for (var i = 0; i < str.length; ++i) {\n if ((units -= 2) < 0) break\n\n c = str.charCodeAt(i)\n hi = c >> 8\n lo = c % 256\n byteArray.push(lo)\n byteArray.push(hi)\n }\n\n return byteArray\n}\n\nfunction base64ToBytes (str) {\n return base64.toByteArray(base64clean(str))\n}\n\nfunction blitBuffer (src, dst, offset, length) {\n for (var i = 0; i < length; ++i) {\n if ((i + offset >= dst.length) || (i >= src.length)) break\n dst[i + offset] = src[i]\n }\n return i\n}\n\nfunction isnan (val) {\n return val !== val // eslint-disable-line no-self-compare\n}\n","/**\n * This is the web browser implementation of `debug()`.\n *\n * Expose `debug()` as the module.\n */\n\nexports = module.exports = require('./debug');\nexports.log = log;\nexports.formatArgs = formatArgs;\nexports.save = save;\nexports.load = load;\nexports.useColors = useColors;\nexports.storage = 'undefined' != typeof chrome\n && 'undefined' != typeof chrome.storage\n ? chrome.storage.local\n : localstorage();\n\n/**\n * Colors.\n */\n\nexports.colors = [\n 'lightseagreen',\n 'forestgreen',\n 'goldenrod',\n 'dodgerblue',\n 'darkorchid',\n 'crimson'\n];\n\n/**\n * Currently only WebKit-based Web Inspectors, Firefox >= v31,\n * and the Firebug extension (any Firefox version) are known\n * to support \"%c\" CSS customizations.\n *\n * TODO: add a `localStorage` variable to explicitly enable/disable colors\n */\n\nfunction useColors() {\n // NB: In an Electron preload script, document will be defined but not fully\n // initialized. Since we know we're in Chrome, we'll just detect this case\n // explicitly\n if (typeof window !== 'undefined' && window && typeof window.process !== 'undefined' && window.process.type === 'renderer') {\n return true;\n }\n\n // is webkit? http://stackoverflow.com/a/16459606/376773\n // document is undefined in react-native: https://github.com/facebook/react-native/pull/1632\n return (typeof document !== 'undefined' && document && 'WebkitAppearance' in document.documentElement.style) ||\n // is firebug? http://stackoverflow.com/a/398120/376773\n (typeof window !== 'undefined' && window && window.console && (console.firebug || (console.exception && console.table))) ||\n // is firefox >= v31?\n // https://developer.mozilla.org/en-US/docs/Tools/Web_Console#Styling_messages\n (typeof navigator !== 'undefined' && navigator && navigator.userAgent && navigator.userAgent.toLowerCase().match(/firefox\\/(\\d+)/) && parseInt(RegExp.$1, 10) >= 31) ||\n // double check webkit in userAgent just in case we are in a worker\n (typeof navigator !== 'undefined' && navigator && navigator.userAgent && navigator.userAgent.toLowerCase().match(/applewebkit\\/(\\d+)/));\n}\n\n/**\n * Map %j to `JSON.stringify()`, since no Web Inspectors do that by default.\n */\n\nexports.formatters.j = function(v) {\n try {\n return JSON.stringify(v);\n } catch (err) {\n return '[UnexpectedJSONParseError]: ' + err.message;\n }\n};\n\n\n/**\n * Colorize log arguments if enabled.\n *\n * @api public\n */\n\nfunction formatArgs(args) {\n var useColors = this.useColors;\n\n args[0] = (useColors ? '%c' : '')\n + this.namespace\n + (useColors ? ' %c' : ' ')\n + args[0]\n + (useColors ? '%c ' : ' ')\n + '+' + exports.humanize(this.diff);\n\n if (!useColors) return;\n\n var c = 'color: ' + this.color;\n args.splice(1, 0, c, 'color: inherit')\n\n // the final \"%c\" is somewhat tricky, because there could be other\n // arguments passed either before or after the %c, so we need to\n // figure out the correct index to insert the CSS into\n var index = 0;\n var lastC = 0;\n args[0].replace(/%[a-zA-Z%]/g, function(match) {\n if ('%%' === match) return;\n index++;\n if ('%c' === match) {\n // we only are interested in the *last* %c\n // (the user may have provided their own)\n lastC = index;\n }\n });\n\n args.splice(lastC, 0, c);\n}\n\n/**\n * Invokes `console.log()` when available.\n * No-op when `console.log` is not a \"function\".\n *\n * @api public\n */\n\nfunction log() {\n // this hackery is required for IE8/9, where\n // the `console.log` function doesn't have 'apply'\n return 'object' === typeof console\n && console.log\n && Function.prototype.apply.call(console.log, console, arguments);\n}\n\n/**\n * Save `namespaces`.\n *\n * @param {String} namespaces\n * @api private\n */\n\nfunction save(namespaces) {\n try {\n if (null == namespaces) {\n exports.storage.removeItem('debug');\n } else {\n exports.storage.debug = namespaces;\n }\n } catch(e) {}\n}\n\n/**\n * Load `namespaces`.\n *\n * @return {String} returns the previously persisted debug modes\n * @api private\n */\n\nfunction load() {\n try {\n return exports.storage.debug;\n } catch(e) {}\n\n // If debug isn't set in LS, and we're in Electron, try to load $DEBUG\n if (typeof process !== 'undefined' && 'env' in process) {\n return process.env.DEBUG;\n }\n}\n\n/**\n * Enable namespaces listed in `localStorage.debug` initially.\n */\n\nexports.enable(load());\n\n/**\n * Localstorage attempts to return the localstorage.\n *\n * This is necessary because safari throws\n * when a user disables cookies/localstorage\n * and you attempt to access it.\n *\n * @return {LocalStorage}\n * @api private\n */\n\nfunction localstorage() {\n try {\n return window.localStorage;\n } catch (e) {}\n}\n","\n/**\n * This is the common logic for both the Node.js and web browser\n * implementations of `debug()`.\n *\n * Expose `debug()` as the module.\n */\n\nexports = module.exports = createDebug.debug = createDebug.default = createDebug;\nexports.coerce = coerce;\nexports.disable = disable;\nexports.enable = enable;\nexports.enabled = enabled;\nexports.humanize = require('ms');\n\n/**\n * The currently active debug mode names, and names to skip.\n */\n\nexports.names = [];\nexports.skips = [];\n\n/**\n * Map of special \"%n\" handling functions, for the debug \"format\" argument.\n *\n * Valid key names are a single, lower or upper-case letter, i.e. \"n\" and \"N\".\n */\n\nexports.formatters = {};\n\n/**\n * Previous log timestamp.\n */\n\nvar prevTime;\n\n/**\n * Select a color.\n * @param {String} namespace\n * @return {Number}\n * @api private\n */\n\nfunction selectColor(namespace) {\n var hash = 0, i;\n\n for (i in namespace) {\n hash = ((hash << 5) - hash) + namespace.charCodeAt(i);\n hash |= 0; // Convert to 32bit integer\n }\n\n return exports.colors[Math.abs(hash) % exports.colors.length];\n}\n\n/**\n * Create a debugger with the given `namespace`.\n *\n * @param {String} namespace\n * @return {Function}\n * @api public\n */\n\nfunction createDebug(namespace) {\n\n function debug() {\n // disabled?\n if (!debug.enabled) return;\n\n var self = debug;\n\n // set `diff` timestamp\n var curr = +new Date();\n var ms = curr - (prevTime || curr);\n self.diff = ms;\n self.prev = prevTime;\n self.curr = curr;\n prevTime = curr;\n\n // turn the `arguments` into a proper Array\n var args = new Array(arguments.length);\n for (var i = 0; i < args.length; i++) {\n args[i] = arguments[i];\n }\n\n args[0] = exports.coerce(args[0]);\n\n if ('string' !== typeof args[0]) {\n // anything else let's inspect with %O\n args.unshift('%O');\n }\n\n // apply any `formatters` transformations\n var index = 0;\n args[0] = args[0].replace(/%([a-zA-Z%])/g, function(match, format) {\n // if we encounter an escaped % then don't increase the array index\n if (match === '%%') return match;\n index++;\n var formatter = exports.formatters[format];\n if ('function' === typeof formatter) {\n var val = args[index];\n match = formatter.call(self, val);\n\n // now we need to remove `args[index]` since it's inlined in the `format`\n args.splice(index, 1);\n index--;\n }\n return match;\n });\n\n // apply env-specific formatting (colors, etc.)\n exports.formatArgs.call(self, args);\n\n var logFn = debug.log || exports.log || console.log.bind(console);\n logFn.apply(self, args);\n }\n\n debug.namespace = namespace;\n debug.enabled = exports.enabled(namespace);\n debug.useColors = exports.useColors();\n debug.color = selectColor(namespace);\n\n // env-specific initialization logic for debug instances\n if ('function' === typeof exports.init) {\n exports.init(debug);\n }\n\n return debug;\n}\n\n/**\n * Enables a debug mode by namespaces. This can include modes\n * separated by a colon and wildcards.\n *\n * @param {String} namespaces\n * @api public\n */\n\nfunction enable(namespaces) {\n exports.save(namespaces);\n\n var split = (namespaces || '').split(/[\\s,]+/);\n var len = split.length;\n\n for (var i = 0; i < len; i++) {\n if (!split[i]) continue; // ignore empty strings\n namespaces = split[i].replace(/\\*/g, '.*?');\n if (namespaces[0] === '-') {\n exports.skips.push(new RegExp('^' + namespaces.substr(1) + '$'));\n } else {\n exports.names.push(new RegExp('^' + namespaces + '$'));\n }\n }\n}\n\n/**\n * Disable debug output.\n *\n * @api public\n */\n\nfunction disable() {\n exports.enable('');\n}\n\n/**\n * Returns true if the given mode name is enabled, false otherwise.\n *\n * @param {String} name\n * @return {Boolean}\n * @api public\n */\n\nfunction enabled(name) {\n var i, len;\n for (i = 0, len = exports.skips.length; i < len; i++) {\n if (exports.skips[i].test(name)) {\n return false;\n }\n }\n for (i = 0, len = exports.names.length; i < len; i++) {\n if (exports.names[i].test(name)) {\n return true;\n }\n }\n return false;\n}\n\n/**\n * Coerce `val`.\n *\n * @param {Mixed} val\n * @return {Mixed}\n * @api private\n */\n\nfunction coerce(val) {\n if (val instanceof Error) return val.stack || val.message;\n return val;\n}\n","exports.read = function (buffer, offset, isLE, mLen, nBytes) {\n var e, m\n var eLen = nBytes * 8 - mLen - 1\n var eMax = (1 << eLen) - 1\n var eBias = eMax >> 1\n var nBits = -7\n var i = isLE ? (nBytes - 1) : 0\n var d = isLE ? -1 : 1\n var s = buffer[offset + i]\n\n i += d\n\n e = s & ((1 << (-nBits)) - 1)\n s >>= (-nBits)\n nBits += eLen\n for (; nBits > 0; e = e * 256 + buffer[offset + i], i += d, nBits -= 8) {}\n\n m = e & ((1 << (-nBits)) - 1)\n e >>= (-nBits)\n nBits += mLen\n for (; nBits > 0; m = m * 256 + buffer[offset + i], i += d, nBits -= 8) {}\n\n if (e === 0) {\n e = 1 - eBias\n } else if (e === eMax) {\n return m ? NaN : ((s ? -1 : 1) * Infinity)\n } else {\n m = m + Math.pow(2, mLen)\n e = e - eBias\n }\n return (s ? -1 : 1) * m * Math.pow(2, e - mLen)\n}\n\nexports.write = function (buffer, value, offset, isLE, mLen, nBytes) {\n var e, m, c\n var eLen = nBytes * 8 - mLen - 1\n var eMax = (1 << eLen) - 1\n var eBias = eMax >> 1\n var rt = (mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0)\n var i = isLE ? 0 : (nBytes - 1)\n var d = isLE ? 1 : -1\n var s = value < 0 || (value === 0 && 1 / value < 0) ? 1 : 0\n\n value = Math.abs(value)\n\n if (isNaN(value) || value === Infinity) {\n m = isNaN(value) ? 1 : 0\n e = eMax\n } else {\n e = Math.floor(Math.log(value) / Math.LN2)\n if (value * (c = Math.pow(2, -e)) < 1) {\n e--\n c *= 2\n }\n if (e + eBias >= 1) {\n value += rt / c\n } else {\n value += rt * Math.pow(2, 1 - eBias)\n }\n if (value * c >= 2) {\n e++\n c /= 2\n }\n\n if (e + eBias >= eMax) {\n m = 0\n e = eMax\n } else if (e + eBias >= 1) {\n m = (value * c - 1) * Math.pow(2, mLen)\n e = e + eBias\n } else {\n m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen)\n e = 0\n }\n }\n\n for (; mLen >= 8; buffer[offset + i] = m & 0xff, i += d, m /= 256, mLen -= 8) {}\n\n e = (e << mLen) | m\n eLen += mLen\n for (; eLen > 0; buffer[offset + i] = e & 0xff, i += d, e /= 256, eLen -= 8) {}\n\n buffer[offset + i - d] |= s * 128\n}\n","var toString = {}.toString;\n\nmodule.exports = Array.isArray || function (arr) {\n return toString.call(arr) == '[object Array]';\n};\n","/*\n * $Id: base64.js,v 2.15 2014/04/05 12:58:57 dankogai Exp dankogai $\n *\n * Licensed under the MIT license.\n * http://opensource.org/licenses/mit-license\n *\n * References:\n * http://en.wikipedia.org/wiki/Base64\n */\n\n(function(global) {\n 'use strict';\n // existing version for noConflict()\n var _Base64 = global.Base64;\n var version = \"2.1.9\";\n // if node.js, we use Buffer\n var buffer;\n if (typeof module !== 'undefined' && module.exports) {\n try {\n buffer = require('buffer').Buffer;\n } catch (err) {}\n }\n // constants\n var b64chars\n = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';\n var b64tab = function(bin) {\n var t = {};\n for (var i = 0, l = bin.length; i < l; i++) t[bin.charAt(i)] = i;\n return t;\n }(b64chars);\n var fromCharCode = String.fromCharCode;\n // encoder stuff\n var cb_utob = function(c) {\n if (c.length < 2) {\n var cc = c.charCodeAt(0);\n return cc < 0x80 ? c\n : cc < 0x800 ? (fromCharCode(0xc0 | (cc >>> 6))\n + fromCharCode(0x80 | (cc & 0x3f)))\n : (fromCharCode(0xe0 | ((cc >>> 12) & 0x0f))\n + fromCharCode(0x80 | ((cc >>> 6) & 0x3f))\n + fromCharCode(0x80 | ( cc & 0x3f)));\n } else {\n var cc = 0x10000\n + (c.charCodeAt(0) - 0xD800) * 0x400\n + (c.charCodeAt(1) - 0xDC00);\n return (fromCharCode(0xf0 | ((cc >>> 18) & 0x07))\n + fromCharCode(0x80 | ((cc >>> 12) & 0x3f))\n + fromCharCode(0x80 | ((cc >>> 6) & 0x3f))\n + fromCharCode(0x80 | ( cc & 0x3f)));\n }\n };\n var re_utob = /[\\uD800-\\uDBFF][\\uDC00-\\uDFFFF]|[^\\x00-\\x7F]/g;\n var utob = function(u) {\n return u.replace(re_utob, cb_utob);\n };\n var cb_encode = function(ccc) {\n var padlen = [0, 2, 1][ccc.length % 3],\n ord = ccc.charCodeAt(0) << 16\n | ((ccc.length > 1 ? ccc.charCodeAt(1) : 0) << 8)\n | ((ccc.length > 2 ? ccc.charCodeAt(2) : 0)),\n chars = [\n b64chars.charAt( ord >>> 18),\n b64chars.charAt((ord >>> 12) & 63),\n padlen >= 2 ? '=' : b64chars.charAt((ord >>> 6) & 63),\n padlen >= 1 ? '=' : b64chars.charAt(ord & 63)\n ];\n return chars.join('');\n };\n var btoa = global.btoa ? function(b) {\n return global.btoa(b);\n } : function(b) {\n return b.replace(/[\\s\\S]{1,3}/g, cb_encode);\n };\n var _encode = buffer ? function (u) {\n return (u.constructor === buffer.constructor ? u : new buffer(u))\n .toString('base64')\n }\n : function (u) { return btoa(utob(u)) }\n ;\n var encode = function(u, urisafe) {\n return !urisafe\n ? _encode(String(u))\n : _encode(String(u)).replace(/[+\\/]/g, function(m0) {\n return m0 == '+' ? '-' : '_';\n }).replace(/=/g, '');\n };\n var encodeURI = function(u) { return encode(u, true) };\n // decoder stuff\n var re_btou = new RegExp([\n '[\\xC0-\\xDF][\\x80-\\xBF]',\n '[\\xE0-\\xEF][\\x80-\\xBF]{2}',\n '[\\xF0-\\xF7][\\x80-\\xBF]{3}'\n ].join('|'), 'g');\n var cb_btou = function(cccc) {\n switch(cccc.length) {\n case 4:\n var cp = ((0x07 & cccc.charCodeAt(0)) << 18)\n | ((0x3f & cccc.charCodeAt(1)) << 12)\n | ((0x3f & cccc.charCodeAt(2)) << 6)\n | (0x3f & cccc.charCodeAt(3)),\n offset = cp - 0x10000;\n return (fromCharCode((offset >>> 10) + 0xD800)\n + fromCharCode((offset & 0x3FF) + 0xDC00));\n case 3:\n return fromCharCode(\n ((0x0f & cccc.charCodeAt(0)) << 12)\n | ((0x3f & cccc.charCodeAt(1)) << 6)\n | (0x3f & cccc.charCodeAt(2))\n );\n default:\n return fromCharCode(\n ((0x1f & cccc.charCodeAt(0)) << 6)\n | (0x3f & cccc.charCodeAt(1))\n );\n }\n };\n var btou = function(b) {\n return b.replace(re_btou, cb_btou);\n };\n var cb_decode = function(cccc) {\n var len = cccc.length,\n padlen = len % 4,\n n = (len > 0 ? b64tab[cccc.charAt(0)] << 18 : 0)\n | (len > 1 ? b64tab[cccc.charAt(1)] << 12 : 0)\n | (len > 2 ? b64tab[cccc.charAt(2)] << 6 : 0)\n | (len > 3 ? b64tab[cccc.charAt(3)] : 0),\n chars = [\n fromCharCode( n >>> 16),\n fromCharCode((n >>> 8) & 0xff),\n fromCharCode( n & 0xff)\n ];\n chars.length -= [0, 0, 2, 1][padlen];\n return chars.join('');\n };\n var atob = global.atob ? function(a) {\n return global.atob(a);\n } : function(a){\n return a.replace(/[\\s\\S]{1,4}/g, cb_decode);\n };\n var _decode = buffer ? function(a) {\n return (a.constructor === buffer.constructor\n ? a : new buffer(a, 'base64')).toString();\n }\n : function(a) { return btou(atob(a)) };\n var decode = function(a){\n return _decode(\n String(a).replace(/[-_]/g, function(m0) { return m0 == '-' ? '+' : '/' })\n .replace(/[^A-Za-z0-9\\+\\/]/g, '')\n );\n };\n var noConflict = function() {\n var Base64 = global.Base64;\n global.Base64 = _Base64;\n return Base64;\n };\n // export Base64\n global.Base64 = {\n VERSION: version,\n atob: atob,\n btoa: btoa,\n fromBase64: decode,\n toBase64: encode,\n utob: utob,\n encode: encode,\n encodeURI: encodeURI,\n btou: btou,\n decode: decode,\n noConflict: noConflict\n };\n // if ES5 is available, make Base64.extendString() available\n if (typeof Object.defineProperty === 'function') {\n var noEnum = function(v){\n return {value:v,enumerable:false,writable:true,configurable:true};\n };\n global.Base64.extendString = function () {\n Object.defineProperty(\n String.prototype, 'fromBase64', noEnum(function () {\n return decode(this)\n }));\n Object.defineProperty(\n String.prototype, 'toBase64', noEnum(function (urisafe) {\n return encode(this, urisafe)\n }));\n Object.defineProperty(\n String.prototype, 'toBase64URI', noEnum(function () {\n return encode(this, true)\n }));\n };\n }\n // that's it!\n if (global['Meteor']) {\n Base64 = global.Base64; // for normal export in Meteor.js\n }\n})(this);\n","/**\n * Helpers.\n */\n\nvar s = 1000\nvar m = s * 60\nvar h = m * 60\nvar d = h * 24\nvar y = d * 365.25\n\n/**\n * Parse or format the given `val`.\n *\n * Options:\n *\n * - `long` verbose formatting [false]\n *\n * @param {String|Number} val\n * @param {Object} options\n * @throws {Error} throw an error if val is not a non-empty string or a number\n * @return {String|Number}\n * @api public\n */\n\nmodule.exports = function (val, options) {\n options = options || {}\n var type = typeof val\n if (type === 'string' && val.length > 0) {\n return parse(val)\n } else if (type === 'number' && isNaN(val) === false) {\n return options.long ?\n\t\t\tfmtLong(val) :\n\t\t\tfmtShort(val)\n }\n throw new Error('val is not a non-empty string or a valid number. val=' + JSON.stringify(val))\n}\n\n/**\n * Parse the given `str` and return milliseconds.\n *\n * @param {String} str\n * @return {Number}\n * @api private\n */\n\nfunction parse(str) {\n str = String(str)\n if (str.length > 10000) {\n return\n }\n var match = /^((?:\\d+)?\\.?\\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|years?|yrs?|y)?$/i.exec(str)\n if (!match) {\n return\n }\n var n = parseFloat(match[1])\n var type = (match[2] || 'ms').toLowerCase()\n switch (type) {\n case 'years':\n case 'year':\n case 'yrs':\n case 'yr':\n case 'y':\n return n * y\n case 'days':\n case 'day':\n case 'd':\n return n * d\n case 'hours':\n case 'hour':\n case 'hrs':\n case 'hr':\n case 'h':\n return n * h\n case 'minutes':\n case 'minute':\n case 'mins':\n case 'min':\n case 'm':\n return n * m\n case 'seconds':\n case 'second':\n case 'secs':\n case 'sec':\n case 's':\n return n * s\n case 'milliseconds':\n case 'millisecond':\n case 'msecs':\n case 'msec':\n case 'ms':\n return n\n default:\n return undefined\n }\n}\n\n/**\n * Short format for `ms`.\n *\n * @param {Number} ms\n * @return {String}\n * @api private\n */\n\nfunction fmtShort(ms) {\n if (ms >= d) {\n return Math.round(ms / d) + 'd'\n }\n if (ms >= h) {\n return Math.round(ms / h) + 'h'\n }\n if (ms >= m) {\n return Math.round(ms / m) + 'm'\n }\n if (ms >= s) {\n return Math.round(ms / s) + 's'\n }\n return ms + 'ms'\n}\n\n/**\n * Long format for `ms`.\n *\n * @param {Number} ms\n * @return {String}\n * @api private\n */\n\nfunction fmtLong(ms) {\n return plural(ms, d, 'day') ||\n plural(ms, h, 'hour') ||\n plural(ms, m, 'minute') ||\n plural(ms, s, 'second') ||\n ms + ' ms'\n}\n\n/**\n * Pluralization helper.\n */\n\nfunction plural(ms, n, name) {\n if (ms < n) {\n return\n }\n if (ms < n * 1.5) {\n return Math.floor(ms / n) + ' ' + name\n }\n return Math.ceil(ms / n) + ' ' + name + 's'\n}\n","// shim for using process in browser\nvar process = module.exports = {};\n\n// cached from whatever global is present so that test runners that stub it\n// don't break things. But we need to wrap it in a try catch in case it is\n// wrapped in strict mode code which doesn't define any globals. It's inside a\n// function because try/catches deoptimize in certain engines.\n\nvar cachedSetTimeout;\nvar cachedClearTimeout;\n\nfunction defaultSetTimout() {\n throw new Error('setTimeout has not been defined');\n}\nfunction defaultClearTimeout () {\n throw new Error('clearTimeout has not been defined');\n}\n(function () {\n try {\n if (typeof setTimeout === 'function') {\n cachedSetTimeout = setTimeout;\n } else {\n cachedSetTimeout = defaultSetTimout;\n }\n } catch (e) {\n cachedSetTimeout = defaultSetTimout;\n }\n try {\n if (typeof clearTimeout === 'function') {\n cachedClearTimeout = clearTimeout;\n } else {\n cachedClearTimeout = defaultClearTimeout;\n }\n } catch (e) {\n cachedClearTimeout = defaultClearTimeout;\n }\n} ())\nfunction runTimeout(fun) {\n if (cachedSetTimeout === setTimeout) {\n //normal enviroments in sane situations\n return setTimeout(fun, 0);\n }\n // if setTimeout wasn't available but was latter defined\n if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {\n cachedSetTimeout = setTimeout;\n return setTimeout(fun, 0);\n }\n try {\n // when when somebody has screwed with setTimeout but no I.E. maddness\n return cachedSetTimeout(fun, 0);\n } catch(e){\n try {\n // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally\n return cachedSetTimeout.call(null, fun, 0);\n } catch(e){\n // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error\n return cachedSetTimeout.call(this, fun, 0);\n }\n }\n\n\n}\nfunction runClearTimeout(marker) {\n if (cachedClearTimeout === clearTimeout) {\n //normal enviroments in sane situations\n return clearTimeout(marker);\n }\n // if clearTimeout wasn't available but was latter defined\n if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {\n cachedClearTimeout = clearTimeout;\n return clearTimeout(marker);\n }\n try {\n // when when somebody has screwed with setTimeout but no I.E. maddness\n return cachedClearTimeout(marker);\n } catch (e){\n try {\n // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally\n return cachedClearTimeout.call(null, marker);\n } catch (e){\n // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error.\n // Some versions of I.E. have different rules for clearTimeout vs setTimeout\n return cachedClearTimeout.call(this, marker);\n }\n }\n\n\n\n}\nvar queue = [];\nvar draining = false;\nvar currentQueue;\nvar queueIndex = -1;\n\nfunction cleanUpNextTick() {\n if (!draining || !currentQueue) {\n return;\n }\n draining = false;\n if (currentQueue.length) {\n queue = currentQueue.concat(queue);\n } else {\n queueIndex = -1;\n }\n if (queue.length) {\n drainQueue();\n }\n}\n\nfunction drainQueue() {\n if (draining) {\n return;\n }\n var timeout = runTimeout(cleanUpNextTick);\n draining = true;\n\n var len = queue.length;\n while(len) {\n currentQueue = queue;\n queue = [];\n while (++queueIndex < len) {\n if (currentQueue) {\n currentQueue[queueIndex].run();\n }\n }\n queueIndex = -1;\n len = queue.length;\n }\n currentQueue = null;\n draining = false;\n runClearTimeout(timeout);\n}\n\nprocess.nextTick = function (fun) {\n var args = new Array(arguments.length - 1);\n if (arguments.length > 1) {\n for (var i = 1; i < arguments.length; i++) {\n args[i - 1] = arguments[i];\n }\n }\n queue.push(new Item(fun, args));\n if (queue.length === 1 && !draining) {\n runTimeout(drainQueue);\n }\n};\n\n// v8 likes predictible objects\nfunction Item(fun, array) {\n this.fun = fun;\n this.array = array;\n}\nItem.prototype.run = function () {\n this.fun.apply(null, this.array);\n};\nprocess.title = 'browser';\nprocess.browser = true;\nprocess.env = {};\nprocess.argv = [];\nprocess.version = ''; // empty string to avoid regexp issues\nprocess.versions = {};\n\nfunction noop() {}\n\nprocess.on = noop;\nprocess.addListener = noop;\nprocess.once = noop;\nprocess.off = noop;\nprocess.removeListener = noop;\nprocess.removeAllListeners = noop;\nprocess.emit = noop;\n\nprocess.binding = function (name) {\n throw new Error('process.binding is not supported');\n};\n\nprocess.cwd = function () { return '/' };\nprocess.chdir = function (dir) {\n throw new Error('process.chdir is not supported');\n};\nprocess.umask = function() { return 0; };\n","/*! https://mths.be/utf8js v2.1.2 by @mathias */\n;(function(root) {\n\n\t// Detect free variables `exports`\n\tvar freeExports = typeof exports == 'object' && exports;\n\n\t// Detect free variable `module`\n\tvar freeModule = typeof module == 'object' && module &&\n\t\tmodule.exports == freeExports && module;\n\n\t// Detect free variable `global`, from Node.js or Browserified code,\n\t// and use it as `root`\n\tvar freeGlobal = typeof global == 'object' && global;\n\tif (freeGlobal.global === freeGlobal || freeGlobal.window === freeGlobal) {\n\t\troot = freeGlobal;\n\t}\n\n\t/*--------------------------------------------------------------------------*/\n\n\tvar stringFromCharCode = String.fromCharCode;\n\n\t// Taken from https://mths.be/punycode\n\tfunction ucs2decode(string) {\n\t\tvar output = [];\n\t\tvar counter = 0;\n\t\tvar length = string.length;\n\t\tvar value;\n\t\tvar extra;\n\t\twhile (counter < length) {\n\t\t\tvalue = string.charCodeAt(counter++);\n\t\t\tif (value >= 0xD800 && value <= 0xDBFF && counter < length) {\n\t\t\t\t// high surrogate, and there is a next character\n\t\t\t\textra = string.charCodeAt(counter++);\n\t\t\t\tif ((extra & 0xFC00) == 0xDC00) { // low surrogate\n\t\t\t\t\toutput.push(((value & 0x3FF) << 10) + (extra & 0x3FF) + 0x10000);\n\t\t\t\t} else {\n\t\t\t\t\t// unmatched surrogate; only append this code unit, in case the next\n\t\t\t\t\t// code unit is the high surrogate of a surrogate pair\n\t\t\t\t\toutput.push(value);\n\t\t\t\t\tcounter--;\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\toutput.push(value);\n\t\t\t}\n\t\t}\n\t\treturn output;\n\t}\n\n\t// Taken from https://mths.be/punycode\n\tfunction ucs2encode(array) {\n\t\tvar length = array.length;\n\t\tvar index = -1;\n\t\tvar value;\n\t\tvar output = '';\n\t\twhile (++index < length) {\n\t\t\tvalue = array[index];\n\t\t\tif (value > 0xFFFF) {\n\t\t\t\tvalue -= 0x10000;\n\t\t\t\toutput += stringFromCharCode(value >>> 10 & 0x3FF | 0xD800);\n\t\t\t\tvalue = 0xDC00 | value & 0x3FF;\n\t\t\t}\n\t\t\toutput += stringFromCharCode(value);\n\t\t}\n\t\treturn output;\n\t}\n\n\tfunction checkScalarValue(codePoint) {\n\t\tif (codePoint >= 0xD800 && codePoint <= 0xDFFF) {\n\t\t\tthrow Error(\n\t\t\t\t'Lone surrogate U+' + codePoint.toString(16).toUpperCase() +\n\t\t\t\t' is not a scalar value'\n\t\t\t);\n\t\t}\n\t}\n\t/*--------------------------------------------------------------------------*/\n\n\tfunction createByte(codePoint, shift) {\n\t\treturn stringFromCharCode(((codePoint >> shift) & 0x3F) | 0x80);\n\t}\n\n\tfunction encodeCodePoint(codePoint) {\n\t\tif ((codePoint & 0xFFFFFF80) == 0) { // 1-byte sequence\n\t\t\treturn stringFromCharCode(codePoint);\n\t\t}\n\t\tvar symbol = '';\n\t\tif ((codePoint & 0xFFFFF800) == 0) { // 2-byte sequence\n\t\t\tsymbol = stringFromCharCode(((codePoint >> 6) & 0x1F) | 0xC0);\n\t\t}\n\t\telse if ((codePoint & 0xFFFF0000) == 0) { // 3-byte sequence\n\t\t\tcheckScalarValue(codePoint);\n\t\t\tsymbol = stringFromCharCode(((codePoint >> 12) & 0x0F) | 0xE0);\n\t\t\tsymbol += createByte(codePoint, 6);\n\t\t}\n\t\telse if ((codePoint & 0xFFE00000) == 0) { // 4-byte sequence\n\t\t\tsymbol = stringFromCharCode(((codePoint >> 18) & 0x07) | 0xF0);\n\t\t\tsymbol += createByte(codePoint, 12);\n\t\t\tsymbol += createByte(codePoint, 6);\n\t\t}\n\t\tsymbol += stringFromCharCode((codePoint & 0x3F) | 0x80);\n\t\treturn symbol;\n\t}\n\n\tfunction utf8encode(string) {\n\t\tvar codePoints = ucs2decode(string);\n\t\tvar length = codePoints.length;\n\t\tvar index = -1;\n\t\tvar codePoint;\n\t\tvar byteString = '';\n\t\twhile (++index < length) {\n\t\t\tcodePoint = codePoints[index];\n\t\t\tbyteString += encodeCodePoint(codePoint);\n\t\t}\n\t\treturn byteString;\n\t}\n\n\t/*--------------------------------------------------------------------------*/\n\n\tfunction readContinuationByte() {\n\t\tif (byteIndex >= byteCount) {\n\t\t\tthrow Error('Invalid byte index');\n\t\t}\n\n\t\tvar continuationByte = byteArray[byteIndex] & 0xFF;\n\t\tbyteIndex++;\n\n\t\tif ((continuationByte & 0xC0) == 0x80) {\n\t\t\treturn continuationByte & 0x3F;\n\t\t}\n\n\t\t// If we end up here, it’s not a continuation byte\n\t\tthrow Error('Invalid continuation byte');\n\t}\n\n\tfunction decodeSymbol() {\n\t\tvar byte1;\n\t\tvar byte2;\n\t\tvar byte3;\n\t\tvar byte4;\n\t\tvar codePoint;\n\n\t\tif (byteIndex > byteCount) {\n\t\t\tthrow Error('Invalid byte index');\n\t\t}\n\n\t\tif (byteIndex == byteCount) {\n\t\t\treturn false;\n\t\t}\n\n\t\t// Read first byte\n\t\tbyte1 = byteArray[byteIndex] & 0xFF;\n\t\tbyteIndex++;\n\n\t\t// 1-byte sequence (no continuation bytes)\n\t\tif ((byte1 & 0x80) == 0) {\n\t\t\treturn byte1;\n\t\t}\n\n\t\t// 2-byte sequence\n\t\tif ((byte1 & 0xE0) == 0xC0) {\n\t\t\tbyte2 = readContinuationByte();\n\t\t\tcodePoint = ((byte1 & 0x1F) << 6) | byte2;\n\t\t\tif (codePoint >= 0x80) {\n\t\t\t\treturn codePoint;\n\t\t\t} else {\n\t\t\t\tthrow Error('Invalid continuation byte');\n\t\t\t}\n\t\t}\n\n\t\t// 3-byte sequence (may include unpaired surrogates)\n\t\tif ((byte1 & 0xF0) == 0xE0) {\n\t\t\tbyte2 = readContinuationByte();\n\t\t\tbyte3 = readContinuationByte();\n\t\t\tcodePoint = ((byte1 & 0x0F) << 12) | (byte2 << 6) | byte3;\n\t\t\tif (codePoint >= 0x0800) {\n\t\t\t\tcheckScalarValue(codePoint);\n\t\t\t\treturn codePoint;\n\t\t\t} else {\n\t\t\t\tthrow Error('Invalid continuation byte');\n\t\t\t}\n\t\t}\n\n\t\t// 4-byte sequence\n\t\tif ((byte1 & 0xF8) == 0xF0) {\n\t\t\tbyte2 = readContinuationByte();\n\t\t\tbyte3 = readContinuationByte();\n\t\t\tbyte4 = readContinuationByte();\n\t\t\tcodePoint = ((byte1 & 0x07) << 0x12) | (byte2 << 0x0C) |\n\t\t\t\t(byte3 << 0x06) | byte4;\n\t\t\tif (codePoint >= 0x010000 && codePoint <= 0x10FFFF) {\n\t\t\t\treturn codePoint;\n\t\t\t}\n\t\t}\n\n\t\tthrow Error('Invalid UTF-8 detected');\n\t}\n\n\tvar byteArray;\n\tvar byteCount;\n\tvar byteIndex;\n\tfunction utf8decode(byteString) {\n\t\tbyteArray = ucs2decode(byteString);\n\t\tbyteCount = byteArray.length;\n\t\tbyteIndex = 0;\n\t\tvar codePoints = [];\n\t\tvar tmp;\n\t\twhile ((tmp = decodeSymbol()) !== false) {\n\t\t\tcodePoints.push(tmp);\n\t\t}\n\t\treturn ucs2encode(codePoints);\n\t}\n\n\t/*--------------------------------------------------------------------------*/\n\n\tvar utf8 = {\n\t\t'version': '2.1.2',\n\t\t'encode': utf8encode,\n\t\t'decode': utf8decode\n\t};\n\n\t// Some AMD build optimizers, like r.js, check for specific condition patterns\n\t// like the following:\n\tif (\n\t\ttypeof define == 'function' &&\n\t\ttypeof define.amd == 'object' &&\n\t\tdefine.amd\n\t) {\n\t\tdefine(function() {\n\t\t\treturn utf8;\n\t\t});\n\t}\telse if (freeExports && !freeExports.nodeType) {\n\t\tif (freeModule) { // in Node.js or RingoJS v0.8.0+\n\t\t\tfreeModule.exports = utf8;\n\t\t} else { // in Narwhal or RingoJS v0.7.0-\n\t\t\tvar object = {};\n\t\t\tvar hasOwnProperty = object.hasOwnProperty;\n\t\t\tfor (var key in utf8) {\n\t\t\t\thasOwnProperty.call(utf8, key) && (freeExports[key] = utf8[key]);\n\t\t\t}\n\t\t}\n\t} else { // in Rhino or a web browser\n\t\troot.utf8 = utf8;\n\t}\n\n}(this));\n"],"preExistingComment":"//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["node_modules/browser-pack/_prelude.js","lib/Gist.js","lib/GitHub.js","lib/Issue.js","lib/Markdown.js","lib/Organization.js","lib/Project.js","lib/RateLimit.js","lib/Repository.js","lib/Requestable.js","lib/Search.js","lib/Team.js","lib/User.js","node_modules/axios/index.js","node_modules/axios/lib/adapters/xhr.js","node_modules/axios/lib/axios.js","node_modules/axios/lib/cancel/Cancel.js","node_modules/axios/lib/cancel/CancelToken.js","node_modules/axios/lib/cancel/isCancel.js","node_modules/axios/lib/core/Axios.js","node_modules/axios/lib/core/InterceptorManager.js","node_modules/axios/lib/core/createError.js","node_modules/axios/lib/core/dispatchRequest.js","node_modules/axios/lib/core/enhanceError.js","node_modules/axios/lib/core/settle.js","node_modules/axios/lib/core/transformData.js","node_modules/axios/lib/defaults.js","node_modules/axios/lib/helpers/bind.js","node_modules/axios/lib/helpers/btoa.js","node_modules/axios/lib/helpers/buildURL.js","node_modules/axios/lib/helpers/combineURLs.js","node_modules/axios/lib/helpers/cookies.js","node_modules/axios/lib/helpers/isAbsoluteURL.js","node_modules/axios/lib/helpers/isURLSameOrigin.js","node_modules/axios/lib/helpers/normalizeHeaderName.js","node_modules/axios/lib/helpers/parseHeaders.js","node_modules/axios/lib/helpers/spread.js","node_modules/axios/lib/utils.js","node_modules/base64-js/index.js","node_modules/buffer/index.js","node_modules/debug/src/browser.js","node_modules/debug/src/debug.js","node_modules/ieee754/index.js","node_modules/isarray/index.js","node_modules/js-base64/base64.js","node_modules/ms/index.js","node_modules/process/browser.js","node_modules/utf8/utf8.js"],"names":[],"mappings":"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AAK,QAAL,CAAc,MAAd,EAAsB,aAAtB,EAAqC,OAArC,EAA8C,EAA9C,CAAP;AACF;;;;;;AAGJ,OAAO,OAAP,GAAiB,IAAjB;;;ACtMA;;;ACAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;ACjLA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACpDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACnBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACzDA;AACA;AACA;AACA;AACA;AACA;;ACLA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACrFA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACpDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC/EA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACnBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACzBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;ACpBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;AC7FA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACXA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACpCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACpEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACZA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACrDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACdA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACpEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACZA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACr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lHA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;AC7vDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;ACtLA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACvMA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACpFA;AACA;AACA;AACA;AACA;AACA;;ACLA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AClMA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACrJA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;ACpLA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA","file":"generated.js","sourceRoot":"","sourcesContent":["(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require==\"function\"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error(\"Cannot find module '\"+o+\"'\");throw f.code=\"MODULE_NOT_FOUND\",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require==\"function\"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})","/**\n * @file\n * @copyright  2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license    Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n *             Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\n\n/**\n * A Gist can retrieve and modify gists.\n */\nclass Gist extends Requestable {\n   /**\n    * Create a Gist.\n    * @param {string} id - the id of the gist (not required when creating a gist)\n    * @param {Requestable.auth} [auth] - information required to authenticate to Github\n    * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n    */\n   constructor(id, auth, apiBase) {\n      super(auth, apiBase);\n      this.__id = id;\n   }\n\n   /**\n    * Fetch a gist.\n    * @see https://developer.github.com/v3/gists/#get-a-single-gist\n    * @param {Requestable.callback} [cb] - will receive the gist\n    * @return {Promise} - the Promise for the http request\n    */\n   read(cb) {\n      return this._request('GET', `/gists/${this.__id}`, null, cb);\n   }\n\n   /**\n    * Create a new gist.\n    * @see https://developer.github.com/v3/gists/#create-a-gist\n    * @param {Object} gist - the data for the new gist\n    * @param {Requestable.callback} [cb] - will receive the new gist upon creation\n    * @return {Promise} - the Promise for the http request\n    */\n   create(gist, cb) {\n      return this._request('POST', '/gists', gist, cb)\n         .then((response) => {\n            this.__id = response.data.id;\n            return response;\n         });\n   }\n\n   /**\n    * Delete a gist.\n    * @see https://developer.github.com/v3/gists/#delete-a-gist\n    * @param {Requestable.callback} [cb] - will receive true if the request succeeds\n    * @return {Promise} - the Promise for the http request\n    */\n   delete(cb) {\n      return this._request('DELETE', `/gists/${this.__id}`, null, cb);\n   }\n\n   /**\n    * Fork a gist.\n    * @see https://developer.github.com/v3/gists/#fork-a-gist\n    * @param {Requestable.callback} [cb] - the function that will receive the gist\n    * @return {Promise} - the Promise for the http request\n    */\n   fork(cb) {\n      return this._request('POST', `/gists/${this.__id}/forks`, null, cb);\n   }\n\n   /**\n    * Update a gist.\n    * @see https://developer.github.com/v3/gists/#edit-a-gist\n    * @param {Object} gist - the new data for the gist\n    * @param {Requestable.callback} [cb] - the function that receives the API result\n    * @return {Promise} - the Promise for the http request\n    */\n   update(gist, cb) {\n      return this._request('PATCH', `/gists/${this.__id}`, gist, cb);\n   }\n\n   /**\n    * Star a gist.\n    * @see https://developer.github.com/v3/gists/#star-a-gist\n    * @param {Requestable.callback} [cb] - will receive true if the request is successful\n    * @return {Promise} - the Promise for the http request\n    */\n   star(cb) {\n      return this._request('PUT', `/gists/${this.__id}/star`, null, cb);\n   }\n\n   /**\n    * Unstar a gist.\n    * @see https://developer.github.com/v3/gists/#unstar-a-gist\n    * @param {Requestable.callback} [cb] - will receive true if the request is successful\n    * @return {Promise} - the Promise for the http request\n    */\n   unstar(cb) {\n      return this._request('DELETE', `/gists/${this.__id}/star`, null, cb);\n   }\n\n   /**\n    * Check if a gist is starred by the user.\n    * @see https://developer.github.com/v3/gists/#check-if-a-gist-is-starred\n    * @param {Requestable.callback} [cb] - will receive true if the gist is starred and false if the gist is not starred\n    * @return {Promise} - the Promise for the http request\n    */\n   isStarred(cb) {\n      return this._request204or404(`/gists/${this.__id}/star`, null, cb);\n   }\n\n   /**\n    * List the gist's commits\n    * @see https://developer.github.com/v3/gists/#list-gist-commits\n    * @param {Requestable.callback} [cb] - will receive the array of commits\n    * @return {Promise} - the Promise for the http request\n    */\n   listCommits(cb) {\n      return this._requestAllPages(`/gists/${this.__id}/commits`, null, cb);\n   }\n\n   /**\n    * Fetch one of the gist's revision.\n    * @see https://developer.github.com/v3/gists/#get-a-specific-revision-of-a-gist\n    * @param {string} revision - the id of the revision\n    * @param {Requestable.callback} [cb] - will receive the revision\n    * @return {Promise} - the Promise for the http request\n    */\n   getRevision(revision, cb) {\n      return this._request('GET', `/gists/${this.__id}/${revision}`, null, cb);\n   }\n\n   /**\n    * List the gist's comments\n    * @see https://developer.github.com/v3/gists/comments/#list-comments-on-a-gist\n    * @param {Requestable.callback} [cb] - will receive the array of comments\n    * @return {Promise} - the promise for the http request\n    */\n   listComments(cb) {\n      return this._requestAllPages(`/gists/${this.__id}/comments`, null, cb);\n   }\n\n   /**\n    * Fetch one of the gist's comments\n    * @see https://developer.github.com/v3/gists/comments/#get-a-single-comment\n    * @param {number} comment - the id of the comment\n    * @param {Requestable.callback} [cb] - will receive the comment\n    * @return {Promise} - the Promise for the http request\n    */\n   getComment(comment, cb) {\n      return this._request('GET', `/gists/${this.__id}/comments/${comment}`, null, cb);\n   }\n\n   /**\n    * Comment on a gist\n    * @see https://developer.github.com/v3/gists/comments/#create-a-comment\n    * @param {string} comment - the comment to add\n    * @param {Requestable.callback} [cb] - the function that receives the API result\n    * @return {Promise} - the Promise for the http request\n    */\n   createComment(comment, cb) {\n      return this._request('POST', `/gists/${this.__id}/comments`, {body: comment}, cb);\n   }\n\n   /**\n    * Edit a comment on the gist\n    * @see https://developer.github.com/v3/gists/comments/#edit-a-comment\n    * @param {number} comment - the id of the comment\n    * @param {string} body - the new comment\n    * @param {Requestable.callback} [cb] - will receive the modified comment\n    * @return {Promise} - the promise for the http request\n    */\n   editComment(comment, body, cb) {\n      return this._request('PATCH', `/gists/${this.__id}/comments/${comment}`, {body: body}, cb);\n   }\n\n   /**\n    * Delete a comment on the gist.\n    * @see https://developer.github.com/v3/gists/comments/#delete-a-comment\n    * @param {number} comment - the id of the comment\n    * @param {Requestable.callback} [cb] - will receive true if the request succeeds\n    * @return {Promise} - the Promise for the http request\n    */\n   deleteComment(comment, cb) {\n      return this._request('DELETE', `/gists/${this.__id}/comments/${comment}`, null, cb);\n   }\n}\n\nmodule.exports = Gist;\n","/**\n * @file\n * @copyright  2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license    Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n *             Github.js is freely distributable.\n */\n/* eslint valid-jsdoc: [\"error\", {\"requireReturnDescription\": false}] */\n\nimport Gist from './Gist';\nimport User from './User';\nimport Issue from './Issue';\nimport Search from './Search';\nimport RateLimit from './RateLimit';\nimport Repository from './Repository';\nimport Organization from './Organization';\nimport Team from './Team';\nimport Markdown from './Markdown';\nimport Project from './Project';\n\n/**\n * GitHub encapsulates the functionality to create various API wrapper objects.\n */\nclass GitHub {\n   /**\n    * Create a new GitHub.\n    * @param {Requestable.auth} [auth] - the credentials to authenticate to Github. If auth is\n    *                                  not provided requests will be made unauthenticated\n    * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n    */\n   constructor(auth, apiBase = 'https://api.github.com') {\n      this.__apiBase = apiBase;\n      this.__auth = auth || {};\n   }\n\n   /**\n    * Create a new Gist wrapper\n    * @param {number} [id] - the id for the gist, leave undefined when creating a new gist\n    * @return {Gist}\n    */\n   getGist(id) {\n      return new Gist(id, this.__auth, this.__apiBase);\n   }\n\n   /**\n    * Create a new User wrapper\n    * @param {string} [user] - the name of the user to get information about\n    *                        leave undefined for the authenticated user\n    * @return {User}\n    */\n   getUser(user) {\n      return new User(user, this.__auth, this.__apiBase);\n   }\n\n   /**\n    * Create a new Organization wrapper\n    * @param {string} organization - the name of the organization\n    * @return {Organization}\n    */\n   getOrganization(organization) {\n      return new Organization(organization, this.__auth, this.__apiBase);\n   }\n\n   /**\n    * create a new Team wrapper\n    * @param {string} teamId - the name of the team\n    * @return {team}\n    */\n   getTeam(teamId) {\n      return new Team(teamId, this.__auth, this.__apiBase);\n   }\n\n   /**\n    * Create a new Repository wrapper\n    * @param {string} user - the user who owns the respository\n    * @param {string} repo - the name of the repository\n    * @return {Repository}\n    */\n   getRepo(user, repo) {\n      return new Repository(this._getFullName(user, repo), this.__auth, this.__apiBase);\n   }\n\n   /**\n    * Create a new Issue wrapper\n    * @param {string} user - the user who owns the respository\n    * @param {string} repo - the name of the repository\n    * @return {Issue}\n    */\n   getIssues(user, repo) {\n      return new Issue(this._getFullName(user, repo), this.__auth, this.__apiBase);\n   }\n\n   /**\n    * Create a new Search wrapper\n    * @param {string} query - the query to search for\n    * @return {Search}\n    */\n   search(query) {\n      return new Search(query, this.__auth, this.__apiBase);\n   }\n\n   /**\n    * Create a new RateLimit wrapper\n    * @return {RateLimit}\n    */\n   getRateLimit() {\n      return new RateLimit(this.__auth, this.__apiBase);\n   }\n\n   /**\n    * Create a new Markdown wrapper\n    * @return {Markdown}\n    */\n   getMarkdown() {\n      return new Markdown(this.__auth, this.__apiBase);\n   }\n\n   /**\n    * Create a new Project wrapper\n    * @param {string} id - the id of the project\n    * @return {Markdown}\n    */\n   getProject(id) {\n      return new Project(id, this.__auth, this.__apiBase);\n   }\n\n   /**\n    * Computes the full repository name\n    * @param {string} user - the username (or the full name)\n    * @param {string} repo - the repository name, must not be passed if `user` is the full name\n    * @return {string} the repository's full name\n    */\n   _getFullName(user, repo) {\n      let fullname = user;\n\n      if (repo) {\n         fullname = `${user}/${repo}`;\n      }\n\n      return fullname;\n   }\n}\n\nmodule.exports = GitHub;\n","/**\n * @file\n * @copyright  2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license    Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n *             Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\n\n/**\n * Issue wraps the functionality to get issues for repositories\n */\nclass Issue extends Requestable {\n   /**\n    * Create a new Issue\n    * @param {string} repository - the full name of the repository (`:user/:repo`) to get issues for\n    * @param {Requestable.auth} [auth] - information required to authenticate to Github\n    * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n    */\n   constructor(repository, auth, apiBase) {\n      super(auth, apiBase);\n      this.__repository = repository;\n   }\n\n   /**\n    * Create a new issue\n    * @see https://developer.github.com/v3/issues/#create-an-issue\n    * @param {Object} issueData - the issue to create\n    * @param {Requestable.callback} [cb] - will receive the created issue\n    * @return {Promise} - the promise for the http request\n    */\n   createIssue(issueData, cb) {\n      return this._request('POST', `/repos/${this.__repository}/issues`, issueData, cb);\n   }\n\n   /**\n    * List the issues for the repository\n    * @see https://developer.github.com/v3/issues/#list-issues-for-a-repository\n    * @param {Object} options - filtering options\n    * @param {Requestable.callback} [cb] - will receive the array of issues\n    * @return {Promise} - the promise for the http request\n    */\n   listIssues(options, cb) {\n      return this._requestAllPages(`/repos/${this.__repository}/issues`, options, cb);\n   }\n\n   /**\n    * List the events for an issue\n    * @see https://developer.github.com/v3/issues/events/#list-events-for-an-issue\n    * @param {number} issue - the issue to get events for\n    * @param {Requestable.callback} [cb] - will receive the list of events\n    * @return {Promise} - the promise for the http request\n    */\n   listIssueEvents(issue, cb) {\n      return this._request('GET', `/repos/${this.__repository}/issues/${issue}/events`, null, cb);\n   }\n\n   /**\n    * List comments on an issue\n    * @see https://developer.github.com/v3/issues/comments/#list-comments-on-an-issue\n    * @param {number} issue - the id of the issue to get comments from\n    * @param {Requestable.callback} [cb] - will receive the comments\n    * @return {Promise} - the promise for the http request\n    */\n   listIssueComments(issue, cb) {\n      return this._request('GET', `/repos/${this.__repository}/issues/${issue}/comments`, null, cb);\n   }\n\n   /**\n    * Get a single comment on an issue\n    * @see https://developer.github.com/v3/issues/comments/#get-a-single-comment\n    * @param {number} id - the comment id to get\n    * @param {Requestable.callback} [cb] - will receive the comment\n    * @return {Promise} - the promise for the http request\n    */\n   getIssueComment(id, cb) {\n      return this._request('GET', `/repos/${this.__repository}/issues/comments/${id}`, null, cb);\n   }\n\n   /**\n    * Comment on an issue\n    * @see https://developer.github.com/v3/issues/comments/#create-a-comment\n    * @param {number} issue - the id of the issue to comment on\n    * @param {string} comment - the comment to add\n    * @param {Requestable.callback} [cb] - will receive the created comment\n    * @return {Promise} - the promise for the http request\n    */\n   createIssueComment(issue, comment, cb) {\n      return this._request('POST', `/repos/${this.__repository}/issues/${issue}/comments`, {body: comment}, cb);\n   }\n\n   /**\n    * Edit a comment on an issue\n    * @see https://developer.github.com/v3/issues/comments/#edit-a-comment\n    * @param {number} id - the comment id to edit\n    * @param {string} comment - the comment to edit\n    * @param {Requestable.callback} [cb] - will receive the edited comment\n    * @return {Promise} - the promise for the http request\n    */\n   editIssueComment(id, comment, cb) {\n      return this._request('PATCH', `/repos/${this.__repository}/issues/comments/${id}`, {body: comment}, cb);\n   }\n\n   /**\n    * Delete a comment on an issue\n    * @see https://developer.github.com/v3/issues/comments/#delete-a-comment\n    * @param {number} id - the comment id to delete\n    * @param {Requestable.callback} [cb] - will receive true if the request is successful\n    * @return {Promise} - the promise for the http request\n    */\n   deleteIssueComment(id, cb) {\n      return this._request('DELETE', `/repos/${this.__repository}/issues/comments/${id}`, null, cb);\n   }\n\n   /**\n    * Edit an issue\n    * @see https://developer.github.com/v3/issues/#edit-an-issue\n    * @param {number} issue - the issue number to edit\n    * @param {Object} issueData - the new issue data\n    * @param {Requestable.callback} [cb] - will receive the modified issue\n    * @return {Promise} - the promise for the http request\n    */\n   editIssue(issue, issueData, cb) {\n      return this._request('PATCH', `/repos/${this.__repository}/issues/${issue}`, issueData, cb);\n   }\n\n   /**\n    * Get a particular issue\n    * @see https://developer.github.com/v3/issues/#get-a-single-issue\n    * @param {number} issue - the issue number to fetch\n    * @param {Requestable.callback} [cb] - will receive the issue\n    * @return {Promise} - the promise for the http request\n    */\n   getIssue(issue, cb) {\n      return this._request('GET', `/repos/${this.__repository}/issues/${issue}`, null, cb);\n   }\n\n   /**\n    * List the milestones for the repository\n    * @see https://developer.github.com/v3/issues/milestones/#list-milestones-for-a-repository\n    * @param {Object} options - filtering options\n    * @param {Requestable.callback} [cb] - will receive the array of milestones\n    * @return {Promise} - the promise for the http request\n    */\n   listMilestones(options, cb) {\n      return this._request('GET', `/repos/${this.__repository}/milestones`, options, cb);\n   }\n\n   /**\n    * Get a milestone\n    * @see https://developer.github.com/v3/issues/milestones/#get-a-single-milestone\n    * @param {string} milestone - the id of the milestone to fetch\n    * @param {Requestable.callback} [cb] - will receive the milestone\n    * @return {Promise} - the promise for the http request\n    */\n   getMilestone(milestone, cb) {\n      return this._request('GET', `/repos/${this.__repository}/milestones/${milestone}`, null, cb);\n   }\n\n   /**\n    * Create a new milestone\n    * @see https://developer.github.com/v3/issues/milestones/#create-a-milestone\n    * @param {Object} milestoneData - the milestone definition\n    * @param {Requestable.callback} [cb] - will receive the milestone\n    * @return {Promise} - the promise for the http request\n    */\n   createMilestone(milestoneData, cb) {\n      return this._request('POST', `/repos/${this.__repository}/milestones`, milestoneData, cb);\n   }\n\n   /**\n    * Edit a milestone\n    * @see https://developer.github.com/v3/issues/milestones/#update-a-milestone\n    * @param {string} milestone - the id of the milestone to edit\n    * @param {Object} milestoneData - the updates to make to the milestone\n    * @param {Requestable.callback} [cb] - will receive the updated milestone\n    * @return {Promise} - the promise for the http request\n    */\n   editMilestone(milestone, milestoneData, cb) {\n      return this._request('PATCH', `/repos/${this.__repository}/milestones/${milestone}`, milestoneData, cb);\n   }\n\n   /**\n    * Delete a milestone (this is distinct from closing a milestone)\n    * @see https://developer.github.com/v3/issues/milestones/#delete-a-milestone\n    * @param {string} milestone - the id of the milestone to delete\n    * @param {Requestable.callback} [cb] - will receive the status\n    * @return {Promise} - the promise for the http request\n    */\n   deleteMilestone(milestone, cb) {\n      return this._request('DELETE', `/repos/${this.__repository}/milestones/${milestone}`, null, cb);\n   }\n\n   /**\n    * Create a new label\n    * @see https://developer.github.com/v3/issues/labels/#create-a-label\n    * @param {Object} labelData - the label definition\n    * @param {Requestable.callback} [cb] - will receive the object representing the label\n    * @return {Promise} - the promise for the http request\n    */\n   createLabel(labelData, cb) {\n      return this._request('POST', `/repos/${this.__repository}/labels`, labelData, cb);\n   }\n\n  /**\n   * List the labels for the repository\n   * @see https://developer.github.com/v3/issues/labels/#list-all-labels-for-this-repository\n   * @param {Object} options - filtering options\n   * @param {Requestable.callback} [cb] - will receive the array of labels\n   * @return {Promise} - the promise for the http request\n   */\n   listLabels(options, cb) {\n      return this._request('GET', `/repos/${this.__repository}/labels`, options, cb);\n   }\n\n  /**\n   * Get a label\n   * @see https://developer.github.com/v3/issues/labels/#get-a-single-label\n   * @param {string} label - the name of the label to fetch\n   * @param {Requestable.callback} [cb] - will receive the label\n   * @return {Promise} - the promise for the http request\n   */\n   getLabel(label, cb) {\n      return this._request('GET', `/repos/${this.__repository}/labels/${label}`, null, cb);\n   }\n\n  /**\n   * Edit a label\n   * @see https://developer.github.com/v3/issues/labels/#update-a-label\n   * @param {string} label - the name of the label to edit\n   * @param {Object} labelData - the updates to make to the label\n   * @param {Requestable.callback} [cb] - will receive the updated label\n   * @return {Promise} - the promise for the http request\n   */\n   editLabel(label, labelData, cb) {\n      return this._request('PATCH', `/repos/${this.__repository}/labels/${label}`, labelData, cb);\n   }\n\n  /**\n   * Delete a label\n   * @see https://developer.github.com/v3/issues/labels/#delete-a-label\n   * @param {string} label - the name of the label to delete\n   * @param {Requestable.callback} [cb] - will receive the status\n   * @return {Promise} - the promise for the http request\n   */\n   deleteLabel(label, cb) {\n      return this._request('DELETE', `/repos/${this.__repository}/labels/${label}`, null, cb);\n   }\n}\n\nmodule.exports = Issue;\n","/**\n * @file\n * @copyright  2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license    Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n *             Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\n\n/**\n * Renders html from Markdown text\n */\nclass Markdown extends Requestable {\n   /**\n    * construct a Markdown\n    * @param {Requestable.auth} auth - the credentials to authenticate to GitHub\n    * @param {string} [apiBase] - the base Github API URL\n    * @return {Promise} - the promise for the http request\n    */\n   constructor(auth, apiBase) {\n      super(auth, apiBase);\n   }\n\n   /**\n    * Render html from Markdown text.\n    * @see https://developer.github.com/v3/markdown/#render-an-arbitrary-markdown-document\n    * @param {Object} options - conversion options\n    * @param {string} [options.text] - the markdown text to convert\n    * @param {string} [options.mode=markdown] - can be either `markdown` or `gfm`\n    * @param {string} [options.context] - repository name if mode is gfm\n    * @param {Requestable.callback} [cb] - will receive the converted html\n    * @return {Promise} - the promise for the http request\n    */\n   render(options, cb) {\n      return this._request('POST', '/markdown', options, cb);\n   }\n}\n\nmodule.exports = Markdown;\n","/**\n * @file\n * @copyright  2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license    Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n *             Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\n\n/**\n * Organization encapsulates the functionality to create repositories in organizations\n */\nclass Organization extends Requestable {\n   /**\n    * Create a new Organization\n    * @param {string} organization - the name of the organization\n    * @param {Requestable.auth} [auth] - information required to authenticate to Github\n    * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n    */\n   constructor(organization, auth, apiBase) {\n      super(auth, apiBase);\n      this.__name = organization;\n   }\n\n   /**\n    * Create a repository in an organization\n    * @see https://developer.github.com/v3/repos/#create\n    * @param {Object} options - the repository definition\n    * @param {Requestable.callback} [cb] - will receive the created repository\n    * @return {Promise} - the promise for the http request\n    */\n   createRepo(options, cb) {\n      return this._request('POST', `/orgs/${this.__name}/repos`, options, cb);\n   }\n\n   /**\n    * List the repositories in an organization\n    * @see https://developer.github.com/v3/repos/#list-organization-repositories\n    * @param {Requestable.callback} [cb] - will receive the list of repositories\n    * @return {Promise} - the promise for the http request\n    */\n   getRepos(cb) {\n      let requestOptions = this._getOptionsWithDefaults({direction: 'desc'});\n\n      return this._requestAllPages(`/orgs/${this.__name}/repos`, requestOptions, cb);\n   }\n\n   /**\n    * Query if the user is a member or not\n    * @param {string} username - the user in question\n    * @param {Requestable.callback} [cb] - will receive true if the user is a member\n    * @return {Promise} - the promise for the http request\n    */\n   isMember(username, cb) {\n      return this._request204or404(`/orgs/${this.__name}/members/${username}`, null, cb);\n   }\n\n   /**\n    * List the users who are members of the company\n    * @see https://developer.github.com/v3/orgs/members/#members-list\n    * @param {object} options - filtering options\n    * @param {string} [options.filter=all] - can be either `2fa_disabled` or `all`\n    * @param {string} [options.role=all] - can be one of: `all`, `admin`, or `member`\n    * @param {Requestable.callback} [cb] - will receive the list of users\n    * @return {Promise} - the promise for the http request\n    */\n   listMembers(options, cb) {\n      return this._request('GET', `/orgs/${this.__name}/members`, options, cb);\n   }\n\n   /**\n    * List the Teams in the Organization\n    * @see https://developer.github.com/v3/orgs/teams/#list-teams\n    * @param {Requestable.callback} [cb] - will receive the list of teams\n    * @return {Promise} - the promise for the http request\n    */\n   getTeams(cb) {\n      return this._requestAllPages(`/orgs/${this.__name}/teams`, undefined, cb);\n   }\n\n   /**\n    * Create a team\n    * @see https://developer.github.com/v3/orgs/teams/#create-team\n    * @param {object} options - Team creation parameters\n    * @param {string} options.name - The name of the team\n    * @param {string} [options.description] - Team description\n    * @param {string} [options.repo_names] - Repos to add the team to\n    * @param {string} [options.privacy=secret] - The level of privacy the team should have. Can be either one\n    * of: `secret`, or `closed`\n    * @param {Requestable.callback} [cb] - will receive the created team\n    * @return {Promise} - the promise for the http request\n    */\n   createTeam(options, cb) {\n      return this._request('POST', `/orgs/${this.__name}/teams`, options, cb);\n   }\n\n   /**\n    * Get information about all projects\n    * @see https://developer.github.com/v3/projects/#list-organization-projects\n    * @param {Requestable.callback} [cb] - will receive the list of projects\n    * @return {Promise} - the promise for the http request\n    */\n   listProjects(cb) {\n      return this._requestAllPages(`/orgs/${this.__name}/projects`, {AcceptHeader: 'inertia-preview'}, cb);\n   }\n\n   /**\n    * Create a new project\n    * @see https://developer.github.com/v3/repos/projects/#create-a-project\n    * @param {Object} options - the description of the project\n    * @param {Requestable.callback} cb - will receive the newly created project\n    * @return {Promise} - the promise for the http request\n    */\n   createProject(options, cb) {\n      options = options || {};\n      options.AcceptHeader = 'inertia-preview';\n      return this._request('POST', `/orgs/${this.__name}/projects`, options, cb);\n   }\n}\n\nmodule.exports = Organization;\n","/**\n * @file\n * @copyright  2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license    Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n *             Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\n\n/**\n * Project encapsulates the functionality to create, query, and modify cards and columns.\n */\nclass Project extends Requestable {\n   /**\n    * Create a Project.\n    * @param {string} id - the id of the project\n    * @param {Requestable.auth} [auth] - information required to authenticate to Github\n    * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n    */\n   constructor(id, auth, apiBase) {\n      super(auth, apiBase, 'inertia-preview');\n      this.__id = id;\n   }\n\n   /**\n    * Get information about a project\n    * @see https://developer.github.com/v3/projects/#get-a-project\n    * @param {Requestable.callback} cb - will receive the project information\n    * @return {Promise} - the promise for the http request\n    */\n   getProject(cb) {\n      return this._request('GET', `/projects/${this.__id}`, null, cb);\n   }\n\n   /**\n    * Edit a project\n    * @see https://developer.github.com/v3/projects/#update-a-project\n    * @param {Object} options - the description of the project\n    * @param {Requestable.callback} cb - will receive the modified project\n    * @return {Promise} - the promise for the http request\n    */\n   updateProject(options, cb) {\n      return this._request('PATCH', `/projects/${this.__id}`, options, cb);\n   }\n\n   /**\n    * Delete a project\n    * @see https://developer.github.com/v3/projects/#delete-a-project\n    * @param {Requestable.callback} cb - will receive true if the operation is successful\n    * @return {Promise} - the promise for the http request\n    */\n   deleteProject(cb) {\n      return this._request('DELETE', `/projects/${this.__id}`, null, cb);\n   }\n\n   /**\n    * Get information about all columns of a project\n    * @see https://developer.github.com/v3/projects/columns/#list-project-columns\n    * @param {Requestable.callback} [cb] - will receive the list of columns\n    * @return {Promise} - the promise for the http request\n    */\n   listProjectColumns(cb) {\n      return this._requestAllPages(`/projects/${this.__id}/columns`, null, cb);\n   }\n\n   /**\n    * Get information about a column\n    * @see https://developer.github.com/v3/projects/columns/#get-a-project-column\n    * @param {string} colId - the id of the column\n    * @param {Requestable.callback} cb - will receive the column information\n    * @return {Promise} - the promise for the http request\n    */\n   getProjectColumn(colId, cb) {\n      return this._request('GET', `/projects/columns/${colId}`, null, cb);\n   }\n\n   /**\n    * Create a new column\n    * @see https://developer.github.com/v3/projects/columns/#create-a-project-column\n    * @param {Object} options - the description of the column\n    * @param {Requestable.callback} cb - will receive the newly created column\n    * @return {Promise} - the promise for the http request\n    */\n   createProjectColumn(options, cb) {\n      return this._request('POST', `/projects/${this.__id}/columns`, options, cb);\n   }\n\n   /**\n    * Edit a column\n    * @see https://developer.github.com/v3/projects/columns/#update-a-project-column\n    * @param {string} colId - the column id\n    * @param {Object} options - the description of the column\n    * @param {Requestable.callback} cb - will receive the modified column\n    * @return {Promise} - the promise for the http request\n    */\n   updateProjectColumn(colId, options, cb) {\n      return this._request('PATCH', `/projects/columns/${colId}`, options, cb);\n   }\n\n   /**\n    * Delete a column\n    * @see https://developer.github.com/v3/projects/columns/#delete-a-project-column\n    * @param {string} colId - the column to be deleted\n    * @param {Requestable.callback} cb - will receive true if the operation is successful\n    * @return {Promise} - the promise for the http request\n    */\n   deleteProjectColumn(colId, cb) {\n      return this._request('DELETE', `/projects/columns/${colId}`, null, cb);\n   }\n\n   /**\n    * Move a column\n    * @see https://developer.github.com/v3/projects/columns/#move-a-project-column\n    * @param {string} colId - the column to be moved\n    * @param {string} position - can be one of first, last, or after:<column-id>,\n    * where <column-id> is the id value of a column in the same project.\n    * @param {Requestable.callback} cb - will receive true if the operation is successful\n    * @return {Promise} - the promise for the http request\n    */\n   moveProjectColumn(colId, position, cb) {\n      return this._request(\n         'POST',\n         `/projects/columns/${colId}/moves`,\n         {position: position},\n         cb\n      );\n   }\n\n  /**\n   * Get information about all cards of a project\n   * @see https://developer.github.com/v3/projects/cards/#list-project-cards\n   * @param {Requestable.callback} [cb] - will receive the list of cards\n   * @return {Promise} - the promise for the http request\n   */\n   listProjectCards(cb) {\n      return this.listProjectColumns()\n        .then(({data}) => {\n           return Promise.all(data.map((column) => {\n              return this._requestAllPages(`/projects/columns/${column.id}/cards`, null);\n           }));\n        }).then((cardsInColumns) => {\n           const cards = cardsInColumns.reduce((prev, {data}) => {\n              prev.push(...data);\n              return prev;\n           }, []);\n           if (cb) {\n              cb(null, cards);\n           }\n           return cards;\n        }).catch((err) => {\n           if (cb) {\n              cb(err);\n              return;\n           }\n           throw err;\n        });\n   }\n\n   /**\n   * Get information about all cards of a column\n   * @see https://developer.github.com/v3/projects/cards/#list-project-cards\n   * @param {string} colId - the id of the column\n   * @param {Requestable.callback} [cb] - will receive the list of cards\n   * @return {Promise} - the promise for the http request\n   */\n   listColumnCards(colId, cb) {\n      return this._requestAllPages(`/projects/columns/${colId}/cards`, null, cb);\n   }\n\n   /**\n   * Get information about a card\n   * @see https://developer.github.com/v3/projects/cards/#get-a-project-card\n   * @param {string} cardId - the id of the card\n   * @param {Requestable.callback} cb - will receive the card information\n   * @return {Promise} - the promise for the http request\n   */\n   getProjectCard(cardId, cb) {\n      return this._request('GET', `/projects/columns/cards/${cardId}`, null, cb);\n   }\n\n   /**\n   * Create a new card\n   * @see https://developer.github.com/v3/projects/cards/#create-a-project-card\n   * @param {string} colId - the column id\n   * @param {Object} options - the description of the card\n   * @param {Requestable.callback} cb - will receive the newly created card\n   * @return {Promise} - the promise for the http request\n   */\n   createProjectCard(colId, options, cb) {\n      return this._request('POST', `/projects/columns/${colId}/cards`, options, cb);\n   }\n\n   /**\n   * Edit a card\n   * @see https://developer.github.com/v3/projects/cards/#update-a-project-card\n   * @param {string} cardId - the card id\n   * @param {Object} options - the description of the card\n   * @param {Requestable.callback} cb - will receive the modified card\n   * @return {Promise} - the promise for the http request\n   */\n   updateProjectCard(cardId, options, cb) {\n      return this._request('PATCH', `/projects/columns/cards/${cardId}`, options, cb);\n   }\n\n   /**\n   * Delete a card\n   * @see https://developer.github.com/v3/projects/cards/#delete-a-project-card\n   * @param {string} cardId - the card to be deleted\n   * @param {Requestable.callback} cb - will receive true if the operation is successful\n   * @return {Promise} - the promise for the http request\n   */\n   deleteProjectCard(cardId, cb) {\n      return this._request('DELETE', `/projects/columns/cards/${cardId}`, null, cb);\n   }\n\n   /**\n   * Move a card\n   * @see https://developer.github.com/v3/projects/cards/#move-a-project-card\n   * @param {string} cardId - the card to be moved\n   * @param {string} position - can be one of top, bottom, or after:<card-id>,\n   * where <card-id> is the id value of a card in the same project.\n   * @param {string} colId - the id value of a column in the same project.\n   * @param {Requestable.callback} cb - will receive true if the operation is successful\n   * @return {Promise} - the promise for the http request\n   */\n   moveProjectCard(cardId, position, colId, cb) {\n      return this._request(\n         'POST',\n         `/projects/columns/cards/${cardId}/moves`,\n         {position: position, column_id: colId}, // eslint-disable-line camelcase\n         cb\n      );\n   }\n}\n\nmodule.exports = Project;\n","/**\n * @file\n * @copyright  2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license    Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n *             Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\n\n/**\n * RateLimit allows users to query their rate-limit status\n */\nclass RateLimit extends Requestable {\n   /**\n    * construct a RateLimit\n    * @param {Requestable.auth} auth - the credentials to authenticate to GitHub\n    * @param {string} [apiBase] - the base Github API URL\n    * @return {Promise} - the promise for the http request\n    */\n   constructor(auth, apiBase) {\n      super(auth, apiBase);\n   }\n\n   /**\n    * Query the current rate limit\n    * @see https://developer.github.com/v3/rate_limit/\n    * @param {Requestable.callback} [cb] - will receive the rate-limit data\n    * @return {Promise} - the promise for the http request\n    */\n   getRateLimit(cb) {\n      return this._request('GET', '/rate_limit', null, cb);\n   }\n}\n\nmodule.exports = RateLimit;\n","/**\n * @file\n * @copyright  2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license    Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n *             Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\nimport Utf8 from 'utf8';\nimport {\n   Base64,\n} from 'js-base64';\nimport debug from 'debug';\nconst log = debug('github:repository');\n\n/**\n * Respository encapsulates the functionality to create, query, and modify files.\n */\nclass Repository extends Requestable {\n   /**\n    * Create a Repository.\n    * @param {string} fullname - the full name of the repository\n    * @param {Requestable.auth} [auth] - information required to authenticate to Github\n    * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n    */\n   constructor(fullname, auth, apiBase) {\n      super(auth, apiBase);\n      this.__fullname = fullname;\n      this.__currentTree = {\n         branch: null,\n         sha: null,\n      };\n   }\n\n   /**\n    * Get a reference\n    * @see https://developer.github.com/v3/git/refs/#get-a-reference\n    * @param {string} ref - the reference to get\n    * @param {Requestable.callback} [cb] - will receive the reference's refSpec or a list of refSpecs that match `ref`\n    * @return {Promise} - the promise for the http request\n    */\n   getRef(ref, cb) {\n      return this._request('GET', `/repos/${this.__fullname}/git/refs/${ref}`, null, cb);\n   }\n\n   /**\n    * Create a reference\n    * @see https://developer.github.com/v3/git/refs/#create-a-reference\n    * @param {Object} options - the object describing the ref\n    * @param {Requestable.callback} [cb] - will receive the ref\n    * @return {Promise} - the promise for the http request\n    */\n   createRef(options, cb) {\n      return this._request('POST', `/repos/${this.__fullname}/git/refs`, options, cb);\n   }\n\n   /**\n    * Delete a reference\n    * @see https://developer.github.com/v3/git/refs/#delete-a-reference\n    * @param {string} ref - the name of the ref to delte\n    * @param {Requestable.callback} [cb] - will receive true if the request is successful\n    * @return {Promise} - the promise for the http request\n    */\n   deleteRef(ref, cb) {\n      return this._request('DELETE', `/repos/${this.__fullname}/git/refs/${ref}`, null, cb);\n   }\n\n   /**\n    * Delete a repository\n    * @see https://developer.github.com/v3/repos/#delete-a-repository\n    * @param {Requestable.callback} [cb] - will receive true if the request is successful\n    * @return {Promise} - the promise for the http request\n    */\n   deleteRepo(cb) {\n      return this._request('DELETE', `/repos/${this.__fullname}`, null, cb);\n   }\n\n   /**\n    * List the tags on a repository\n    * @see https://developer.github.com/v3/repos/#list-tags\n    * @param {Requestable.callback} [cb] - will receive the tag data\n    * @return {Promise} - the promise for the http request\n    */\n   listTags(cb) {\n      return this._request('GET', `/repos/${this.__fullname}/tags`, null, cb);\n   }\n\n   /**\n    * List the open pull requests on the repository\n    * @see https://developer.github.com/v3/pulls/#list-pull-requests\n    * @param {Object} options - options to filter the search\n    * @param {Requestable.callback} [cb] - will receive the list of PRs\n    * @return {Promise} - the promise for the http request\n    */\n   listPullRequests(options, cb) {\n      options = options || {};\n      return this._request('GET', `/repos/${this.__fullname}/pulls`, options, cb);\n   }\n\n   /**\n    * Get information about a specific pull request\n    * @see https://developer.github.com/v3/pulls/#get-a-single-pull-request\n    * @param {number} number - the PR you wish to fetch\n    * @param {Requestable.callback} [cb] - will receive the PR from the API\n    * @return {Promise} - the promise for the http request\n    */\n   getPullRequest(number, cb) {\n      return this._request('GET', `/repos/${this.__fullname}/pulls/${number}`, null, cb);\n   }\n\n   /**\n    * List the files of a specific pull request\n    * @see https://developer.github.com/v3/pulls/#list-pull-requests-files\n    * @param {number|string} number - the PR you wish to fetch\n    * @param {Requestable.callback} [cb] - will receive the list of files from the API\n    * @return {Promise} - the promise for the http request\n    */\n   listPullRequestFiles(number, cb) {\n      return this._request('GET', `/repos/${this.__fullname}/pulls/${number}/files`, null, cb);\n   }\n\n   /**\n    * Compare two branches/commits/repositories\n    * @see https://developer.github.com/v3/repos/commits/#compare-two-commits\n    * @param {string} base - the base commit\n    * @param {string} head - the head commit\n    * @param {Requestable.callback} cb - will receive the comparison\n    * @return {Promise} - the promise for the http request\n    */\n   compareBranches(base, head, cb) {\n      return this._request('GET', `/repos/${this.__fullname}/compare/${base}...${head}`, null, cb);\n   }\n\n   /**\n    * List all the branches for the repository\n    * @see https://developer.github.com/v3/repos/#list-branches\n    * @param {Requestable.callback} cb - will receive the list of branches\n    * @return {Promise} - the promise for the http request\n    */\n   listBranches(cb) {\n      return this._request('GET', `/repos/${this.__fullname}/branches`, null, cb);\n   }\n\n   /**\n    * Get a raw blob from the repository\n    * @see https://developer.github.com/v3/git/blobs/#get-a-blob\n    * @param {string} sha - the sha of the blob to fetch\n    * @param {Requestable.callback} cb - will receive the blob from the API\n    * @return {Promise} - the promise for the http request\n    */\n   getBlob(sha, cb) {\n      return this._request('GET', `/repos/${this.__fullname}/git/blobs/${sha}`, null, cb, 'raw');\n   }\n\n   /**\n    * Get a single branch\n    * @see https://developer.github.com/v3/repos/branches/#get-branch\n    * @param {string} branch - the name of the branch to fetch\n    * @param {Requestable.callback} cb - will receive the branch from the API\n    * @returns {Promise} - the promise for the http request\n    */\n   getBranch(branch, cb) {\n      return this._request('GET', `/repos/${this.__fullname}/branches/${branch}`, null, cb);\n   }\n\n   /**\n    * Get a commit from the repository\n    * @see https://developer.github.com/v3/repos/commits/#get-a-single-commit\n    * @param {string} sha - the sha for the commit to fetch\n    * @param {Requestable.callback} cb - will receive the commit data\n    * @return {Promise} - the promise for the http request\n    */\n   getCommit(sha, cb) {\n      return this._request('GET', `/repos/${this.__fullname}/git/commits/${sha}`, null, cb);\n   }\n\n   /**\n    * List the commits on a repository, optionally filtering by path, author or time range\n    * @see https://developer.github.com/v3/repos/commits/#list-commits-on-a-repository\n    * @param {Object} [options] - the filtering options for commits\n    * @param {string} [options.sha] - the SHA or branch to start from\n    * @param {string} [options.path] - the path to search on\n    * @param {string} [options.author] - the commit author\n    * @param {(Date|string)} [options.since] - only commits after this date will be returned\n    * @param {(Date|string)} [options.until] - only commits before this date will be returned\n    * @param {Requestable.callback} cb - will receive the list of commits found matching the criteria\n    * @return {Promise} - the promise for the http request\n    */\n   listCommits(options, cb) {\n      options = options || {};\n\n      options.since = this._dateToISO(options.since);\n      options.until = this._dateToISO(options.until);\n\n      return this._request('GET', `/repos/${this.__fullname}/commits`, options, cb);\n   }\n\n    /**\n     * Gets a single commit information for a repository\n     * @see https://developer.github.com/v3/repos/commits/#get-a-single-commit\n     * @param {string} ref - the reference for the commit-ish\n     * @param {Requestable.callback} cb - will receive the commit information\n     * @return {Promise} - the promise for the http request\n     */\n   getSingleCommit(ref, cb) {\n      ref = ref || '';\n      return this._request('GET', `/repos/${this.__fullname}/commits/${ref}`, null, cb);\n   }\n\n   /**\n    * Get tha sha for a particular object in the repository. This is a convenience function\n    * @see https://developer.github.com/v3/repos/contents/#get-contents\n    * @param {string} [branch] - the branch to look in, or the repository's default branch if omitted\n    * @param {string} path - the path of the file or directory\n    * @param {Requestable.callback} cb - will receive a description of the requested object, including a `SHA` property\n    * @return {Promise} - the promise for the http request\n    */\n   getSha(branch, path, cb) {\n      branch = branch ? `?ref=${branch}` : '';\n      return this._request('GET', `/repos/${this.__fullname}/contents/${path}${branch}`, null, cb);\n   }\n\n   /**\n    * List the commit statuses for a particular sha, branch, or tag\n    * @see https://developer.github.com/v3/repos/statuses/#list-statuses-for-a-specific-ref\n    * @param {string} sha - the sha, branch, or tag to get statuses for\n    * @param {Requestable.callback} cb - will receive the list of statuses\n    * @return {Promise} - the promise for the http request\n    */\n   listStatuses(sha, cb) {\n      return this._request('GET', `/repos/${this.__fullname}/commits/${sha}/statuses`, null, cb);\n   }\n\n   /**\n    * Get a description of a git tree\n    * @see https://developer.github.com/v3/git/trees/#get-a-tree\n    * @param {string} treeSHA - the SHA of the tree to fetch\n    * @param {Requestable.callback} cb - will receive the callback data\n    * @return {Promise} - the promise for the http request\n    */\n   getTree(treeSHA, cb) {\n      return this._request('GET', `/repos/${this.__fullname}/git/trees/${treeSHA}`, null, cb);\n   }\n\n   /**\n    * Create a blob\n    * @see https://developer.github.com/v3/git/blobs/#create-a-blob\n    * @param {(string|Buffer|Blob)} content - the content to add to the repository\n    * @param {Requestable.callback} cb - will receive the details of the created blob\n    * @return {Promise} - the promise for the http request\n    */\n   createBlob(content, cb) {\n      let postBody = this._getContentObject(content);\n\n      log('sending content', postBody);\n      return this._request('POST', `/repos/${this.__fullname}/git/blobs`, postBody, cb);\n   }\n\n   /**\n    * Get the object that represents the provided content\n    * @param {string|Buffer|Blob} content - the content to send to the server\n    * @return {Object} the representation of `content` for the GitHub API\n    */\n   _getContentObject(content) {\n      if (typeof content === 'string') {\n         log('contet is a string');\n         return {\n            content: Utf8.encode(content),\n            encoding: 'utf-8',\n         };\n\n      } else if (typeof Buffer !== 'undefined' && content instanceof Buffer) {\n         log('We appear to be in Node');\n         return {\n            content: content.toString('base64'),\n            encoding: 'base64',\n         };\n\n      } else if (typeof Blob !== 'undefined' && content instanceof Blob) {\n         log('We appear to be in the browser');\n         return {\n            content: Base64.encode(content),\n            encoding: 'base64',\n         };\n\n      } else { // eslint-disable-line\n         log(`Not sure what this content is: ${typeof content}, ${JSON.stringify(content)}`);\n         throw new Error('Unknown content passed to postBlob. Must be string or Buffer (node) or Blob (web)');\n      }\n   }\n\n   /**\n    * Update a tree in Git\n    * @see https://developer.github.com/v3/git/trees/#create-a-tree\n    * @param {string} baseTreeSHA - the SHA of the tree to update\n    * @param {string} path - the path for the new file\n    * @param {string} blobSHA - the SHA for the blob to put at `path`\n    * @param {Requestable.callback} cb - will receive the new tree that is created\n    * @return {Promise} - the promise for the http request\n    * @deprecated use {@link Repository#createTree} instead\n    */\n   updateTree(baseTreeSHA, path, blobSHA, cb) {\n      let newTree = {\n         base_tree: baseTreeSHA, // eslint-disable-line\n         tree: [{\n            path: path,\n            sha: blobSHA,\n            mode: '100644',\n            type: 'blob',\n         }],\n      };\n\n      return this._request('POST', `/repos/${this.__fullname}/git/trees`, newTree, cb);\n   }\n\n   /**\n    * Create a new tree in git\n    * @see https://developer.github.com/v3/git/trees/#create-a-tree\n    * @param {Object} tree - the tree to create\n    * @param {string} baseSHA - the root sha of the tree\n    * @param {Requestable.callback} cb - will receive the new tree that is created\n    * @return {Promise} - the promise for the http request\n    */\n   createTree(tree, baseSHA, cb) {\n      return this._request('POST', `/repos/${this.__fullname}/git/trees`, {\n         tree,\n         base_tree: baseSHA, // eslint-disable-line camelcase\n      }, cb);\n   }\n\n   /**\n    * Add a commit to the repository\n    * @see https://developer.github.com/v3/git/commits/#create-a-commit\n    * @param {string} parent - the SHA of the parent commit\n    * @param {string} tree - the SHA of the tree for this commit\n    * @param {string} message - the commit message\n    * @param {Requestable.callback} cb - will receive the commit that is created\n    * @return {Promise} - the promise for the http request\n    */\n   commit(parent, tree, message, cb) {\n      let data = {\n         message,\n         tree,\n         parents: [parent],\n      };\n\n      return this._request('POST', `/repos/${this.__fullname}/git/commits`, data, cb)\n         .then((response) => {\n            this.__currentTree.sha = response.data.sha; // Update latest commit\n            return response;\n         });\n   }\n\n   /**\n    * Update a ref\n    * @see https://developer.github.com/v3/git/refs/#update-a-reference\n    * @param {string} ref - the ref to update\n    * @param {string} commitSHA - the SHA to point the reference to\n    * @param {boolean} force - indicates whether to force or ensure a fast-forward update\n    * @param {Requestable.callback} cb - will receive the updated ref back\n    * @return {Promise} - the promise for the http request\n    */\n   updateHead(ref, commitSHA, force, cb) {\n      return this._request('PATCH', `/repos/${this.__fullname}/git/refs/${ref}`, {\n         sha: commitSHA,\n         force: force,\n      }, cb);\n   }\n\n   /**\n    * Update commit status\n    * @see https://developer.github.com/v3/repos/statuses/\n    * @param {string} commitSHA - the SHA of the commit that should be updated\n    * @param {object} options - Commit status parameters\n    * @param {string} options.state - The state of the status. Can be one of: pending, success, error, or failure.\n    * @param {string} [options.target_url] - The target URL to associate with this status.\n    * @param {string} [options.description] - A short description of the status.\n    * @param {string} [options.context] - A string label to differentiate this status among CI systems.\n    * @param {Requestable.callback} cb - will receive the updated commit back\n    * @return {Promise} - the promise for the http request\n    */\n   updateStatus(commitSHA, options, cb) {\n      return this._request('POST', `/repos/${this.__fullname}/statuses/${commitSHA}`, options, cb);\n   }\n\n   /**\n    * Update repository information\n    * @see https://developer.github.com/v3/repos/#edit\n    * @param {object} options - New parameters that will be set to the repository\n    * @param {string} options.name - Name of the repository\n    * @param {string} [options.description] - A short description of the repository\n    * @param {string} [options.homepage] - A URL with more information about the repository\n    * @param {boolean} [options.private] - Either true to make the repository private, or false to make it public.\n    * @param {boolean} [options.has_issues] - Either true to enable issues for this repository, false to disable them.\n    * @param {boolean} [options.has_wiki] - Either true to enable the wiki for this repository, false to disable it.\n    * @param {boolean} [options.has_downloads] - Either true to enable downloads, false to disable them.\n    * @param {string} [options.default_branch] - Updates the default branch for this repository.\n    * @param {Requestable.callback} cb - will receive the updated repository back\n    * @return {Promise} - the promise for the http request\n    */\n   updateRepository(options, cb) {\n      return this._request('PATCH', `/repos/${this.__fullname}`, options, cb);\n   }\n\n  /**\n    * Get information about the repository\n    * @see https://developer.github.com/v3/repos/#get\n    * @param {Requestable.callback} cb - will receive the information about the repository\n    * @return {Promise} - the promise for the http request\n    */\n   getDetails(cb) {\n      return this._request('GET', `/repos/${this.__fullname}`, null, cb);\n   }\n\n   /**\n    * List the contributors to the repository\n    * @see https://developer.github.com/v3/repos/#list-contributors\n    * @param {Requestable.callback} cb - will receive the list of contributors\n    * @return {Promise} - the promise for the http request\n    */\n   getContributors(cb) {\n      return this._request('GET', `/repos/${this.__fullname}/contributors`, null, cb);\n   }\n\n   /**\n    * List the contributor stats to the repository\n    * @see https://developer.github.com/v3/repos/#list-contributors\n    * @param {Requestable.callback} cb - will receive the list of contributors\n    * @return {Promise} - the promise for the http request\n    */\n   getContributorStats(cb) {\n      return this._request('GET', `/repos/${this.__fullname}/stats/contributors`, null, cb);\n   }\n\n   /**\n    * List the users who are collaborators on the repository. The currently authenticated user must have\n    * push access to use this method\n    * @see https://developer.github.com/v3/repos/collaborators/#list-collaborators\n    * @param {Requestable.callback} cb - will receive the list of collaborators\n    * @return {Promise} - the promise for the http request\n    */\n   getCollaborators(cb) {\n      return this._request('GET', `/repos/${this.__fullname}/collaborators`, null, cb);\n   }\n\n   /**\n    * Check if a user is a collaborator on the repository\n    * @see https://developer.github.com/v3/repos/collaborators/#check-if-a-user-is-a-collaborator\n    * @param {string} username - the user to check\n    * @param {Requestable.callback} cb - will receive true if the user is a collaborator and false if they are not\n    * @return {Promise} - the promise for the http request {Boolean} [description]\n    */\n   isCollaborator(username, cb) {\n      return this._request('GET', `/repos/${this.__fullname}/collaborators/${username}`, null, cb);\n   }\n\n   /**\n    * Get the contents of a repository\n    * @see https://developer.github.com/v3/repos/contents/#get-contents\n    * @param {string} ref - the ref to check\n    * @param {string} path - the path containing the content to fetch\n    * @param {boolean} raw - `true` if the results should be returned raw instead of GitHub's normalized format\n    * @param {Requestable.callback} cb - will receive the fetched data\n    * @return {Promise} - the promise for the http request\n    */\n   getContents(ref, path, raw, cb) {\n      path = path ? `${encodeURI(path)}` : '';\n      return this._request('GET', `/repos/${this.__fullname}/contents/${path}`, {\n         ref,\n      }, cb, raw);\n   }\n\n   /**\n    * Get the README of a repository\n    * @see https://developer.github.com/v3/repos/contents/#get-the-readme\n    * @param {string} ref - the ref to check\n    * @param {boolean} raw - `true` if the results should be returned raw instead of GitHub's normalized format\n    * @param {Requestable.callback} cb - will receive the fetched data\n    * @return {Promise} - the promise for the http request\n    */\n   getReadme(ref, raw, cb) {\n      return this._request('GET', `/repos/${this.__fullname}/readme`, {\n         ref,\n      }, cb, raw);\n   }\n\n   /**\n    * Fork a repository\n    * @see https://developer.github.com/v3/repos/forks/#create-a-fork\n    * @param {Requestable.callback} cb - will receive the information about the newly created fork\n    * @return {Promise} - the promise for the http request\n    */\n   fork(cb) {\n      return this._request('POST', `/repos/${this.__fullname}/forks`, null, cb);\n   }\n\n   /**\n    * List a repository's forks\n    * @see https://developer.github.com/v3/repos/forks/#list-forks\n    * @param {Requestable.callback} cb - will receive the list of repositories forked from this one\n    * @return {Promise} - the promise for the http request\n    */\n   listForks(cb) {\n      return this._request('GET', `/repos/${this.__fullname}/forks`, null, cb);\n   }\n\n   /**\n    * Create a new branch from an existing branch.\n    * @param {string} [oldBranch=master] - the name of the existing branch\n    * @param {string} newBranch - the name of the new branch\n    * @param {Requestable.callback} cb - will receive the commit data for the head of the new branch\n    * @return {Promise} - the promise for the http request\n    */\n   createBranch(oldBranch, newBranch, cb) {\n      if (typeof newBranch === 'function') {\n         cb = newBranch;\n         newBranch = oldBranch;\n         oldBranch = 'master';\n      }\n\n      return this.getRef(`heads/${oldBranch}`)\n         .then((response) => {\n            let sha = response.data.object.sha;\n            return this.createRef({\n               sha,\n               ref: `refs/heads/${newBranch}`,\n            }, cb);\n         });\n   }\n\n   /**\n    * Create a new pull request\n    * @see https://developer.github.com/v3/pulls/#create-a-pull-request\n    * @param {Object} options - the pull request description\n    * @param {Requestable.callback} cb - will receive the new pull request\n    * @return {Promise} - the promise for the http request\n    */\n   createPullRequest(options, cb) {\n      return this._request('POST', `/repos/${this.__fullname}/pulls`, options, cb);\n   }\n\n   /**\n    * Update a pull request\n    * @see https://developer.github.com/v3/pulls/#update-a-pull-request\n    * @param {number|string} number - the number of the pull request to update\n    * @param {Object} options - the pull request description\n    * @param {Requestable.callback} [cb] - will receive the pull request information\n    * @return {Promise} - the promise for the http request\n    */\n   updatePullRequest(number, options, cb) {\n      return this._request('PATCH', `/repos/${this.__fullname}/pulls/${number}`, options, cb);\n   }\n\n   /**\n    * List the hooks for the repository\n    * @see https://developer.github.com/v3/repos/hooks/#list-hooks\n    * @param {Requestable.callback} cb - will receive the list of hooks\n    * @return {Promise} - the promise for the http request\n    */\n   listHooks(cb) {\n      return this._request('GET', `/repos/${this.__fullname}/hooks`, null, cb);\n   }\n\n   /**\n    * Get a hook for the repository\n    * @see https://developer.github.com/v3/repos/hooks/#get-single-hook\n    * @param {number} id - the id of the webook\n    * @param {Requestable.callback} cb - will receive the details of the webook\n    * @return {Promise} - the promise for the http request\n    */\n   getHook(id, cb) {\n      return this._request('GET', `/repos/${this.__fullname}/hooks/${id}`, null, cb);\n   }\n\n   /**\n    * Add a new hook to the repository\n    * @see https://developer.github.com/v3/repos/hooks/#create-a-hook\n    * @param {Object} options - the configuration describing the new hook\n    * @param {Requestable.callback} cb - will receive the new webhook\n    * @return {Promise} - the promise for the http request\n    */\n   createHook(options, cb) {\n      return this._request('POST', `/repos/${this.__fullname}/hooks`, options, cb);\n   }\n\n   /**\n    * Edit an existing webhook\n    * @see https://developer.github.com/v3/repos/hooks/#edit-a-hook\n    * @param {number} id - the id of the webhook\n    * @param {Object} options - the new description of the webhook\n    * @param {Requestable.callback} cb - will receive the updated webhook\n    * @return {Promise} - the promise for the http request\n    */\n   updateHook(id, options, cb) {\n      return this._request('PATCH', `/repos/${this.__fullname}/hooks/${id}`, options, cb);\n   }\n\n   /**\n    * Delete a webhook\n    * @see https://developer.github.com/v3/repos/hooks/#delete-a-hook\n    * @param {number} id - the id of the webhook to be deleted\n    * @param {Requestable.callback} cb - will receive true if the call is successful\n    * @return {Promise} - the promise for the http request\n    */\n   deleteHook(id, cb) {\n      return this._request('DELETE', `/repos/${this.__fullname}/hooks/${id}`, null, cb);\n   }\n\n   /**\n    * List the deploy keys for the repository\n    * @see https://developer.github.com/v3/repos/keys/#list-deploy-keys\n    * @param {Requestable.callback} cb - will receive the list of deploy keys\n    * @return {Promise} - the promise for the http request\n    */\n   listKeys(cb) {\n      return this._request('GET', `/repos/${this.__fullname}/keys`, null, cb);\n   }\n\n   /**\n    * Get a deploy key for the repository\n    * @see https://developer.github.com/v3/repos/keys/#get-a-deploy-key\n    * @param {number} id - the id of the deploy key\n    * @param {Requestable.callback} cb - will receive the details of the deploy key\n    * @return {Promise} - the promise for the http request\n    */\n   getKey(id, cb) {\n      return this._request('GET', `/repos/${this.__fullname}/keys/${id}`, null, cb);\n   }\n\n   /**\n    * Add a new deploy key to the repository\n    * @see https://developer.github.com/v3/repos/keys/#add-a-new-deploy-key\n    * @param {Object} options - the configuration describing the new deploy key\n    * @param {Requestable.callback} cb - will receive the new deploy key\n    * @return {Promise} - the promise for the http request\n    */\n   createKey(options, cb) {\n      return this._request('POST', `/repos/${this.__fullname}/keys`, options, cb);\n   }\n\n   /**\n    * Delete a deploy key\n    * @see https://developer.github.com/v3/repos/keys/#remove-a-deploy-key\n    * @param {number} id - the id of the deploy key to be deleted\n    * @param {Requestable.callback} cb - will receive true if the call is successful\n    * @return {Promise} - the promise for the http request\n    */\n   deleteKey(id, cb) {\n      return this._request('DELETE', `/repos/${this.__fullname}/keys/${id}`, null, cb);\n   }\n\n   /**\n    * Delete a file from a branch\n    * @see https://developer.github.com/v3/repos/contents/#delete-a-file\n    * @param {string} branch - the branch to delete from, or the default branch if not specified\n    * @param {string} path - the path of the file to remove\n    * @param {Requestable.callback} cb - will receive the commit in which the delete occurred\n    * @return {Promise} - the promise for the http request\n    */\n   deleteFile(branch, path, cb) {\n      return this.getSha(branch, path)\n         .then((response) => {\n            const deleteCommit = {\n               message: `Delete the file at '${path}'`,\n               sha: response.data.sha,\n               branch,\n            };\n            return this._request('DELETE', `/repos/${this.__fullname}/contents/${path}`, deleteCommit, cb);\n         });\n   }\n\n   /**\n    * Change all references in a repo from oldPath to new_path\n    * @param {string} branch - the branch to carry out the reference change, or the default branch if not specified\n    * @param {string} oldPath - original path\n    * @param {string} newPath - new reference path\n    * @param {Requestable.callback} cb - will receive the commit in which the move occurred\n    * @return {Promise} - the promise for the http request\n    */\n   move(branch, oldPath, newPath, cb) {\n      let oldSha;\n      return this.getRef(`heads/${branch}`)\n         .then(({data: {object}}) => this.getTree(`${object.sha}?recursive=true`))\n         .then(({data: {tree, sha}}) => {\n            oldSha = sha;\n            let newTree = tree.map((ref) => {\n               if (ref.path === oldPath) {\n                  ref.path = newPath;\n               }\n               if (ref.type === 'tree') {\n                  delete ref.sha;\n               }\n               return ref;\n            });\n            return this.createTree(newTree);\n         })\n         .then(({data: tree}) => this.commit(oldSha, tree.sha, `Renamed '${oldPath}' to '${newPath}'`))\n         .then(({data: commit}) => this.updateHead(`heads/${branch}`, commit.sha, true, cb));\n   }\n\n   /**\n    * Write a file to the repository\n    * @see https://developer.github.com/v3/repos/contents/#update-a-file\n    * @param {string} branch - the name of the branch\n    * @param {string} path - the path for the file\n    * @param {string} content - the contents of the file\n    * @param {string} message - the commit message\n    * @param {Object} [options] - commit options\n    * @param {Object} [options.author] - the author of the commit\n    * @param {Object} [options.commiter] - the committer\n    * @param {boolean} [options.encode] - true if the content should be base64 encoded\n    * @param {Requestable.callback} cb - will receive the new commit\n    * @return {Promise} - the promise for the http request\n    */\n   writeFile(branch, path, content, message, options, cb) {\n      if (typeof options === 'function') {\n         cb = options;\n         options = {};\n      }\n      let filePath = path ? encodeURI(path) : '';\n      let shouldEncode = options.encode !== false;\n      let commit = {\n         branch,\n         message,\n         author: options.author,\n         committer: options.committer,\n         content: shouldEncode ? Base64.encode(content) : content,\n      };\n\n      return this.getSha(branch, filePath)\n         .then((response) => {\n            commit.sha = response.data.sha;\n            return this._request('PUT', `/repos/${this.__fullname}/contents/${filePath}`, commit, cb);\n         }, () => {\n            return this._request('PUT', `/repos/${this.__fullname}/contents/${filePath}`, commit, cb);\n         });\n   }\n\n   /**\n    * Check if a repository is starred by you\n    * @see https://developer.github.com/v3/activity/starring/#check-if-you-are-starring-a-repository\n    * @param {Requestable.callback} cb - will receive true if the repository is starred and false if the repository\n    *                                  is not starred\n    * @return {Promise} - the promise for the http request {Boolean} [description]\n    */\n   isStarred(cb) {\n      return this._request204or404(`/user/starred/${this.__fullname}`, null, cb);\n   }\n\n   /**\n    * Star a repository\n    * @see https://developer.github.com/v3/activity/starring/#star-a-repository\n    * @param {Requestable.callback} cb - will receive true if the repository is starred\n    * @return {Promise} - the promise for the http request\n    */\n   star(cb) {\n      return this._request('PUT', `/user/starred/${this.__fullname}`, null, cb);\n   }\n\n   /**\n    * Unstar a repository\n    * @see https://developer.github.com/v3/activity/starring/#unstar-a-repository\n    * @param {Requestable.callback} cb - will receive true if the repository is unstarred\n    * @return {Promise} - the promise for the http request\n    */\n   unstar(cb) {\n      return this._request('DELETE', `/user/starred/${this.__fullname}`, null, cb);\n   }\n\n   /**\n    * Create a new release\n    * @see https://developer.github.com/v3/repos/releases/#create-a-release\n    * @param {Object} options - the description of the release\n    * @param {Requestable.callback} cb - will receive the newly created release\n    * @return {Promise} - the promise for the http request\n    */\n   createRelease(options, cb) {\n      return this._request('POST', `/repos/${this.__fullname}/releases`, options, cb);\n   }\n\n   /**\n    * Edit a release\n    * @see https://developer.github.com/v3/repos/releases/#edit-a-release\n    * @param {string} id - the id of the release\n    * @param {Object} options - the description of the release\n    * @param {Requestable.callback} cb - will receive the modified release\n    * @return {Promise} - the promise for the http request\n    */\n   updateRelease(id, options, cb) {\n      return this._request('PATCH', `/repos/${this.__fullname}/releases/${id}`, options, cb);\n   }\n\n   /**\n    * Get information about all releases\n    * @see https://developer.github.com/v3/repos/releases/#list-releases-for-a-repository\n    * @param {Requestable.callback} cb - will receive the release information\n    * @return {Promise} - the promise for the http request\n    */\n   listReleases(cb) {\n      return this._request('GET', `/repos/${this.__fullname}/releases`, null, cb);\n   }\n\n   /**\n    * Get information about a release\n    * @see https://developer.github.com/v3/repos/releases/#get-a-single-release\n    * @param {string} id - the id of the release\n    * @param {Requestable.callback} cb - will receive the release information\n    * @return {Promise} - the promise for the http request\n    */\n   getRelease(id, cb) {\n      return this._request('GET', `/repos/${this.__fullname}/releases/${id}`, null, cb);\n   }\n\n   /**\n    * Delete a release\n    * @see https://developer.github.com/v3/repos/releases/#delete-a-release\n    * @param {string} id - the release to be deleted\n    * @param {Requestable.callback} cb - will receive true if the operation is successful\n    * @return {Promise} - the promise for the http request\n    */\n   deleteRelease(id, cb) {\n      return this._request('DELETE', `/repos/${this.__fullname}/releases/${id}`, null, cb);\n   }\n\n   /**\n    * Merge a pull request\n    * @see https://developer.github.com/v3/pulls/#merge-a-pull-request-merge-button\n    * @param {number|string} number - the number of the pull request to merge\n    * @param {Object} options - the merge options for the pull request\n    * @param {Requestable.callback} [cb] - will receive the merge information if the operation is successful\n    * @return {Promise} - the promise for the http request\n    */\n   mergePullRequest(number, options, cb) {\n      return this._request('PUT', `/repos/${this.__fullname}/pulls/${number}/merge`, options, cb);\n   }\n\n   /**\n    * Get information about all projects\n    * @see https://developer.github.com/v3/projects/#list-repository-projects\n    * @param {Requestable.callback} [cb] - will receive the list of projects\n    * @return {Promise} - the promise for the http request\n    */\n   listProjects(cb) {\n      return this._requestAllPages(`/repos/${this.__fullname}/projects`, {AcceptHeader: 'inertia-preview'}, cb);\n   }\n\n   /**\n    * Create a new project\n    * @see https://developer.github.com/v3/projects/#create-a-repository-project\n    * @param {Object} options - the description of the project\n    * @param {Requestable.callback} cb - will receive the newly created project\n    * @return {Promise} - the promise for the http request\n    */\n   createProject(options, cb) {\n      options = options || {};\n      options.AcceptHeader = 'inertia-preview';\n      return this._request('POST', `/repos/${this.__fullname}/projects`, options, cb);\n   }\n\n}\n\nmodule.exports = Repository;\n","/**\n * @file\n * @copyright  2016 Yahoo Inc.\n * @license    Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n *             Github.js is freely distributable.\n */\n\nimport axios from 'axios';\nimport debug from 'debug';\nimport {Base64} from 'js-base64';\n\nconst log = debug('github:request');\n\n/**\n * The error structure returned when a network call fails\n */\nclass ResponseError extends Error {\n   /**\n    * Construct a new ResponseError\n    * @param {string} message - an message to return instead of the the default error message\n    * @param {string} path - the requested path\n    * @param {Object} response - the object returned by Axios\n    */\n   constructor(message, path, response) {\n      super(message);\n      this.path = path;\n      this.request = response.config;\n      this.response = (response || {}).response || response;\n      this.status = response.status;\n   }\n}\n\n/**\n * Requestable wraps the logic for making http requests to the API\n */\nclass Requestable {\n   /**\n    * Either a username and password or an oauth token for Github\n    * @typedef {Object} Requestable.auth\n    * @prop {string} [username] - the Github username\n    * @prop {string} [password] - the user's password\n    * @prop {token} [token] - an OAuth token\n    */\n   /**\n    * Initialize the http internals.\n    * @param {Requestable.auth} [auth] - the credentials to authenticate to Github. If auth is\n    *                                  not provided request will be made unauthenticated\n    * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n    * @param {string} [AcceptHeader=v3] - the accept header for the requests\n    */\n   constructor(auth, apiBase, AcceptHeader) {\n      this.__apiBase = apiBase || 'https://api.github.com';\n      this.__auth = {\n         token: auth.token,\n         username: auth.username,\n         password: auth.password,\n      };\n      this.__AcceptHeader = AcceptHeader || 'v3';\n\n      if (auth.token) {\n         this.__authorizationHeader = 'token ' + auth.token;\n      } else if (auth.username && auth.password) {\n         this.__authorizationHeader = 'Basic ' + Base64.encode(auth.username + ':' + auth.password);\n      }\n   }\n\n   /**\n    * Compute the URL to use to make a request.\n    * @private\n    * @param {string} path - either a URL relative to the API base or an absolute URL\n    * @return {string} - the URL to use\n    */\n   __getURL(path) {\n      let url = path;\n\n      if (path.indexOf('//') === -1) {\n         url = this.__apiBase + path;\n      }\n\n      let newCacheBuster = 'timestamp=' + new Date().getTime();\n      return url.replace(/(timestamp=\\d+)/, newCacheBuster);\n   }\n\n   /**\n    * Compute the headers required for an API request.\n    * @private\n    * @param {boolean} raw - if the request should be treated as JSON or as a raw request\n    * @param {string} AcceptHeader - the accept header for the request\n    * @return {Object} - the headers to use in the request\n    */\n   __getRequestHeaders(raw, AcceptHeader) {\n      let headers = {\n         'Content-Type': 'application/json;charset=UTF-8',\n         'Accept': 'application/vnd.github.' + (AcceptHeader || this.__AcceptHeader),\n      };\n\n      if (raw) {\n         headers.Accept += '.raw';\n      }\n      headers.Accept += '+json';\n\n      if (this.__authorizationHeader) {\n         headers.Authorization = this.__authorizationHeader;\n      }\n\n      return headers;\n   }\n\n   /**\n    * Sets the default options for API requests\n    * @protected\n    * @param {Object} [requestOptions={}] - the current options for the request\n    * @return {Object} - the options to pass to the request\n    */\n   _getOptionsWithDefaults(requestOptions = {}) {\n      if (!(requestOptions.visibility || requestOptions.affiliation)) {\n         requestOptions.type = requestOptions.type || 'all';\n      }\n      requestOptions.sort = requestOptions.sort || 'updated';\n      requestOptions.per_page = requestOptions.per_page || '100'; // eslint-disable-line\n\n      return requestOptions;\n   }\n\n   /**\n    * if a `Date` is passed to this function it will be converted to an ISO string\n    * @param {*} date - the object to attempt to cooerce into an ISO date string\n    * @return {string} - the ISO representation of `date` or whatever was passed in if it was not a date\n    */\n   _dateToISO(date) {\n      if (date && (date instanceof Date)) {\n         date = date.toISOString();\n      }\n\n      return date;\n   }\n\n   /**\n    * A function that receives the result of the API request.\n    * @callback Requestable.callback\n    * @param {Requestable.Error} error - the error returned by the API or `null`\n    * @param {(Object|true)} result - the data returned by the API or `true` if the API returns `204 No Content`\n    * @param {Object} request - the raw {@linkcode https://github.com/mzabriskie/axios#response-schema Response}\n    */\n   /**\n    * Make a request.\n    * @param {string} method - the method for the request (GET, PUT, POST, DELETE)\n    * @param {string} path - the path for the request\n    * @param {*} [data] - the data to send to the server. For HTTP methods that don't have a body the data\n    *                   will be sent as query parameters\n    * @param {Requestable.callback} [cb] - the callback for the request\n    * @param {boolean} [raw=false] - if the request should be sent as raw. If this is a falsy value then the\n    *                              request will be made as JSON\n    * @return {Promise} - the Promise for the http request\n    */\n   _request(method, path, data, cb, raw) {\n      const url = this.__getURL(path);\n\n      const AcceptHeader = (data || {}).AcceptHeader;\n      if (AcceptHeader) {\n         delete data.AcceptHeader;\n      }\n      const headers = this.__getRequestHeaders(raw, AcceptHeader);\n\n      let queryParams = {};\n\n      const shouldUseDataAsParams = data && (typeof data === 'object') && methodHasNoBody(method);\n      if (shouldUseDataAsParams) {\n         queryParams = data;\n         data = undefined;\n      }\n\n      const config = {\n         url: url,\n         method: method,\n         headers: headers,\n         params: queryParams,\n         data: data,\n         responseType: raw ? 'text' : 'json',\n      };\n\n      log(`${config.method} to ${config.url}`);\n      const requestPromise = axios(config).catch(callbackErrorOrThrow(cb, path));\n\n      if (cb) {\n         requestPromise.then((response) => {\n            if (response.data && Object.keys(response.data).length > 0) {\n               // When data has results\n               cb(null, response.data, response);\n            } else if (config.method !== 'GET' && Object.keys(response.data).length < 1) {\n               // True when successful submit a request and receive a empty object\n               cb(null, (response.status < 300), response);\n            } else {\n               cb(null, response.data, response);\n            }\n         });\n      }\n\n      return requestPromise;\n   }\n\n   /**\n    * Make a request to an endpoint the returns 204 when true and 404 when false\n    * @param {string} path - the path to request\n    * @param {Object} data - any query parameters for the request\n    * @param {Requestable.callback} cb - the callback that will receive `true` or `false`\n    * @param {method} [method=GET] - HTTP Method to use\n    * @return {Promise} - the promise for the http request\n    */\n   _request204or404(path, data, cb, method = 'GET') {\n      return this._request(method, path, data)\n         .then(function success(response) {\n            if (cb) {\n               cb(null, true, response);\n            }\n            return true;\n         }, function failure(response) {\n            if (response.response.status === 404) {\n               if (cb) {\n                  cb(null, false, response);\n               }\n               return false;\n            }\n\n            if (cb) {\n               cb(response);\n            }\n            throw response;\n         });\n   }\n\n   /**\n    * Make a request and fetch all the available data. Github will paginate responses so for queries\n    * that might span multiple pages this method is preferred to {@link Requestable#request}\n    * @param {string} path - the path to request\n    * @param {Object} options - the query parameters to include\n    * @param {Requestable.callback} [cb] - the function to receive the data. The returned data will always be an array.\n    * @param {Object[]} results - the partial results. This argument is intended for interal use only.\n    * @return {Promise} - a promise which will resolve when all pages have been fetched\n    * @deprecated This will be folded into {@link Requestable#_request} in the 2.0 release.\n    */\n   _requestAllPages(path, options, cb, results) {\n      results = results || [];\n\n      return this._request('GET', path, options)\n         .then((response) => {\n            let thisGroup;\n            if (response.data instanceof Array) {\n               thisGroup = response.data;\n            } else if (response.data.items instanceof Array) {\n               thisGroup = response.data.items;\n            } else {\n               let message = `cannot figure out how to append ${response.data} to the result set`;\n               throw new ResponseError(message, path, response);\n            }\n            results.push(...thisGroup);\n\n            const nextUrl = getNextPage(response.headers.link);\n            if (nextUrl && typeof options.page !== 'number') {\n               log(`getting next page: ${nextUrl}`);\n               return this._requestAllPages(nextUrl, options, cb, results);\n            }\n\n            if (cb) {\n               cb(null, results, response);\n            }\n\n            response.data = results;\n            return response;\n         }).catch(callbackErrorOrThrow(cb, path));\n   }\n}\n\nmodule.exports = Requestable;\n\n// ////////////////////////// //\n//  Private helper functions  //\n// ////////////////////////// //\nconst METHODS_WITH_NO_BODY = ['GET', 'HEAD', 'DELETE'];\nfunction methodHasNoBody(method) {\n   return METHODS_WITH_NO_BODY.indexOf(method) !== -1;\n}\n\nfunction getNextPage(linksHeader = '') {\n   const links = linksHeader.split(/\\s*,\\s*/); // splits and strips the urls\n   return links.reduce(function(nextUrl, link) {\n      if (link.search(/rel=\"next\"/) !== -1) {\n         return (link.match(/<(.*)>/) || [])[1];\n      }\n\n      return nextUrl;\n   }, undefined);\n}\n\nfunction callbackErrorOrThrow(cb, path) {\n   return function handler(object) {\n      let error;\n      if (object.hasOwnProperty('config')) {\n         const {response: {status, statusText}, config: {method, url}} = object;\n         let message = (`${status} error making request ${method} ${url}: \"${statusText}\"`);\n         error = new ResponseError(message, path, object);\n         log(`${message} ${JSON.stringify(object.data)}`);\n      } else {\n         error = object;\n      }\n      if (cb) {\n         log('going to error callback');\n         cb(error);\n      } else {\n         log('throwing error');\n         throw error;\n      }\n   };\n}\n","/**\n * @file\n * @copyright  2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license    Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n *             Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\nimport debug from 'debug';\nconst log = debug('github:search');\n\n/**\n * Wrap the Search API\n */\nclass Search extends Requestable {\n   /**\n    * Create a Search\n    * @param {Object} defaults - defaults for the search\n    * @param {Requestable.auth} [auth] - information required to authenticate to Github\n    * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n    */\n   constructor(defaults, auth, apiBase) {\n      super(auth, apiBase);\n      this.__defaults = this._getOptionsWithDefaults(defaults);\n   }\n\n   /**\n    * Available search options\n    * @see https://developer.github.com/v3/search/#parameters\n    * @typedef {Object} Search.Params\n    * @param {string} q - the query to make\n    * @param {string} sort - the sort field, one of `stars`, `forks`, or `updated`.\n    *                      Default is [best match](https://developer.github.com/v3/search/#ranking-search-results)\n    * @param {string} order - the ordering, either `asc` or `desc`\n    */\n   /**\n    * Perform a search on the GitHub API\n    * @private\n    * @param {string} path - the scope of the search\n    * @param {Search.Params} [withOptions] - additional parameters for the search\n    * @param {Requestable.callback} [cb] - will receive the results of the search\n    * @return {Promise} - the promise for the http request\n    */\n   _search(path, withOptions = {}, cb = undefined) {\n      let requestOptions = {};\n      Object.keys(this.__defaults).forEach((prop) => {\n         requestOptions[prop] = this.__defaults[prop];\n      });\n      Object.keys(withOptions).forEach((prop) => {\n         requestOptions[prop] = withOptions[prop];\n      });\n\n      log(`searching ${path} with options:`, requestOptions);\n      return this._requestAllPages(`/search/${path}`, requestOptions, cb);\n   }\n\n   /**\n    * Search for repositories\n    * @see https://developer.github.com/v3/search/#search-repositories\n    * @param {Search.Params} [options] - additional parameters for the search\n    * @param {Requestable.callback} [cb] - will receive the results of the search\n    * @return {Promise} - the promise for the http request\n    */\n   forRepositories(options, cb) {\n      return this._search('repositories', options, cb);\n   }\n\n   /**\n    * Search for code\n    * @see https://developer.github.com/v3/search/#search-code\n    * @param {Search.Params} [options] - additional parameters for the search\n    * @param {Requestable.callback} [cb] - will receive the results of the search\n    * @return {Promise} - the promise for the http request\n    */\n   forCode(options, cb) {\n      return this._search('code', options, cb);\n   }\n\n   /**\n    * Search for issues\n    * @see https://developer.github.com/v3/search/#search-issues\n    * @param {Search.Params} [options] - additional parameters for the search\n    * @param {Requestable.callback} [cb] - will receive the results of the search\n    * @return {Promise} - the promise for the http request\n    */\n   forIssues(options, cb) {\n      return this._search('issues', options, cb);\n   }\n\n   /**\n    * Search for users\n    * @see https://developer.github.com/v3/search/#search-users\n    * @param {Search.Params} [options] - additional parameters for the search\n    * @param {Requestable.callback} [cb] - will receive the results of the search\n    * @return {Promise} - the promise for the http request\n    */\n   forUsers(options, cb) {\n      return this._search('users', options, cb);\n   }\n}\n\nmodule.exports = Search;\n","/**\n * @file\n * @copyright  2016 Matt Smith (Development Seed)\n * @license    Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n *             Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\nimport debug from 'debug';\nconst log = debug('github:team');\n\n/**\n * A Team allows scoping of API requests to a particular Github Organization Team.\n */\nclass Team extends Requestable {\n   /**\n    * Create a Team.\n    * @param {string} [teamId] - the id for the team\n    * @param {Requestable.auth} [auth] - information required to authenticate to Github\n    * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n    */\n   constructor(teamId, auth, apiBase) {\n      super(auth, apiBase);\n      this.__teamId = teamId;\n   }\n\n   /**\n    * Get Team information\n    * @see https://developer.github.com/v3/orgs/teams/#get-team\n    * @param {Requestable.callback} [cb] - will receive the team\n    * @return {Promise} - the promise for the http request\n    */\n   getTeam(cb) {\n      log(`Fetching Team ${this.__teamId}`);\n      return this._request('Get', `/teams/${this.__teamId}`, undefined, cb);\n   }\n\n   /**\n    * List the Team's repositories\n    * @see https://developer.github.com/v3/orgs/teams/#list-team-repos\n    * @param {Requestable.callback} [cb] - will receive the list of repositories\n    * @return {Promise} - the promise for the http request\n    */\n   listRepos(cb) {\n      log(`Fetching repositories for Team ${this.__teamId}`);\n      return this._requestAllPages(`/teams/${this.__teamId}/repos`, undefined, cb);\n   }\n\n   /**\n    * Edit Team information\n    * @see https://developer.github.com/v3/orgs/teams/#edit-team\n    * @param {object} options - Parameters for team edit\n    * @param {string} options.name - The name of the team\n    * @param {string} [options.description] - Team description\n    * @param {string} [options.repo_names] - Repos to add the team to\n    * @param {string} [options.privacy=secret] - The level of privacy the team should have. Can be either one\n    * of: `secret`, or `closed`\n    * @param {Requestable.callback} [cb] - will receive the updated team\n    * @return {Promise} - the promise for the http request\n    */\n   editTeam(options, cb) {\n      log(`Editing Team ${this.__teamId}`);\n      return this._request('PATCH', `/teams/${this.__teamId}`, options, cb);\n   }\n\n   /**\n    * List the users who are members of the Team\n    * @see https://developer.github.com/v3/orgs/teams/#list-team-members\n    * @param {object} options - Parameters for listing team users\n    * @param {string} [options.role=all] - can be one of: `all`, `maintainer`, or `member`\n    * @param {Requestable.callback} [cb] - will receive the list of users\n    * @return {Promise} - the promise for the http request\n    */\n   listMembers(options, cb) {\n      log(`Getting members of Team ${this.__teamId}`);\n      return this._requestAllPages(`/teams/${this.__teamId}/members`, options, cb);\n   }\n\n   /**\n    * Get Team membership status for a user\n    * @see https://developer.github.com/v3/orgs/teams/#get-team-membership\n    * @param {string} username - can be one of: `all`, `maintainer`, or `member`\n    * @param {Requestable.callback} [cb] - will receive the membership status of a user\n    * @return {Promise} - the promise for the http request\n    */\n   getMembership(username, cb) {\n      log(`Getting membership of user ${username} in Team ${this.__teamId}`);\n      return this._request('GET', `/teams/${this.__teamId}/memberships/${username}`, undefined, cb);\n   }\n\n   /**\n    * Add a member to the Team\n    * @see https://developer.github.com/v3/orgs/teams/#add-team-membership\n    * @param {string} username - can be one of: `all`, `maintainer`, or `member`\n    * @param {object} options - Parameters for adding a team member\n    * @param {string} [options.role=member] - The role that this user should have in the team. Can be one\n    * of: `member`, or `maintainer`\n    * @param {Requestable.callback} [cb] - will receive the membership status of added user\n    * @return {Promise} - the promise for the http request\n    */\n   addMembership(username, options, cb) {\n      log(`Adding user ${username} to Team ${this.__teamId}`);\n      return this._request('PUT', `/teams/${this.__teamId}/memberships/${username}`, options, cb);\n   }\n\n   /**\n    * Get repo management status for team\n    * @see https://developer.github.com/v3/orgs/teams/#remove-team-membership\n    * @param {string} owner - Organization name\n    * @param {string} repo - Repo name\n    * @param {Requestable.callback} [cb] - will receive the membership status of added user\n    * @return {Promise} - the promise for the http request\n    */\n   isManagedRepo(owner, repo, cb) {\n      log(`Getting repo management by Team ${this.__teamId} for repo ${owner}/${repo}`);\n      return this._request204or404(`/teams/${this.__teamId}/repos/${owner}/${repo}`, undefined, cb);\n   }\n\n   /**\n    * Add or Update repo management status for team\n    * @see https://developer.github.com/v3/orgs/teams/#add-or-update-team-repository\n    * @param {string} owner - Organization name\n    * @param {string} repo - Repo name\n    * @param {object} options - Parameters for adding or updating repo management for the team\n    * @param {string} [options.permission] - The permission to grant the team on this repository. Can be one\n    * of: `pull`, `push`, or `admin`\n    * @param {Requestable.callback} [cb] - will receive the membership status of added user\n    * @return {Promise} - the promise for the http request\n    */\n   manageRepo(owner, repo, options, cb) {\n      log(`Adding or Updating repo management by Team ${this.__teamId} for repo ${owner}/${repo}`);\n      return this._request204or404(`/teams/${this.__teamId}/repos/${owner}/${repo}`, options, cb, 'PUT');\n   }\n\n   /**\n    * Remove repo management status for team\n    * @see https://developer.github.com/v3/orgs/teams/#remove-team-repository\n    * @param {string} owner - Organization name\n    * @param {string} repo - Repo name\n    * @param {Requestable.callback} [cb] - will receive the membership status of added user\n    * @return {Promise} - the promise for the http request\n    */\n   unmanageRepo(owner, repo, cb) {\n      log(`Remove repo management by Team ${this.__teamId} for repo ${owner}/${repo}`);\n      return this._request204or404(`/teams/${this.__teamId}/repos/${owner}/${repo}`, undefined, cb, 'DELETE');\n   }\n\n   /**\n    * Delete Team\n    * @see https://developer.github.com/v3/orgs/teams/#delete-team\n    * @param {Requestable.callback} [cb] - will receive the list of repositories\n    * @return {Promise} - the promise for the http request\n    */\n   deleteTeam(cb) {\n      log(`Deleting Team ${this.__teamId}`);\n      return this._request204or404(`/teams/${this.__teamId}`, undefined, cb, 'DELETE');\n   }\n}\n\nmodule.exports = Team;\n","/**\n * @file\n * @copyright  2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license    Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n *             Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\nimport debug from 'debug';\nconst log = debug('github:user');\n\n/**\n * A User allows scoping of API requests to a particular Github user.\n */\nclass User extends Requestable {\n   /**\n    * Create a User.\n    * @param {string} [username] - the user to use for user-scoped queries\n    * @param {Requestable.auth} [auth] - information required to authenticate to Github\n    * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n    */\n   constructor(username, auth, apiBase) {\n      super(auth, apiBase);\n      this.__user = username;\n   }\n\n   /**\n    * Get the url for the request. (dependent on if we're requesting for the authenticated user or not)\n    * @private\n    * @param {string} endpoint - the endpoint being requested\n    * @return {string} - the resolved endpoint\n    */\n   __getScopedUrl(endpoint) {\n      if (this.__user) {\n         return endpoint ?\n            `/users/${this.__user}/${endpoint}` :\n            `/users/${this.__user}`\n            ;\n\n      } else { // eslint-disable-line\n         switch (endpoint) {\n            case '':\n               return '/user';\n\n            case 'notifications':\n            case 'gists':\n               return `/${endpoint}`;\n\n            default:\n               return `/user/${endpoint}`;\n         }\n      }\n   }\n\n   /**\n    * List the user's repositories\n    * @see https://developer.github.com/v3/repos/#list-user-repositories\n    * @param {Object} [options={}] - any options to refine the search\n    * @param {Requestable.callback} [cb] - will receive the list of repositories\n    * @return {Promise} - the promise for the http request\n    */\n   listRepos(options, cb) {\n      if (typeof options === 'function') {\n         cb = options;\n         options = {};\n      }\n\n      options = this._getOptionsWithDefaults(options);\n\n      log(`Fetching repositories with options: ${JSON.stringify(options)}`);\n      return this._requestAllPages(this.__getScopedUrl('repos'), options, cb);\n   }\n\n   /**\n    * List the orgs that the user belongs to\n    * @see https://developer.github.com/v3/orgs/#list-user-organizations\n    * @param {Requestable.callback} [cb] - will receive the list of organizations\n    * @return {Promise} - the promise for the http request\n    */\n   listOrgs(cb) {\n      return this._request('GET', this.__getScopedUrl('orgs'), null, cb);\n   }\n\n   /**\n    * List the user's gists\n    * @see https://developer.github.com/v3/gists/#list-a-users-gists\n    * @param {Requestable.callback} [cb] - will receive the list of gists\n    * @return {Promise} - the promise for the http request\n    */\n   listGists(cb) {\n      return this._request('GET', this.__getScopedUrl('gists'), null, cb);\n   }\n\n   /**\n    * List the user's starred gists\n    * @see https://developer.github.com/v3/gists/#list-starred-gists\n    * @param {Requestable.callback} [cb] - will receive the list of gists\n    * @return {Promise} - the promise for the http request\n    */\n   listStarredGists(cb) {\n      return this._request('GET', this.__getScopedUrl('gists/starred'), null, cb);\n   }\n\n   /**\n    * List the user's gists\n    * @see https://developer.github.com/v3/gists/#list-a-users-gists\n    * @param {Requestable.callback} [cb] - will receive the list of gists\n    * @return {Promise} - the promise for the http request\n    */\n   listStarredGists(cb) {\n      return this._request('GET', this.__getScopedUrl('gists'), null, cb);\n   }\n\n   /**\n    * List the user's notifications\n    * @see https://developer.github.com/v3/activity/notifications/#list-your-notifications\n    * @param {Object} [options={}] - any options to refine the search\n    * @param {Requestable.callback} [cb] - will receive the list of repositories\n    * @return {Promise} - the promise for the http request\n    */\n   listNotifications(options, cb) {\n      options = options || {};\n      if (typeof options === 'function') {\n         cb = options;\n         options = {};\n      }\n\n      options.since = this._dateToISO(options.since);\n      options.before = this._dateToISO(options.before);\n\n      return this._request('GET', this.__getScopedUrl('notifications'), options, cb);\n   }\n\n   /**\n    * Show the user's profile\n    * @see https://developer.github.com/v3/users/#get-a-single-user\n    * @param {Requestable.callback} [cb] - will receive the user's information\n    * @return {Promise} - the promise for the http request\n    */\n   getProfile(cb) {\n      return this._request('GET', this.__getScopedUrl(''), null, cb);\n   }\n\n   /**\n    * Gets the list of starred repositories for the user\n    * @see https://developer.github.com/v3/activity/starring/#list-repositories-being-starred\n    * @param {Requestable.callback} [cb] - will receive the list of starred repositories\n    * @return {Promise} - the promise for the http request\n    */\n   listStarredRepos(cb) {\n      let requestOptions = this._getOptionsWithDefaults();\n      return this._requestAllPages(this.__getScopedUrl('starred'), requestOptions, cb);\n   }\n\n   /**\n    * List email addresses for a user\n    * @see https://developer.github.com/v3/users/emails/#list-email-addresses-for-a-user\n    * @param {Requestable.callback} [cb] - will receive the list of emails\n    * @return {Promise} - the promise for the http request\n    */\n   getEmails(cb) {\n      return this._request('GET', '/user/emails', null, cb);\n   }\n\n   /**\n    * Have the authenticated user follow this user\n    * @see https://developer.github.com/v3/users/followers/#follow-a-user\n    * @param {string} username - the user to follow\n    * @param {Requestable.callback} [cb] - will receive true if the request succeeds\n    * @return {Promise} - the promise for the http request\n    */\n   follow(username, cb) {\n      return this._request('PUT', `/user/following/${this.__user}`, null, cb);\n   }\n\n   /**\n    * Have the currently authenticated user unfollow this user\n    * @see https://developer.github.com/v3/users/followers/#follow-a-user\n    * @param {string} username - the user to unfollow\n    * @param {Requestable.callback} [cb] - receives true if the request succeeds\n    * @return {Promise} - the promise for the http request\n    */\n   unfollow(username, cb) {\n      return this._request('DELETE', `/user/following/${this.__user}`, null, cb);\n   }\n\n   /**\n    * Create a new repository for the currently authenticated user\n    * @see https://developer.github.com/v3/repos/#create\n    * @param {object} options - the repository definition\n    * @param {Requestable.callback} [cb] - will receive the API response\n    * @return {Promise} - the promise for the http request\n    */\n   createRepo(options, cb) {\n      return this._request('POST', '/user/repos', options, cb);\n   }\n}\n\nmodule.exports = User;\n","module.exports = require('./lib/axios');","'use strict';\n\nvar utils = require('./../utils');\nvar settle = require('./../core/settle');\nvar buildURL = require('./../helpers/buildURL');\nvar parseHeaders = require('./../helpers/parseHeaders');\nvar isURLSameOrigin = require('./../helpers/isURLSameOrigin');\nvar createError = require('../core/createError');\nvar btoa = (typeof window !== 'undefined' && window.btoa && window.btoa.bind(window)) || require('./../helpers/btoa');\n\nmodule.exports = function xhrAdapter(config) {\n  return new Promise(function dispatchXhrRequest(resolve, reject) {\n    var requestData = config.data;\n    var requestHeaders = config.headers;\n\n    if (utils.isFormData(requestData)) {\n      delete requestHeaders['Content-Type']; // Let the browser set it\n    }\n\n    var request = new XMLHttpRequest();\n    var loadEvent = 'onreadystatechange';\n    var xDomain = false;\n\n    // For IE 8/9 CORS support\n    // Only supports POST and GET calls and doesn't returns the response headers.\n    // DON'T do this for testing b/c XMLHttpRequest is mocked, not XDomainRequest.\n    if (process.env.NODE_ENV !== 'test' &&\n        typeof window !== 'undefined' &&\n        window.XDomainRequest && !('withCredentials' in request) &&\n        !isURLSameOrigin(config.url)) {\n      request = new window.XDomainRequest();\n      loadEvent = 'onload';\n      xDomain = true;\n      request.onprogress = function handleProgress() {};\n      request.ontimeout = function handleTimeout() {};\n    }\n\n    // HTTP basic authentication\n    if (config.auth) {\n      var username = config.auth.username || '';\n      var password = config.auth.password || '';\n      requestHeaders.Authorization = 'Basic ' + btoa(username + ':' + password);\n    }\n\n    request.open(config.method.toUpperCase(), buildURL(config.url, config.params, config.paramsSerializer), true);\n\n    // Set the request timeout in MS\n    request.timeout = config.timeout;\n\n    // Listen for ready state\n    request[loadEvent] = function handleLoad() {\n      if (!request || (request.readyState !== 4 && !xDomain)) {\n        return;\n      }\n\n      // The request errored out and we didn't get a response, this will be\n      // handled by onerror instead\n      // With one exception: request that using file: protocol, most browsers\n      // will return status as 0 even though it's a successful request\n      if (request.status === 0 && !(request.responseURL && request.responseURL.indexOf('file:') === 0)) {\n        return;\n      }\n\n      // Prepare the response\n      var responseHeaders = 'getAllResponseHeaders' in request ? parseHeaders(request.getAllResponseHeaders()) : null;\n      var responseData = !config.responseType || config.responseType === 'text' ? request.responseText : request.response;\n      var response = {\n        data: responseData,\n        // IE sends 1223 instead of 204 (https://github.com/mzabriskie/axios/issues/201)\n        status: request.status === 1223 ? 204 : request.status,\n        statusText: request.status === 1223 ? 'No Content' : request.statusText,\n        headers: responseHeaders,\n        config: config,\n        request: request\n      };\n\n      settle(resolve, reject, response);\n\n      // Clean up request\n      request = null;\n    };\n\n    // Handle low level network errors\n    request.onerror = function handleError() {\n      // Real errors are hidden from us by the browser\n      // onerror should only fire if it's a network error\n      reject(createError('Network Error', config));\n\n      // Clean up request\n      request = null;\n    };\n\n    // Handle timeout\n    request.ontimeout = function handleTimeout() {\n      reject(createError('timeout of ' + config.timeout + 'ms exceeded', config, 'ECONNABORTED'));\n\n      // Clean up request\n      request = null;\n    };\n\n    // Add xsrf header\n    // This is only done if running in a standard browser environment.\n    // Specifically not if we're in a web worker, or react-native.\n    if (utils.isStandardBrowserEnv()) {\n      var cookies = require('./../helpers/cookies');\n\n      // Add xsrf header\n      var xsrfValue = (config.withCredentials || isURLSameOrigin(config.url)) && config.xsrfCookieName ?\n          cookies.read(config.xsrfCookieName) :\n          undefined;\n\n      if (xsrfValue) {\n        requestHeaders[config.xsrfHeaderName] = xsrfValue;\n      }\n    }\n\n    // Add headers to the request\n    if ('setRequestHeader' in request) {\n      utils.forEach(requestHeaders, function setRequestHeader(val, key) {\n        if (typeof requestData === 'undefined' && key.toLowerCase() === 'content-type') {\n          // Remove Content-Type if data is undefined\n          delete requestHeaders[key];\n        } else {\n          // Otherwise add header to the request\n          request.setRequestHeader(key, val);\n        }\n      });\n    }\n\n    // Add withCredentials to request if needed\n    if (config.withCredentials) {\n      request.withCredentials = true;\n    }\n\n    // Add responseType to request if needed\n    if (config.responseType) {\n      try {\n        request.responseType = config.responseType;\n      } catch (e) {\n        if (request.responseType !== 'json') {\n          throw e;\n        }\n      }\n    }\n\n    // Handle progress if needed\n    if (typeof config.onDownloadProgress === 'function') {\n      request.addEventListener('progress', config.onDownloadProgress);\n    }\n\n    // Not all browsers support upload events\n    if (typeof config.onUploadProgress === 'function' && request.upload) {\n      request.upload.addEventListener('progress', config.onUploadProgress);\n    }\n\n    if (config.cancelToken) {\n      // Handle cancellation\n      config.cancelToken.promise.then(function onCanceled(cancel) {\n        if (!request) {\n          return;\n        }\n\n        request.abort();\n        reject(cancel);\n        // Clean up request\n        request = null;\n      });\n    }\n\n    if (requestData === undefined) {\n      requestData = null;\n    }\n\n    // Send the request\n    request.send(requestData);\n  });\n};\n","'use strict';\n\nvar utils = require('./utils');\nvar bind = require('./helpers/bind');\nvar Axios = require('./core/Axios');\nvar defaults = require('./defaults');\n\n/**\n * Create an instance of Axios\n *\n * @param {Object} defaultConfig The default config for the instance\n * @return {Axios} A new instance of Axios\n */\nfunction createInstance(defaultConfig) {\n  var context = new Axios(defaultConfig);\n  var instance = bind(Axios.prototype.request, context);\n\n  // Copy axios.prototype to instance\n  utils.extend(instance, Axios.prototype, context);\n\n  // Copy context to instance\n  utils.extend(instance, context);\n\n  return instance;\n}\n\n// Create the default instance to be exported\nvar axios = createInstance(defaults);\n\n// Expose Axios class to allow class inheritance\naxios.Axios = Axios;\n\n// Factory for creating new instances\naxios.create = function create(instanceConfig) {\n  return createInstance(utils.merge(defaults, instanceConfig));\n};\n\n// Expose Cancel & CancelToken\naxios.Cancel = require('./cancel/Cancel');\naxios.CancelToken = require('./cancel/CancelToken');\naxios.isCancel = require('./cancel/isCancel');\n\n// Expose all/spread\naxios.all = function all(promises) {\n  return Promise.all(promises);\n};\naxios.spread = require('./helpers/spread');\n\nmodule.exports = axios;\n\n// Allow use of default import syntax in TypeScript\nmodule.exports.default = axios;\n","'use strict';\n\n/**\n * A `Cancel` is an object that is thrown when an operation is canceled.\n *\n * @class\n * @param {string=} message The message.\n */\nfunction Cancel(message) {\n  this.message = message;\n}\n\nCancel.prototype.toString = function toString() {\n  return 'Cancel' + (this.message ? ': ' + this.message : '');\n};\n\nCancel.prototype.__CANCEL__ = true;\n\nmodule.exports = Cancel;\n","'use strict';\n\nvar Cancel = require('./Cancel');\n\n/**\n * A `CancelToken` is an object that can be used to request cancellation of an operation.\n *\n * @class\n * @param {Function} executor The executor function.\n */\nfunction CancelToken(executor) {\n  if (typeof executor !== 'function') {\n    throw new TypeError('executor must be a function.');\n  }\n\n  var resolvePromise;\n  this.promise = new Promise(function promiseExecutor(resolve) {\n    resolvePromise = resolve;\n  });\n\n  var token = this;\n  executor(function cancel(message) {\n    if (token.reason) {\n      // Cancellation has already been requested\n      return;\n    }\n\n    token.reason = new Cancel(message);\n    resolvePromise(token.reason);\n  });\n}\n\n/**\n * Throws a `Cancel` if cancellation has been requested.\n */\nCancelToken.prototype.throwIfRequested = function throwIfRequested() {\n  if (this.reason) {\n    throw this.reason;\n  }\n};\n\n/**\n * Returns an object that contains a new `CancelToken` and a function that, when called,\n * cancels the `CancelToken`.\n */\nCancelToken.source = function source() {\n  var cancel;\n  var token = new CancelToken(function executor(c) {\n    cancel = c;\n  });\n  return {\n    token: token,\n    cancel: cancel\n  };\n};\n\nmodule.exports = CancelToken;\n","'use strict';\n\nmodule.exports = function isCancel(value) {\n  return !!(value && value.__CANCEL__);\n};\n","'use strict';\n\nvar defaults = require('./../defaults');\nvar utils = require('./../utils');\nvar InterceptorManager = require('./InterceptorManager');\nvar dispatchRequest = require('./dispatchRequest');\nvar isAbsoluteURL = require('./../helpers/isAbsoluteURL');\nvar combineURLs = require('./../helpers/combineURLs');\n\n/**\n * Create a new instance of Axios\n *\n * @param {Object} instanceConfig The default config for the instance\n */\nfunction Axios(instanceConfig) {\n  this.defaults = instanceConfig;\n  this.interceptors = {\n    request: new InterceptorManager(),\n    response: new InterceptorManager()\n  };\n}\n\n/**\n * Dispatch a request\n *\n * @param {Object} config The config specific for this request (merged with this.defaults)\n */\nAxios.prototype.request = function request(config) {\n  /*eslint no-param-reassign:0*/\n  // Allow for axios('example/url'[, config]) a la fetch API\n  if (typeof config === 'string') {\n    config = utils.merge({\n      url: arguments[0]\n    }, arguments[1]);\n  }\n\n  config = utils.merge(defaults, this.defaults, { method: 'get' }, config);\n\n  // Support baseURL config\n  if (config.baseURL && !isAbsoluteURL(config.url)) {\n    config.url = combineURLs(config.baseURL, config.url);\n  }\n\n  // Hook up interceptors middleware\n  var chain = [dispatchRequest, undefined];\n  var promise = Promise.resolve(config);\n\n  this.interceptors.request.forEach(function unshiftRequestInterceptors(interceptor) {\n    chain.unshift(interceptor.fulfilled, interceptor.rejected);\n  });\n\n  this.interceptors.response.forEach(function pushResponseInterceptors(interceptor) {\n    chain.push(interceptor.fulfilled, interceptor.rejected);\n  });\n\n  while (chain.length) {\n    promise = promise.then(chain.shift(), chain.shift());\n  }\n\n  return promise;\n};\n\n// Provide aliases for supported request methods\nutils.forEach(['delete', 'get', 'head'], function forEachMethodNoData(method) {\n  /*eslint func-names:0*/\n  Axios.prototype[method] = function(url, config) {\n    return this.request(utils.merge(config || {}, {\n      method: method,\n      url: url\n    }));\n  };\n});\n\nutils.forEach(['post', 'put', 'patch'], function forEachMethodWithData(method) {\n  /*eslint func-names:0*/\n  Axios.prototype[method] = function(url, data, config) {\n    return this.request(utils.merge(config || {}, {\n      method: method,\n      url: url,\n      data: data\n    }));\n  };\n});\n\nmodule.exports = Axios;\n","'use strict';\n\nvar utils = require('./../utils');\n\nfunction InterceptorManager() {\n  this.handlers = [];\n}\n\n/**\n * Add a new interceptor to the stack\n *\n * @param {Function} fulfilled The function to handle `then` for a `Promise`\n * @param {Function} rejected The function to handle `reject` for a `Promise`\n *\n * @return {Number} An ID used to remove interceptor later\n */\nInterceptorManager.prototype.use = function use(fulfilled, rejected) {\n  this.handlers.push({\n    fulfilled: fulfilled,\n    rejected: rejected\n  });\n  return this.handlers.length - 1;\n};\n\n/**\n * Remove an interceptor from the stack\n *\n * @param {Number} id The ID that was returned by `use`\n */\nInterceptorManager.prototype.eject = function eject(id) {\n  if (this.handlers[id]) {\n    this.handlers[id] = null;\n  }\n};\n\n/**\n * Iterate over all the registered interceptors\n *\n * This method is particularly useful for skipping over any\n * interceptors that may have become `null` calling `eject`.\n *\n * @param {Function} fn The function to call for each interceptor\n */\nInterceptorManager.prototype.forEach = function forEach(fn) {\n  utils.forEach(this.handlers, function forEachHandler(h) {\n    if (h !== null) {\n      fn(h);\n    }\n  });\n};\n\nmodule.exports = InterceptorManager;\n","'use strict';\n\nvar enhanceError = require('./enhanceError');\n\n/**\n * Create an Error with the specified message, config, error code, and response.\n *\n * @param {string} message The error message.\n * @param {Object} config The config.\n * @param {string} [code] The error code (for example, 'ECONNABORTED').\n @ @param {Object} [response] The response.\n * @returns {Error} The created error.\n */\nmodule.exports = function createError(message, config, code, response) {\n  var error = new Error(message);\n  return enhanceError(error, config, code, response);\n};\n","'use strict';\n\nvar utils = require('./../utils');\nvar transformData = require('./transformData');\nvar isCancel = require('../cancel/isCancel');\nvar defaults = require('../defaults');\n\n/**\n * Throws a `Cancel` if cancellation has been requested.\n */\nfunction throwIfCancellationRequested(config) {\n  if (config.cancelToken) {\n    config.cancelToken.throwIfRequested();\n  }\n}\n\n/**\n * Dispatch a request to the server using the configured adapter.\n *\n * @param {object} config The config that is to be used for the request\n * @returns {Promise} The Promise to be fulfilled\n */\nmodule.exports = function dispatchRequest(config) {\n  throwIfCancellationRequested(config);\n\n  // Ensure headers exist\n  config.headers = config.headers || {};\n\n  // Transform request data\n  config.data = transformData(\n    config.data,\n    config.headers,\n    config.transformRequest\n  );\n\n  // Flatten headers\n  config.headers = utils.merge(\n    config.headers.common || {},\n    config.headers[config.method] || {},\n    config.headers || {}\n  );\n\n  utils.forEach(\n    ['delete', 'get', 'head', 'post', 'put', 'patch', 'common'],\n    function cleanHeaderConfig(method) {\n      delete config.headers[method];\n    }\n  );\n\n  var adapter = config.adapter || defaults.adapter;\n\n  return adapter(config).then(function onAdapterResolution(response) {\n    throwIfCancellationRequested(config);\n\n    // Transform response data\n    response.data = transformData(\n      response.data,\n      response.headers,\n      config.transformResponse\n    );\n\n    return response;\n  }, function onAdapterRejection(reason) {\n    if (!isCancel(reason)) {\n      throwIfCancellationRequested(config);\n\n      // Transform response data\n      if (reason && reason.response) {\n        reason.response.data = transformData(\n          reason.response.data,\n          reason.response.headers,\n          config.transformResponse\n        );\n      }\n    }\n\n    return Promise.reject(reason);\n  });\n};\n","'use strict';\n\n/**\n * Update an Error with the specified config, error code, and response.\n *\n * @param {Error} error The error to update.\n * @param {Object} config The config.\n * @param {string} [code] The error code (for example, 'ECONNABORTED').\n @ @param {Object} [response] The response.\n * @returns {Error} The error.\n */\nmodule.exports = function enhanceError(error, config, code, response) {\n  error.config = config;\n  if (code) {\n    error.code = code;\n  }\n  error.response = response;\n  return error;\n};\n","'use strict';\n\nvar createError = require('./createError');\n\n/**\n * Resolve or reject a Promise based on response status.\n *\n * @param {Function} resolve A function that resolves the promise.\n * @param {Function} reject A function that rejects the promise.\n * @param {object} response The response.\n */\nmodule.exports = function settle(resolve, reject, response) {\n  var validateStatus = response.config.validateStatus;\n  // Note: status is not exposed by XDomainRequest\n  if (!response.status || !validateStatus || validateStatus(response.status)) {\n    resolve(response);\n  } else {\n    reject(createError(\n      'Request failed with status code ' + response.status,\n      response.config,\n      null,\n      response\n    ));\n  }\n};\n","'use strict';\n\nvar utils = require('./../utils');\n\n/**\n * Transform the data for a request or a response\n *\n * @param {Object|String} data The data to be transformed\n * @param {Array} headers The headers for the request or response\n * @param {Array|Function} fns A single function or Array of functions\n * @returns {*} The resulting transformed data\n */\nmodule.exports = function transformData(data, headers, fns) {\n  /*eslint no-param-reassign:0*/\n  utils.forEach(fns, function transform(fn) {\n    data = fn(data, headers);\n  });\n\n  return data;\n};\n","'use strict';\n\nvar utils = require('./utils');\nvar normalizeHeaderName = require('./helpers/normalizeHeaderName');\n\nvar PROTECTION_PREFIX = /^\\)\\]\\}',?\\n/;\nvar DEFAULT_CONTENT_TYPE = {\n  'Content-Type': 'application/x-www-form-urlencoded'\n};\n\nfunction setContentTypeIfUnset(headers, value) {\n  if (!utils.isUndefined(headers) && utils.isUndefined(headers['Content-Type'])) {\n    headers['Content-Type'] = value;\n  }\n}\n\nfunction getDefaultAdapter() {\n  var adapter;\n  if (typeof XMLHttpRequest !== 'undefined') {\n    // For browsers use XHR adapter\n    adapter = require('./adapters/xhr');\n  } else if (typeof process !== 'undefined') {\n    // For node use HTTP adapter\n    adapter = require('./adapters/http');\n  }\n  return adapter;\n}\n\nvar defaults = {\n  adapter: getDefaultAdapter(),\n\n  transformRequest: [function transformRequest(data, headers) {\n    normalizeHeaderName(headers, 'Content-Type');\n    if (utils.isFormData(data) ||\n      utils.isArrayBuffer(data) ||\n      utils.isStream(data) ||\n      utils.isFile(data) ||\n      utils.isBlob(data)\n    ) {\n      return data;\n    }\n    if (utils.isArrayBufferView(data)) {\n      return data.buffer;\n    }\n    if (utils.isURLSearchParams(data)) {\n      setContentTypeIfUnset(headers, 'application/x-www-form-urlencoded;charset=utf-8');\n      return data.toString();\n    }\n    if (utils.isObject(data)) {\n      setContentTypeIfUnset(headers, 'application/json;charset=utf-8');\n      return JSON.stringify(data);\n    }\n    return data;\n  }],\n\n  transformResponse: [function transformResponse(data) {\n    /*eslint no-param-reassign:0*/\n    if (typeof data === 'string') {\n      data = data.replace(PROTECTION_PREFIX, '');\n      try {\n        data = JSON.parse(data);\n      } catch (e) { /* Ignore */ }\n    }\n    return data;\n  }],\n\n  timeout: 0,\n\n  xsrfCookieName: 'XSRF-TOKEN',\n  xsrfHeaderName: 'X-XSRF-TOKEN',\n\n  maxContentLength: -1,\n\n  validateStatus: function validateStatus(status) {\n    return status >= 200 && status < 300;\n  }\n};\n\ndefaults.headers = {\n  common: {\n    'Accept': 'application/json, text/plain, */*'\n  }\n};\n\nutils.forEach(['delete', 'get', 'head'], function forEachMehtodNoData(method) {\n  defaults.headers[method] = {};\n});\n\nutils.forEach(['post', 'put', 'patch'], function forEachMethodWithData(method) {\n  defaults.headers[method] = utils.merge(DEFAULT_CONTENT_TYPE);\n});\n\nmodule.exports = defaults;\n","'use strict';\n\nmodule.exports = function bind(fn, thisArg) {\n  return function wrap() {\n    var args = new Array(arguments.length);\n    for (var i = 0; i < args.length; i++) {\n      args[i] = arguments[i];\n    }\n    return fn.apply(thisArg, args);\n  };\n};\n","'use strict';\n\n// btoa polyfill for IE<10 courtesy https://github.com/davidchambers/Base64.js\n\nvar chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=';\n\nfunction E() {\n  this.message = 'String contains an invalid character';\n}\nE.prototype = new Error;\nE.prototype.code = 5;\nE.prototype.name = 'InvalidCharacterError';\n\nfunction btoa(input) {\n  var str = String(input);\n  var output = '';\n  for (\n    // initialize result and counter\n    var block, charCode, idx = 0, map = chars;\n    // if the next str index does not exist:\n    //   change the mapping table to \"=\"\n    //   check if d has no fractional digits\n    str.charAt(idx | 0) || (map = '=', idx % 1);\n    // \"8 - idx % 1 * 8\" generates the sequence 2, 4, 6, 8\n    output += map.charAt(63 & block >> 8 - idx % 1 * 8)\n  ) {\n    charCode = str.charCodeAt(idx += 3 / 4);\n    if (charCode > 0xFF) {\n      throw new E();\n    }\n    block = block << 8 | charCode;\n  }\n  return output;\n}\n\nmodule.exports = btoa;\n","'use strict';\n\nvar utils = require('./../utils');\n\nfunction encode(val) {\n  return encodeURIComponent(val).\n    replace(/%40/gi, '@').\n    replace(/%3A/gi, ':').\n    replace(/%24/g, '$').\n    replace(/%2C/gi, ',').\n    replace(/%20/g, '+').\n    replace(/%5B/gi, '[').\n    replace(/%5D/gi, ']');\n}\n\n/**\n * Build a URL by appending params to the end\n *\n * @param {string} url The base of the url (e.g., http://www.google.com)\n * @param {object} [params] The params to be appended\n * @returns {string} The formatted url\n */\nmodule.exports = function buildURL(url, params, paramsSerializer) {\n  /*eslint no-param-reassign:0*/\n  if (!params) {\n    return url;\n  }\n\n  var serializedParams;\n  if (paramsSerializer) {\n    serializedParams = paramsSerializer(params);\n  } else if (utils.isURLSearchParams(params)) {\n    serializedParams = params.toString();\n  } else {\n    var parts = [];\n\n    utils.forEach(params, function serialize(val, key) {\n      if (val === null || typeof val === 'undefined') {\n        return;\n      }\n\n      if (utils.isArray(val)) {\n        key = key + '[]';\n      }\n\n      if (!utils.isArray(val)) {\n        val = [val];\n      }\n\n      utils.forEach(val, function parseValue(v) {\n        if (utils.isDate(v)) {\n          v = v.toISOString();\n        } else if (utils.isObject(v)) {\n          v = JSON.stringify(v);\n        }\n        parts.push(encode(key) + '=' + encode(v));\n      });\n    });\n\n    serializedParams = parts.join('&');\n  }\n\n  if (serializedParams) {\n    url += (url.indexOf('?') === -1 ? '?' : '&') + serializedParams;\n  }\n\n  return url;\n};\n","'use strict';\n\n/**\n * Creates a new URL by combining the specified URLs\n *\n * @param {string} baseURL The base URL\n * @param {string} relativeURL The relative URL\n * @returns {string} The combined URL\n */\nmodule.exports = function combineURLs(baseURL, relativeURL) {\n  return baseURL.replace(/\\/+$/, '') + '/' + relativeURL.replace(/^\\/+/, '');\n};\n","'use strict';\n\nvar utils = require('./../utils');\n\nmodule.exports = (\n  utils.isStandardBrowserEnv() ?\n\n  // Standard browser envs support document.cookie\n  (function standardBrowserEnv() {\n    return {\n      write: function write(name, value, expires, path, domain, secure) {\n        var cookie = [];\n        cookie.push(name + '=' + encodeURIComponent(value));\n\n        if (utils.isNumber(expires)) {\n          cookie.push('expires=' + new Date(expires).toGMTString());\n        }\n\n        if (utils.isString(path)) {\n          cookie.push('path=' + path);\n        }\n\n        if (utils.isString(domain)) {\n          cookie.push('domain=' + domain);\n        }\n\n        if (secure === true) {\n          cookie.push('secure');\n        }\n\n        document.cookie = cookie.join('; ');\n      },\n\n      read: function read(name) {\n        var match = document.cookie.match(new RegExp('(^|;\\\\s*)(' + name + ')=([^;]*)'));\n        return (match ? decodeURIComponent(match[3]) : null);\n      },\n\n      remove: function remove(name) {\n        this.write(name, '', Date.now() - 86400000);\n      }\n    };\n  })() :\n\n  // Non standard browser env (web workers, react-native) lack needed support.\n  (function nonStandardBrowserEnv() {\n    return {\n      write: function write() {},\n      read: function read() { return null; },\n      remove: function remove() {}\n    };\n  })()\n);\n","'use strict';\n\n/**\n * Determines whether the specified URL is absolute\n *\n * @param {string} url The URL to test\n * @returns {boolean} True if the specified URL is absolute, otherwise false\n */\nmodule.exports = function isAbsoluteURL(url) {\n  // A URL is considered absolute if it begins with \"<scheme>://\" or \"//\" (protocol-relative URL).\n  // RFC 3986 defines scheme name as a sequence of characters beginning with a letter and followed\n  // by any combination of letters, digits, plus, period, or hyphen.\n  return /^([a-z][a-z\\d\\+\\-\\.]*:)?\\/\\//i.test(url);\n};\n","'use strict';\n\nvar utils = require('./../utils');\n\nmodule.exports = (\n  utils.isStandardBrowserEnv() ?\n\n  // Standard browser envs have full support of the APIs needed to test\n  // whether the request URL is of the same origin as current location.\n  (function standardBrowserEnv() {\n    var msie = /(msie|trident)/i.test(navigator.userAgent);\n    var urlParsingNode = document.createElement('a');\n    var originURL;\n\n    /**\n    * Parse a URL to discover it's components\n    *\n    * @param {String} url The URL to be parsed\n    * @returns {Object}\n    */\n    function resolveURL(url) {\n      var href = url;\n\n      if (msie) {\n        // IE needs attribute set twice to normalize properties\n        urlParsingNode.setAttribute('href', href);\n        href = urlParsingNode.href;\n      }\n\n      urlParsingNode.setAttribute('href', href);\n\n      // urlParsingNode provides the UrlUtils interface - http://url.spec.whatwg.org/#urlutils\n      return {\n        href: urlParsingNode.href,\n        protocol: urlParsingNode.protocol ? urlParsingNode.protocol.replace(/:$/, '') : '',\n        host: urlParsingNode.host,\n        search: urlParsingNode.search ? urlParsingNode.search.replace(/^\\?/, '') : '',\n        hash: urlParsingNode.hash ? urlParsingNode.hash.replace(/^#/, '') : '',\n        hostname: urlParsingNode.hostname,\n        port: urlParsingNode.port,\n        pathname: (urlParsingNode.pathname.charAt(0) === '/') ?\n                  urlParsingNode.pathname :\n                  '/' + urlParsingNode.pathname\n      };\n    }\n\n    originURL = resolveURL(window.location.href);\n\n    /**\n    * Determine if a URL shares the same origin as the current location\n    *\n    * @param {String} requestURL The URL to test\n    * @returns {boolean} True if URL shares the same origin, otherwise false\n    */\n    return function isURLSameOrigin(requestURL) {\n      var parsed = (utils.isString(requestURL)) ? resolveURL(requestURL) : requestURL;\n      return (parsed.protocol === originURL.protocol &&\n            parsed.host === originURL.host);\n    };\n  })() :\n\n  // Non standard browser envs (web workers, react-native) lack needed support.\n  (function nonStandardBrowserEnv() {\n    return function isURLSameOrigin() {\n      return true;\n    };\n  })()\n);\n","'use strict';\n\nvar utils = require('../utils');\n\nmodule.exports = function normalizeHeaderName(headers, normalizedName) {\n  utils.forEach(headers, function processHeader(value, name) {\n    if (name !== normalizedName && name.toUpperCase() === normalizedName.toUpperCase()) {\n      headers[normalizedName] = value;\n      delete headers[name];\n    }\n  });\n};\n","'use strict';\n\nvar utils = require('./../utils');\n\n/**\n * Parse headers into an object\n *\n * ```\n * Date: Wed, 27 Aug 2014 08:58:49 GMT\n * Content-Type: application/json\n * Connection: keep-alive\n * Transfer-Encoding: chunked\n * ```\n *\n * @param {String} headers Headers needing to be parsed\n * @returns {Object} Headers parsed into an object\n */\nmodule.exports = function parseHeaders(headers) {\n  var parsed = {};\n  var key;\n  var val;\n  var i;\n\n  if (!headers) { return parsed; }\n\n  utils.forEach(headers.split('\\n'), function parser(line) {\n    i = line.indexOf(':');\n    key = utils.trim(line.substr(0, i)).toLowerCase();\n    val = utils.trim(line.substr(i + 1));\n\n    if (key) {\n      parsed[key] = parsed[key] ? parsed[key] + ', ' + val : val;\n    }\n  });\n\n  return parsed;\n};\n","'use strict';\n\n/**\n * Syntactic sugar for invoking a function and expanding an array for arguments.\n *\n * Common use case would be to use `Function.prototype.apply`.\n *\n *  ```js\n *  function f(x, y, z) {}\n *  var args = [1, 2, 3];\n *  f.apply(null, args);\n *  ```\n *\n * With `spread` this example can be re-written.\n *\n *  ```js\n *  spread(function(x, y, z) {})([1, 2, 3]);\n *  ```\n *\n * @param {Function} callback\n * @returns {Function}\n */\nmodule.exports = function spread(callback) {\n  return function wrap(arr) {\n    return callback.apply(null, arr);\n  };\n};\n","'use strict';\n\nvar bind = require('./helpers/bind');\n\n/*global toString:true*/\n\n// utils is a library of generic helper functions non-specific to axios\n\nvar toString = Object.prototype.toString;\n\n/**\n * Determine if a value is an Array\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if value is an Array, otherwise false\n */\nfunction isArray(val) {\n  return toString.call(val) === '[object Array]';\n}\n\n/**\n * Determine if a value is an ArrayBuffer\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if value is an ArrayBuffer, otherwise false\n */\nfunction isArrayBuffer(val) {\n  return toString.call(val) === '[object ArrayBuffer]';\n}\n\n/**\n * Determine if a value is a FormData\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if value is an FormData, otherwise false\n */\nfunction isFormData(val) {\n  return (typeof FormData !== 'undefined') && (val instanceof FormData);\n}\n\n/**\n * Determine if a value is a view on an ArrayBuffer\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if value is a view on an ArrayBuffer, otherwise false\n */\nfunction isArrayBufferView(val) {\n  var result;\n  if ((typeof ArrayBuffer !== 'undefined') && (ArrayBuffer.isView)) {\n    result = ArrayBuffer.isView(val);\n  } else {\n    result = (val) && (val.buffer) && (val.buffer instanceof ArrayBuffer);\n  }\n  return result;\n}\n\n/**\n * Determine if a value is a String\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if value is a String, otherwise false\n */\nfunction isString(val) {\n  return typeof val === 'string';\n}\n\n/**\n * Determine if a value is a Number\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if value is a Number, otherwise false\n */\nfunction isNumber(val) {\n  return typeof val === 'number';\n}\n\n/**\n * Determine if a value is undefined\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if the value is undefined, otherwise false\n */\nfunction isUndefined(val) {\n  return typeof val === 'undefined';\n}\n\n/**\n * Determine if a value is an Object\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if value is an Object, otherwise false\n */\nfunction isObject(val) {\n  return val !== null && typeof val === 'object';\n}\n\n/**\n * Determine if a value is a Date\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if value is a Date, otherwise false\n */\nfunction isDate(val) {\n  return toString.call(val) === '[object Date]';\n}\n\n/**\n * Determine if a value is a File\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if value is a File, otherwise false\n */\nfunction isFile(val) {\n  return toString.call(val) === '[object File]';\n}\n\n/**\n * Determine if a value is a Blob\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if value is a Blob, otherwise false\n */\nfunction isBlob(val) {\n  return toString.call(val) === '[object Blob]';\n}\n\n/**\n * Determine if a value is a Function\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if value is a Function, otherwise false\n */\nfunction isFunction(val) {\n  return toString.call(val) === '[object Function]';\n}\n\n/**\n * Determine if a value is a Stream\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if value is a Stream, otherwise false\n */\nfunction isStream(val) {\n  return isObject(val) && isFunction(val.pipe);\n}\n\n/**\n * Determine if a value is a URLSearchParams object\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if value is a URLSearchParams object, otherwise false\n */\nfunction isURLSearchParams(val) {\n  return typeof URLSearchParams !== 'undefined' && val instanceof URLSearchParams;\n}\n\n/**\n * Trim excess whitespace off the beginning and end of a string\n *\n * @param {String} str The String to trim\n * @returns {String} The String freed of excess whitespace\n */\nfunction trim(str) {\n  return str.replace(/^\\s*/, '').replace(/\\s*$/, '');\n}\n\n/**\n * Determine if we're running in a standard browser environment\n *\n * This allows axios to run in a web worker, and react-native.\n * Both environments support XMLHttpRequest, but not fully standard globals.\n *\n * web workers:\n *  typeof window -> undefined\n *  typeof document -> undefined\n *\n * react-native:\n *  typeof document.createElement -> undefined\n */\nfunction isStandardBrowserEnv() {\n  return (\n    typeof window !== 'undefined' &&\n    typeof document !== 'undefined' &&\n    typeof document.createElement === 'function'\n  );\n}\n\n/**\n * Iterate over an Array or an Object invoking a function for each item.\n *\n * If `obj` is an Array callback will be called passing\n * the value, index, and complete array for each item.\n *\n * If 'obj' is an Object callback will be called passing\n * the value, key, and complete object for each property.\n *\n * @param {Object|Array} obj The object to iterate\n * @param {Function} fn The callback to invoke for each item\n */\nfunction forEach(obj, fn) {\n  // Don't bother if no value provided\n  if (obj === null || typeof obj === 'undefined') {\n    return;\n  }\n\n  // Force an array if not already something iterable\n  if (typeof obj !== 'object' && !isArray(obj)) {\n    /*eslint no-param-reassign:0*/\n    obj = [obj];\n  }\n\n  if (isArray(obj)) {\n    // Iterate over array values\n    for (var i = 0, l = obj.length; i < l; i++) {\n      fn.call(null, obj[i], i, obj);\n    }\n  } else {\n    // Iterate over object keys\n    for (var key in obj) {\n      if (Object.prototype.hasOwnProperty.call(obj, key)) {\n        fn.call(null, obj[key], key, obj);\n      }\n    }\n  }\n}\n\n/**\n * Accepts varargs expecting each argument to be an object, then\n * immutably merges the properties of each object and returns result.\n *\n * When multiple objects contain the same key the later object in\n * the arguments list will take precedence.\n *\n * Example:\n *\n * ```js\n * var result = merge({foo: 123}, {foo: 456});\n * console.log(result.foo); // outputs 456\n * ```\n *\n * @param {Object} obj1 Object to merge\n * @returns {Object} Result of all merge properties\n */\nfunction merge(/* obj1, obj2, obj3, ... */) {\n  var result = {};\n  function assignValue(val, key) {\n    if (typeof result[key] === 'object' && typeof val === 'object') {\n      result[key] = merge(result[key], val);\n    } else {\n      result[key] = val;\n    }\n  }\n\n  for (var i = 0, l = arguments.length; i < l; i++) {\n    forEach(arguments[i], assignValue);\n  }\n  return result;\n}\n\n/**\n * Extends object a by mutably adding to it the properties of object b.\n *\n * @param {Object} a The object to be extended\n * @param {Object} b The object to copy properties from\n * @param {Object} thisArg The object to bind function to\n * @return {Object} The resulting value of object a\n */\nfunction extend(a, b, thisArg) {\n  forEach(b, function assignValue(val, key) {\n    if (thisArg && typeof val === 'function') {\n      a[key] = bind(val, thisArg);\n    } else {\n      a[key] = val;\n    }\n  });\n  return a;\n}\n\nmodule.exports = {\n  isArray: isArray,\n  isArrayBuffer: isArrayBuffer,\n  isFormData: isFormData,\n  isArrayBufferView: isArrayBufferView,\n  isString: isString,\n  isNumber: isNumber,\n  isObject: isObject,\n  isUndefined: isUndefined,\n  isDate: isDate,\n  isFile: isFile,\n  isBlob: isBlob,\n  isFunction: isFunction,\n  isStream: isStream,\n  isURLSearchParams: isURLSearchParams,\n  isStandardBrowserEnv: isStandardBrowserEnv,\n  forEach: forEach,\n  merge: merge,\n  extend: extend,\n  trim: trim\n};\n","'use strict'\n\nexports.byteLength = byteLength\nexports.toByteArray = toByteArray\nexports.fromByteArray = fromByteArray\n\nvar lookup = []\nvar revLookup = []\nvar Arr = typeof Uint8Array !== 'undefined' ? Uint8Array : Array\n\nvar code = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'\nfor (var i = 0, len = code.length; i < len; ++i) {\n  lookup[i] = code[i]\n  revLookup[code.charCodeAt(i)] = i\n}\n\nrevLookup['-'.charCodeAt(0)] = 62\nrevLookup['_'.charCodeAt(0)] = 63\n\nfunction placeHoldersCount (b64) {\n  var len = b64.length\n  if (len % 4 > 0) {\n    throw new Error('Invalid string. Length must be a multiple of 4')\n  }\n\n  // the number of equal signs (place holders)\n  // if there are two placeholders, than the two characters before it\n  // represent one byte\n  // if there is only one, then the three characters before it represent 2 bytes\n  // this is just a cheap hack to not do indexOf twice\n  return b64[len - 2] === '=' ? 2 : b64[len - 1] === '=' ? 1 : 0\n}\n\nfunction byteLength (b64) {\n  // base64 is 4/3 + up to two characters of the original data\n  return b64.length * 3 / 4 - placeHoldersCount(b64)\n}\n\nfunction toByteArray (b64) {\n  var i, j, l, tmp, placeHolders, arr\n  var len = b64.length\n  placeHolders = placeHoldersCount(b64)\n\n  arr = new Arr(len * 3 / 4 - placeHolders)\n\n  // if there are placeholders, only get up to the last complete 4 chars\n  l = placeHolders > 0 ? len - 4 : len\n\n  var L = 0\n\n  for (i = 0, j = 0; i < l; i += 4, j += 3) {\n    tmp = (revLookup[b64.charCodeAt(i)] << 18) | (revLookup[b64.charCodeAt(i + 1)] << 12) | (revLookup[b64.charCodeAt(i + 2)] << 6) | revLookup[b64.charCodeAt(i + 3)]\n    arr[L++] = (tmp >> 16) & 0xFF\n    arr[L++] = (tmp >> 8) & 0xFF\n    arr[L++] = tmp & 0xFF\n  }\n\n  if (placeHolders === 2) {\n    tmp = (revLookup[b64.charCodeAt(i)] << 2) | (revLookup[b64.charCodeAt(i + 1)] >> 4)\n    arr[L++] = tmp & 0xFF\n  } else if (placeHolders === 1) {\n    tmp = (revLookup[b64.charCodeAt(i)] << 10) | (revLookup[b64.charCodeAt(i + 1)] << 4) | (revLookup[b64.charCodeAt(i + 2)] >> 2)\n    arr[L++] = (tmp >> 8) & 0xFF\n    arr[L++] = tmp & 0xFF\n  }\n\n  return arr\n}\n\nfunction tripletToBase64 (num) {\n  return lookup[num >> 18 & 0x3F] + lookup[num >> 12 & 0x3F] + lookup[num >> 6 & 0x3F] + lookup[num & 0x3F]\n}\n\nfunction encodeChunk (uint8, start, end) {\n  var tmp\n  var output = []\n  for (var i = start; i < end; i += 3) {\n    tmp = (uint8[i] << 16) + (uint8[i + 1] << 8) + (uint8[i + 2])\n    output.push(tripletToBase64(tmp))\n  }\n  return output.join('')\n}\n\nfunction fromByteArray (uint8) {\n  var tmp\n  var len = uint8.length\n  var extraBytes = len % 3 // if we have 1 byte left, pad 2 bytes\n  var output = ''\n  var parts = []\n  var maxChunkLength = 16383 // must be multiple of 3\n\n  // go through the array every three bytes, we'll deal with trailing stuff later\n  for (var i = 0, len2 = len - extraBytes; i < len2; i += maxChunkLength) {\n    parts.push(encodeChunk(uint8, i, (i + maxChunkLength) > len2 ? len2 : (i + maxChunkLength)))\n  }\n\n  // pad the end with zeros, but make sure to not forget the extra bytes\n  if (extraBytes === 1) {\n    tmp = uint8[len - 1]\n    output += lookup[tmp >> 2]\n    output += lookup[(tmp << 4) & 0x3F]\n    output += '=='\n  } else if (extraBytes === 2) {\n    tmp = (uint8[len - 2] << 8) + (uint8[len - 1])\n    output += lookup[tmp >> 10]\n    output += lookup[(tmp >> 4) & 0x3F]\n    output += lookup[(tmp << 2) & 0x3F]\n    output += '='\n  }\n\n  parts.push(output)\n\n  return parts.join('')\n}\n","/*!\n * The buffer module from node.js, for the browser.\n *\n * @author   Feross Aboukhadijeh <feross@feross.org> <http://feross.org>\n * @license  MIT\n */\n/* eslint-disable no-proto */\n\n'use strict'\n\nvar base64 = require('base64-js')\nvar ieee754 = require('ieee754')\nvar isArray = require('isarray')\n\nexports.Buffer = Buffer\nexports.SlowBuffer = SlowBuffer\nexports.INSPECT_MAX_BYTES = 50\n\n/**\n * If `Buffer.TYPED_ARRAY_SUPPORT`:\n *   === true    Use Uint8Array implementation (fastest)\n *   === false   Use Object implementation (most compatible, even IE6)\n *\n * Browsers that support typed arrays are IE 10+, Firefox 4+, Chrome 7+, Safari 5.1+,\n * Opera 11.6+, iOS 4.2+.\n *\n * Due to various browser bugs, sometimes the Object implementation will be used even\n * when the browser supports typed arrays.\n *\n * Note:\n *\n *   - Firefox 4-29 lacks support for adding new properties to `Uint8Array` instances,\n *     See: https://bugzilla.mozilla.org/show_bug.cgi?id=695438.\n *\n *   - Chrome 9-10 is missing the `TypedArray.prototype.subarray` function.\n *\n *   - IE10 has a broken `TypedArray.prototype.subarray` function which returns arrays of\n *     incorrect length in some situations.\n\n * We detect these buggy browsers and set `Buffer.TYPED_ARRAY_SUPPORT` to `false` so they\n * get the Object implementation, which is slower but behaves correctly.\n */\nBuffer.TYPED_ARRAY_SUPPORT = global.TYPED_ARRAY_SUPPORT !== undefined\n  ? global.TYPED_ARRAY_SUPPORT\n  : typedArraySupport()\n\n/*\n * Export kMaxLength after typed array support is determined.\n */\nexports.kMaxLength = kMaxLength()\n\nfunction typedArraySupport () {\n  try {\n    var arr = new Uint8Array(1)\n    arr.__proto__ = {__proto__: Uint8Array.prototype, foo: function () { return 42 }}\n    return arr.foo() === 42 && // typed array instances can be augmented\n        typeof arr.subarray === 'function' && // chrome 9-10 lack `subarray`\n        arr.subarray(1, 1).byteLength === 0 // ie10 has broken `subarray`\n  } catch (e) {\n    return false\n  }\n}\n\nfunction kMaxLength () {\n  return Buffer.TYPED_ARRAY_SUPPORT\n    ? 0x7fffffff\n    : 0x3fffffff\n}\n\nfunction createBuffer (that, length) {\n  if (kMaxLength() < length) {\n    throw new RangeError('Invalid typed array length')\n  }\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    // Return an augmented `Uint8Array` instance, for best performance\n    that = new Uint8Array(length)\n    that.__proto__ = Buffer.prototype\n  } else {\n    // Fallback: Return an object instance of the Buffer class\n    if (that === null) {\n      that = new Buffer(length)\n    }\n    that.length = length\n  }\n\n  return that\n}\n\n/**\n * The Buffer constructor returns instances of `Uint8Array` that have their\n * prototype changed to `Buffer.prototype`. Furthermore, `Buffer` is a subclass of\n * `Uint8Array`, so the returned instances will have all the node `Buffer` methods\n * and the `Uint8Array` methods. Square bracket notation works as expected -- it\n * returns a single octet.\n *\n * The `Uint8Array` prototype remains unmodified.\n */\n\nfunction Buffer (arg, encodingOrOffset, length) {\n  if (!Buffer.TYPED_ARRAY_SUPPORT && !(this instanceof Buffer)) {\n    return new Buffer(arg, encodingOrOffset, length)\n  }\n\n  // Common case.\n  if (typeof arg === 'number') {\n    if (typeof encodingOrOffset === 'string') {\n      throw new Error(\n        'If encoding is specified then the first argument must be a string'\n      )\n    }\n    return allocUnsafe(this, arg)\n  }\n  return from(this, arg, encodingOrOffset, length)\n}\n\nBuffer.poolSize = 8192 // not used by this implementation\n\n// TODO: Legacy, not needed anymore. Remove in next major version.\nBuffer._augment = function (arr) {\n  arr.__proto__ = Buffer.prototype\n  return arr\n}\n\nfunction from (that, value, encodingOrOffset, length) {\n  if (typeof value === 'number') {\n    throw new TypeError('\"value\" argument must not be a number')\n  }\n\n  if (typeof ArrayBuffer !== 'undefined' && value instanceof ArrayBuffer) {\n    return fromArrayBuffer(that, value, encodingOrOffset, length)\n  }\n\n  if (typeof value === 'string') {\n    return fromString(that, value, encodingOrOffset)\n  }\n\n  return fromObject(that, value)\n}\n\n/**\n * Functionally equivalent to Buffer(arg, encoding) but throws a TypeError\n * if value is a number.\n * Buffer.from(str[, encoding])\n * Buffer.from(array)\n * Buffer.from(buffer)\n * Buffer.from(arrayBuffer[, byteOffset[, length]])\n **/\nBuffer.from = function (value, encodingOrOffset, length) {\n  return from(null, value, encodingOrOffset, length)\n}\n\nif (Buffer.TYPED_ARRAY_SUPPORT) {\n  Buffer.prototype.__proto__ = Uint8Array.prototype\n  Buffer.__proto__ = Uint8Array\n  if (typeof Symbol !== 'undefined' && Symbol.species &&\n      Buffer[Symbol.species] === Buffer) {\n    // Fix subarray() in ES2016. See: https://github.com/feross/buffer/pull/97\n    Object.defineProperty(Buffer, Symbol.species, {\n      value: null,\n      configurable: true\n    })\n  }\n}\n\nfunction assertSize (size) {\n  if (typeof size !== 'number') {\n    throw new TypeError('\"size\" argument must be a number')\n  } else if (size < 0) {\n    throw new RangeError('\"size\" argument must not be negative')\n  }\n}\n\nfunction alloc (that, size, fill, encoding) {\n  assertSize(size)\n  if (size <= 0) {\n    return createBuffer(that, size)\n  }\n  if (fill !== undefined) {\n    // Only pay attention to encoding if it's a string. This\n    // prevents accidentally sending in a number that would\n    // be interpretted as a start offset.\n    return typeof encoding === 'string'\n      ? createBuffer(that, size).fill(fill, encoding)\n      : createBuffer(that, size).fill(fill)\n  }\n  return createBuffer(that, size)\n}\n\n/**\n * Creates a new filled Buffer instance.\n * alloc(size[, fill[, encoding]])\n **/\nBuffer.alloc = function (size, fill, encoding) {\n  return alloc(null, size, fill, encoding)\n}\n\nfunction allocUnsafe (that, size) {\n  assertSize(size)\n  that = createBuffer(that, size < 0 ? 0 : checked(size) | 0)\n  if (!Buffer.TYPED_ARRAY_SUPPORT) {\n    for (var i = 0; i < size; ++i) {\n      that[i] = 0\n    }\n  }\n  return that\n}\n\n/**\n * Equivalent to Buffer(num), by default creates a non-zero-filled Buffer instance.\n * */\nBuffer.allocUnsafe = function (size) {\n  return allocUnsafe(null, size)\n}\n/**\n * Equivalent to SlowBuffer(num), by default creates a non-zero-filled Buffer instance.\n */\nBuffer.allocUnsafeSlow = function (size) {\n  return allocUnsafe(null, size)\n}\n\nfunction fromString (that, string, encoding) {\n  if (typeof encoding !== 'string' || encoding === '') {\n    encoding = 'utf8'\n  }\n\n  if (!Buffer.isEncoding(encoding)) {\n    throw new TypeError('\"encoding\" must be a valid string encoding')\n  }\n\n  var length = byteLength(string, encoding) | 0\n  that = createBuffer(that, length)\n\n  var actual = that.write(string, encoding)\n\n  if (actual !== length) {\n    // Writing a hex string, for example, that contains invalid characters will\n    // cause everything after the first invalid character to be ignored. (e.g.\n    // 'abxxcd' will be treated as 'ab')\n    that = that.slice(0, actual)\n  }\n\n  return that\n}\n\nfunction fromArrayLike (that, array) {\n  var length = array.length < 0 ? 0 : checked(array.length) | 0\n  that = createBuffer(that, length)\n  for (var i = 0; i < length; i += 1) {\n    that[i] = array[i] & 255\n  }\n  return that\n}\n\nfunction fromArrayBuffer (that, array, byteOffset, length) {\n  array.byteLength // this throws if `array` is not a valid ArrayBuffer\n\n  if (byteOffset < 0 || array.byteLength < byteOffset) {\n    throw new RangeError('\\'offset\\' is out of bounds')\n  }\n\n  if (array.byteLength < byteOffset + (length || 0)) {\n    throw new RangeError('\\'length\\' is out of bounds')\n  }\n\n  if (byteOffset === undefined && length === undefined) {\n    array = new Uint8Array(array)\n  } else if (length === undefined) {\n    array = new Uint8Array(array, byteOffset)\n  } else {\n    array = new Uint8Array(array, byteOffset, length)\n  }\n\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    // Return an augmented `Uint8Array` instance, for best performance\n    that = array\n    that.__proto__ = Buffer.prototype\n  } else {\n    // Fallback: Return an object instance of the Buffer class\n    that = fromArrayLike(that, array)\n  }\n  return that\n}\n\nfunction fromObject (that, obj) {\n  if (Buffer.isBuffer(obj)) {\n    var len = checked(obj.length) | 0\n    that = createBuffer(that, len)\n\n    if (that.length === 0) {\n      return that\n    }\n\n    obj.copy(that, 0, 0, len)\n    return that\n  }\n\n  if (obj) {\n    if ((typeof ArrayBuffer !== 'undefined' &&\n        obj.buffer instanceof ArrayBuffer) || 'length' in obj) {\n      if (typeof obj.length !== 'number' || isnan(obj.length)) {\n        return createBuffer(that, 0)\n      }\n      return fromArrayLike(that, obj)\n    }\n\n    if (obj.type === 'Buffer' && isArray(obj.data)) {\n      return fromArrayLike(that, obj.data)\n    }\n  }\n\n  throw new TypeError('First argument must be a string, Buffer, ArrayBuffer, Array, or array-like object.')\n}\n\nfunction checked (length) {\n  // Note: cannot use `length < kMaxLength()` here because that fails when\n  // length is NaN (which is otherwise coerced to zero.)\n  if (length >= kMaxLength()) {\n    throw new RangeError('Attempt to allocate Buffer larger than maximum ' +\n                         'size: 0x' + kMaxLength().toString(16) + ' bytes')\n  }\n  return length | 0\n}\n\nfunction SlowBuffer (length) {\n  if (+length != length) { // eslint-disable-line eqeqeq\n    length = 0\n  }\n  return Buffer.alloc(+length)\n}\n\nBuffer.isBuffer = function isBuffer (b) {\n  return !!(b != null && b._isBuffer)\n}\n\nBuffer.compare = function compare (a, b) {\n  if (!Buffer.isBuffer(a) || !Buffer.isBuffer(b)) {\n    throw new TypeError('Arguments must be Buffers')\n  }\n\n  if (a === b) return 0\n\n  var x = a.length\n  var y = b.length\n\n  for (var i = 0, len = Math.min(x, y); i < len; ++i) {\n    if (a[i] !== b[i]) {\n      x = a[i]\n      y = b[i]\n      break\n    }\n  }\n\n  if (x < y) return -1\n  if (y < x) return 1\n  return 0\n}\n\nBuffer.isEncoding = function isEncoding (encoding) {\n  switch (String(encoding).toLowerCase()) {\n    case 'hex':\n    case 'utf8':\n    case 'utf-8':\n    case 'ascii':\n    case 'latin1':\n    case 'binary':\n    case 'base64':\n    case 'ucs2':\n    case 'ucs-2':\n    case 'utf16le':\n    case 'utf-16le':\n      return true\n    default:\n      return false\n  }\n}\n\nBuffer.concat = function concat (list, length) {\n  if (!isArray(list)) {\n    throw new TypeError('\"list\" argument must be an Array of Buffers')\n  }\n\n  if (list.length === 0) {\n    return Buffer.alloc(0)\n  }\n\n  var i\n  if (length === undefined) {\n    length = 0\n    for (i = 0; i < list.length; ++i) {\n      length += list[i].length\n    }\n  }\n\n  var buffer = Buffer.allocUnsafe(length)\n  var pos = 0\n  for (i = 0; i < list.length; ++i) {\n    var buf = list[i]\n    if (!Buffer.isBuffer(buf)) {\n      throw new TypeError('\"list\" argument must be an Array of Buffers')\n    }\n    buf.copy(buffer, pos)\n    pos += buf.length\n  }\n  return buffer\n}\n\nfunction byteLength (string, encoding) {\n  if (Buffer.isBuffer(string)) {\n    return string.length\n  }\n  if (typeof ArrayBuffer !== 'undefined' && typeof ArrayBuffer.isView === 'function' &&\n      (ArrayBuffer.isView(string) || string instanceof ArrayBuffer)) {\n    return string.byteLength\n  }\n  if (typeof string !== 'string') {\n    string = '' + string\n  }\n\n  var len = string.length\n  if (len === 0) return 0\n\n  // Use a for loop to avoid recursion\n  var loweredCase = false\n  for (;;) {\n    switch (encoding) {\n      case 'ascii':\n      case 'latin1':\n      case 'binary':\n        return len\n      case 'utf8':\n      case 'utf-8':\n      case undefined:\n        return utf8ToBytes(string).length\n      case 'ucs2':\n      case 'ucs-2':\n      case 'utf16le':\n      case 'utf-16le':\n        return len * 2\n      case 'hex':\n        return len >>> 1\n      case 'base64':\n        return base64ToBytes(string).length\n      default:\n        if (loweredCase) return utf8ToBytes(string).length // assume utf8\n        encoding = ('' + encoding).toLowerCase()\n        loweredCase = true\n    }\n  }\n}\nBuffer.byteLength = byteLength\n\nfunction slowToString (encoding, start, end) {\n  var loweredCase = false\n\n  // No need to verify that \"this.length <= MAX_UINT32\" since it's a read-only\n  // property of a typed array.\n\n  // This behaves neither like String nor Uint8Array in that we set start/end\n  // to their upper/lower bounds if the value passed is out of range.\n  // undefined is handled specially as per ECMA-262 6th Edition,\n  // Section 13.3.3.7 Runtime Semantics: KeyedBindingInitialization.\n  if (start === undefined || start < 0) {\n    start = 0\n  }\n  // Return early if start > this.length. Done here to prevent potential uint32\n  // coercion fail below.\n  if (start > this.length) {\n    return ''\n  }\n\n  if (end === undefined || end > this.length) {\n    end = this.length\n  }\n\n  if (end <= 0) {\n    return ''\n  }\n\n  // Force coersion to uint32. This will also coerce falsey/NaN values to 0.\n  end >>>= 0\n  start >>>= 0\n\n  if (end <= start) {\n    return ''\n  }\n\n  if (!encoding) encoding = 'utf8'\n\n  while (true) {\n    switch (encoding) {\n      case 'hex':\n        return hexSlice(this, start, end)\n\n      case 'utf8':\n      case 'utf-8':\n        return utf8Slice(this, start, end)\n\n      case 'ascii':\n        return asciiSlice(this, start, end)\n\n      case 'latin1':\n      case 'binary':\n        return latin1Slice(this, start, end)\n\n      case 'base64':\n        return base64Slice(this, start, end)\n\n      case 'ucs2':\n      case 'ucs-2':\n      case 'utf16le':\n      case 'utf-16le':\n        return utf16leSlice(this, start, end)\n\n      default:\n        if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)\n        encoding = (encoding + '').toLowerCase()\n        loweredCase = true\n    }\n  }\n}\n\n// The property is used by `Buffer.isBuffer` and `is-buffer` (in Safari 5-7) to detect\n// Buffer instances.\nBuffer.prototype._isBuffer = true\n\nfunction swap (b, n, m) {\n  var i = b[n]\n  b[n] = b[m]\n  b[m] = i\n}\n\nBuffer.prototype.swap16 = function swap16 () {\n  var len = this.length\n  if (len % 2 !== 0) {\n    throw new RangeError('Buffer size must be a multiple of 16-bits')\n  }\n  for (var i = 0; i < len; i += 2) {\n    swap(this, i, i + 1)\n  }\n  return this\n}\n\nBuffer.prototype.swap32 = function swap32 () {\n  var len = this.length\n  if (len % 4 !== 0) {\n    throw new RangeError('Buffer size must be a multiple of 32-bits')\n  }\n  for (var i = 0; i < len; i += 4) {\n    swap(this, i, i + 3)\n    swap(this, i + 1, i + 2)\n  }\n  return this\n}\n\nBuffer.prototype.swap64 = function swap64 () {\n  var len = this.length\n  if (len % 8 !== 0) {\n    throw new RangeError('Buffer size must be a multiple of 64-bits')\n  }\n  for (var i = 0; i < len; i += 8) {\n    swap(this, i, i + 7)\n    swap(this, i + 1, i + 6)\n    swap(this, i + 2, i + 5)\n    swap(this, i + 3, i + 4)\n  }\n  return this\n}\n\nBuffer.prototype.toString = function toString () {\n  var length = this.length | 0\n  if (length === 0) return ''\n  if (arguments.length === 0) return utf8Slice(this, 0, length)\n  return slowToString.apply(this, arguments)\n}\n\nBuffer.prototype.equals = function equals (b) {\n  if (!Buffer.isBuffer(b)) throw new TypeError('Argument must be a Buffer')\n  if (this === b) return true\n  return Buffer.compare(this, b) === 0\n}\n\nBuffer.prototype.inspect = function inspect () {\n  var str = ''\n  var max = exports.INSPECT_MAX_BYTES\n  if (this.length > 0) {\n    str = this.toString('hex', 0, max).match(/.{2}/g).join(' ')\n    if (this.length > max) str += ' ... '\n  }\n  return '<Buffer ' + str + '>'\n}\n\nBuffer.prototype.compare = function compare (target, start, end, thisStart, thisEnd) {\n  if (!Buffer.isBuffer(target)) {\n    throw new TypeError('Argument must be a Buffer')\n  }\n\n  if (start === undefined) {\n    start = 0\n  }\n  if (end === undefined) {\n    end = target ? target.length : 0\n  }\n  if (thisStart === undefined) {\n    thisStart = 0\n  }\n  if (thisEnd === undefined) {\n    thisEnd = this.length\n  }\n\n  if (start < 0 || end > target.length || thisStart < 0 || thisEnd > this.length) {\n    throw new RangeError('out of range index')\n  }\n\n  if (thisStart >= thisEnd && start >= end) {\n    return 0\n  }\n  if (thisStart >= thisEnd) {\n    return -1\n  }\n  if (start >= end) {\n    return 1\n  }\n\n  start >>>= 0\n  end >>>= 0\n  thisStart >>>= 0\n  thisEnd >>>= 0\n\n  if (this === target) return 0\n\n  var x = thisEnd - thisStart\n  var y = end - start\n  var len = Math.min(x, y)\n\n  var thisCopy = this.slice(thisStart, thisEnd)\n  var targetCopy = target.slice(start, end)\n\n  for (var i = 0; i < len; ++i) {\n    if (thisCopy[i] !== targetCopy[i]) {\n      x = thisCopy[i]\n      y = targetCopy[i]\n      break\n    }\n  }\n\n  if (x < y) return -1\n  if (y < x) return 1\n  return 0\n}\n\n// Finds either the first index of `val` in `buffer` at offset >= `byteOffset`,\n// OR the last index of `val` in `buffer` at offset <= `byteOffset`.\n//\n// Arguments:\n// - buffer - a Buffer to search\n// - val - a string, Buffer, or number\n// - byteOffset - an index into `buffer`; will be clamped to an int32\n// - encoding - an optional encoding, relevant is val is a string\n// - dir - true for indexOf, false for lastIndexOf\nfunction bidirectionalIndexOf (buffer, val, byteOffset, encoding, dir) {\n  // Empty buffer means no match\n  if (buffer.length === 0) return -1\n\n  // Normalize byteOffset\n  if (typeof byteOffset === 'string') {\n    encoding = byteOffset\n    byteOffset = 0\n  } else if (byteOffset > 0x7fffffff) {\n    byteOffset = 0x7fffffff\n  } else if (byteOffset < -0x80000000) {\n    byteOffset = -0x80000000\n  }\n  byteOffset = +byteOffset  // Coerce to Number.\n  if (isNaN(byteOffset)) {\n    // byteOffset: it it's undefined, null, NaN, \"foo\", etc, search whole buffer\n    byteOffset = dir ? 0 : (buffer.length - 1)\n  }\n\n  // Normalize byteOffset: negative offsets start from the end of the buffer\n  if (byteOffset < 0) byteOffset = buffer.length + byteOffset\n  if (byteOffset >= buffer.length) {\n    if (dir) return -1\n    else byteOffset = buffer.length - 1\n  } else if (byteOffset < 0) {\n    if (dir) byteOffset = 0\n    else return -1\n  }\n\n  // Normalize val\n  if (typeof val === 'string') {\n    val = Buffer.from(val, encoding)\n  }\n\n  // Finally, search either indexOf (if dir is true) or lastIndexOf\n  if (Buffer.isBuffer(val)) {\n    // Special case: looking for empty string/buffer always fails\n    if (val.length === 0) {\n      return -1\n    }\n    return arrayIndexOf(buffer, val, byteOffset, encoding, dir)\n  } else if (typeof val === 'number') {\n    val = val & 0xFF // Search for a byte value [0-255]\n    if (Buffer.TYPED_ARRAY_SUPPORT &&\n        typeof Uint8Array.prototype.indexOf === 'function') {\n      if (dir) {\n        return Uint8Array.prototype.indexOf.call(buffer, val, byteOffset)\n      } else {\n        return Uint8Array.prototype.lastIndexOf.call(buffer, val, byteOffset)\n      }\n    }\n    return arrayIndexOf(buffer, [ val ], byteOffset, encoding, dir)\n  }\n\n  throw new TypeError('val must be string, number or Buffer')\n}\n\nfunction arrayIndexOf (arr, val, byteOffset, encoding, dir) {\n  var indexSize = 1\n  var arrLength = arr.length\n  var valLength = val.length\n\n  if (encoding !== undefined) {\n    encoding = String(encoding).toLowerCase()\n    if (encoding === 'ucs2' || encoding === 'ucs-2' ||\n        encoding === 'utf16le' || encoding === 'utf-16le') {\n      if (arr.length < 2 || val.length < 2) {\n        return -1\n      }\n      indexSize = 2\n      arrLength /= 2\n      valLength /= 2\n      byteOffset /= 2\n    }\n  }\n\n  function read (buf, i) {\n    if (indexSize === 1) {\n      return buf[i]\n    } else {\n      return buf.readUInt16BE(i * indexSize)\n    }\n  }\n\n  var i\n  if (dir) {\n    var foundIndex = -1\n    for (i = byteOffset; i < arrLength; i++) {\n      if (read(arr, i) === read(val, foundIndex === -1 ? 0 : i - foundIndex)) {\n        if (foundIndex === -1) foundIndex = i\n        if (i - foundIndex + 1 === valLength) return foundIndex * indexSize\n      } else {\n        if (foundIndex !== -1) i -= i - foundIndex\n        foundIndex = -1\n      }\n    }\n  } else {\n    if (byteOffset + valLength > arrLength) byteOffset = arrLength - valLength\n    for (i = byteOffset; i >= 0; i--) {\n      var found = true\n      for (var j = 0; j < valLength; j++) {\n        if (read(arr, i + j) !== read(val, j)) {\n          found = false\n          break\n        }\n      }\n      if (found) return i\n    }\n  }\n\n  return -1\n}\n\nBuffer.prototype.includes = function includes (val, byteOffset, encoding) {\n  return this.indexOf(val, byteOffset, encoding) !== -1\n}\n\nBuffer.prototype.indexOf = function indexOf (val, byteOffset, encoding) {\n  return bidirectionalIndexOf(this, val, byteOffset, encoding, true)\n}\n\nBuffer.prototype.lastIndexOf = function lastIndexOf (val, byteOffset, encoding) {\n  return bidirectionalIndexOf(this, val, byteOffset, encoding, false)\n}\n\nfunction hexWrite (buf, string, offset, length) {\n  offset = Number(offset) || 0\n  var remaining = buf.length - offset\n  if (!length) {\n    length = remaining\n  } else {\n    length = Number(length)\n    if (length > remaining) {\n      length = remaining\n    }\n  }\n\n  // must be an even number of digits\n  var strLen = string.length\n  if (strLen % 2 !== 0) throw new TypeError('Invalid hex string')\n\n  if (length > strLen / 2) {\n    length = strLen / 2\n  }\n  for (var i = 0; i < length; ++i) {\n    var parsed = parseInt(string.substr(i * 2, 2), 16)\n    if (isNaN(parsed)) return i\n    buf[offset + i] = parsed\n  }\n  return i\n}\n\nfunction utf8Write (buf, string, offset, length) {\n  return blitBuffer(utf8ToBytes(string, buf.length - offset), buf, offset, length)\n}\n\nfunction asciiWrite (buf, string, offset, length) {\n  return blitBuffer(asciiToBytes(string), buf, offset, length)\n}\n\nfunction latin1Write (buf, string, offset, length) {\n  return asciiWrite(buf, string, offset, length)\n}\n\nfunction base64Write (buf, string, offset, length) {\n  return blitBuffer(base64ToBytes(string), buf, offset, length)\n}\n\nfunction ucs2Write (buf, string, offset, length) {\n  return blitBuffer(utf16leToBytes(string, buf.length - offset), buf, offset, length)\n}\n\nBuffer.prototype.write = function write (string, offset, length, encoding) {\n  // Buffer#write(string)\n  if (offset === undefined) {\n    encoding = 'utf8'\n    length = this.length\n    offset = 0\n  // Buffer#write(string, encoding)\n  } else if (length === undefined && typeof offset === 'string') {\n    encoding = offset\n    length = this.length\n    offset = 0\n  // Buffer#write(string, offset[, length][, encoding])\n  } else if (isFinite(offset)) {\n    offset = offset | 0\n    if (isFinite(length)) {\n      length = length | 0\n      if (encoding === undefined) encoding = 'utf8'\n    } else {\n      encoding = length\n      length = undefined\n    }\n  // legacy write(string, encoding, offset, length) - remove in v0.13\n  } else {\n    throw new Error(\n      'Buffer.write(string, encoding, offset[, length]) is no longer supported'\n    )\n  }\n\n  var remaining = this.length - offset\n  if (length === undefined || length > remaining) length = remaining\n\n  if ((string.length > 0 && (length < 0 || offset < 0)) || offset > this.length) {\n    throw new RangeError('Attempt to write outside buffer bounds')\n  }\n\n  if (!encoding) encoding = 'utf8'\n\n  var loweredCase = false\n  for (;;) {\n    switch (encoding) {\n      case 'hex':\n        return hexWrite(this, string, offset, length)\n\n      case 'utf8':\n      case 'utf-8':\n        return utf8Write(this, string, offset, length)\n\n      case 'ascii':\n        return asciiWrite(this, string, offset, length)\n\n      case 'latin1':\n      case 'binary':\n        return latin1Write(this, string, offset, length)\n\n      case 'base64':\n        // Warning: maxLength not taken into account in base64Write\n        return base64Write(this, string, offset, length)\n\n      case 'ucs2':\n      case 'ucs-2':\n      case 'utf16le':\n      case 'utf-16le':\n        return ucs2Write(this, string, offset, length)\n\n      default:\n        if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)\n        encoding = ('' + encoding).toLowerCase()\n        loweredCase = true\n    }\n  }\n}\n\nBuffer.prototype.toJSON = function toJSON () {\n  return {\n    type: 'Buffer',\n    data: Array.prototype.slice.call(this._arr || this, 0)\n  }\n}\n\nfunction base64Slice (buf, start, end) {\n  if (start === 0 && end === buf.length) {\n    return base64.fromByteArray(buf)\n  } else {\n    return base64.fromByteArray(buf.slice(start, end))\n  }\n}\n\nfunction utf8Slice (buf, start, end) {\n  end = Math.min(buf.length, end)\n  var res = []\n\n  var i = start\n  while (i < end) {\n    var firstByte = buf[i]\n    var codePoint = null\n    var bytesPerSequence = (firstByte > 0xEF) ? 4\n      : (firstByte > 0xDF) ? 3\n      : (firstByte > 0xBF) ? 2\n      : 1\n\n    if (i + bytesPerSequence <= end) {\n      var secondByte, thirdByte, fourthByte, tempCodePoint\n\n      switch (bytesPerSequence) {\n        case 1:\n          if (firstByte < 0x80) {\n            codePoint = firstByte\n          }\n          break\n        case 2:\n          secondByte = buf[i + 1]\n          if ((secondByte & 0xC0) === 0x80) {\n            tempCodePoint = (firstByte & 0x1F) << 0x6 | (secondByte & 0x3F)\n            if (tempCodePoint > 0x7F) {\n              codePoint = tempCodePoint\n            }\n          }\n          break\n        case 3:\n          secondByte = buf[i + 1]\n          thirdByte = buf[i + 2]\n          if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80) {\n            tempCodePoint = (firstByte & 0xF) << 0xC | (secondByte & 0x3F) << 0x6 | (thirdByte & 0x3F)\n            if (tempCodePoint > 0x7FF && (tempCodePoint < 0xD800 || tempCodePoint > 0xDFFF)) {\n              codePoint = tempCodePoint\n            }\n          }\n          break\n        case 4:\n          secondByte = buf[i + 1]\n          thirdByte = buf[i + 2]\n          fourthByte = buf[i + 3]\n          if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80 && (fourthByte & 0xC0) === 0x80) {\n            tempCodePoint = (firstByte & 0xF) << 0x12 | (secondByte & 0x3F) << 0xC | (thirdByte & 0x3F) << 0x6 | (fourthByte & 0x3F)\n            if (tempCodePoint > 0xFFFF && tempCodePoint < 0x110000) {\n              codePoint = tempCodePoint\n            }\n          }\n      }\n    }\n\n    if (codePoint === null) {\n      // we did not generate a valid codePoint so insert a\n      // replacement char (U+FFFD) and advance only 1 byte\n      codePoint = 0xFFFD\n      bytesPerSequence = 1\n    } else if (codePoint > 0xFFFF) {\n      // encode to utf16 (surrogate pair dance)\n      codePoint -= 0x10000\n      res.push(codePoint >>> 10 & 0x3FF | 0xD800)\n      codePoint = 0xDC00 | codePoint & 0x3FF\n    }\n\n    res.push(codePoint)\n    i += bytesPerSequence\n  }\n\n  return decodeCodePointsArray(res)\n}\n\n// Based on http://stackoverflow.com/a/22747272/680742, the browser with\n// the lowest limit is Chrome, with 0x10000 args.\n// We go 1 magnitude less, for safety\nvar MAX_ARGUMENTS_LENGTH = 0x1000\n\nfunction decodeCodePointsArray (codePoints) {\n  var len = codePoints.length\n  if (len <= MAX_ARGUMENTS_LENGTH) {\n    return String.fromCharCode.apply(String, codePoints) // avoid extra slice()\n  }\n\n  // Decode in chunks to avoid \"call stack size exceeded\".\n  var res = ''\n  var i = 0\n  while (i < len) {\n    res += String.fromCharCode.apply(\n      String,\n      codePoints.slice(i, i += MAX_ARGUMENTS_LENGTH)\n    )\n  }\n  return res\n}\n\nfunction asciiSlice (buf, start, end) {\n  var ret = ''\n  end = Math.min(buf.length, end)\n\n  for (var i = start; i < end; ++i) {\n    ret += String.fromCharCode(buf[i] & 0x7F)\n  }\n  return ret\n}\n\nfunction latin1Slice (buf, start, end) {\n  var ret = ''\n  end = Math.min(buf.length, end)\n\n  for (var i = start; i < end; ++i) {\n    ret += String.fromCharCode(buf[i])\n  }\n  return ret\n}\n\nfunction hexSlice (buf, start, end) {\n  var len = buf.length\n\n  if (!start || start < 0) start = 0\n  if (!end || end < 0 || end > len) end = len\n\n  var out = ''\n  for (var i = start; i < end; ++i) {\n    out += toHex(buf[i])\n  }\n  return out\n}\n\nfunction utf16leSlice (buf, start, end) {\n  var bytes = buf.slice(start, end)\n  var res = ''\n  for (var i = 0; i < bytes.length; i += 2) {\n    res += String.fromCharCode(bytes[i] + bytes[i + 1] * 256)\n  }\n  return res\n}\n\nBuffer.prototype.slice = function slice (start, end) {\n  var len = this.length\n  start = ~~start\n  end = end === undefined ? len : ~~end\n\n  if (start < 0) {\n    start += len\n    if (start < 0) start = 0\n  } else if (start > len) {\n    start = len\n  }\n\n  if (end < 0) {\n    end += len\n    if (end < 0) end = 0\n  } else if (end > len) {\n    end = len\n  }\n\n  if (end < start) end = start\n\n  var newBuf\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    newBuf = this.subarray(start, end)\n    newBuf.__proto__ = Buffer.prototype\n  } else {\n    var sliceLen = end - start\n    newBuf = new Buffer(sliceLen, undefined)\n    for (var i = 0; i < sliceLen; ++i) {\n      newBuf[i] = this[i + start]\n    }\n  }\n\n  return newBuf\n}\n\n/*\n * Need to make sure that buffer isn't trying to write out of bounds.\n */\nfunction checkOffset (offset, ext, length) {\n  if ((offset % 1) !== 0 || offset < 0) throw new RangeError('offset is not uint')\n  if (offset + ext > length) throw new RangeError('Trying to access beyond buffer length')\n}\n\nBuffer.prototype.readUIntLE = function readUIntLE (offset, byteLength, noAssert) {\n  offset = offset | 0\n  byteLength = byteLength | 0\n  if (!noAssert) checkOffset(offset, byteLength, this.length)\n\n  var val = this[offset]\n  var mul = 1\n  var i = 0\n  while (++i < byteLength && (mul *= 0x100)) {\n    val += this[offset + i] * mul\n  }\n\n  return val\n}\n\nBuffer.prototype.readUIntBE = function readUIntBE (offset, byteLength, noAssert) {\n  offset = offset | 0\n  byteLength = byteLength | 0\n  if (!noAssert) {\n    checkOffset(offset, byteLength, this.length)\n  }\n\n  var val = this[offset + --byteLength]\n  var mul = 1\n  while (byteLength > 0 && (mul *= 0x100)) {\n    val += this[offset + --byteLength] * mul\n  }\n\n  return val\n}\n\nBuffer.prototype.readUInt8 = function readUInt8 (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 1, this.length)\n  return this[offset]\n}\n\nBuffer.prototype.readUInt16LE = function readUInt16LE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 2, this.length)\n  return this[offset] | (this[offset + 1] << 8)\n}\n\nBuffer.prototype.readUInt16BE = function readUInt16BE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 2, this.length)\n  return (this[offset] << 8) | this[offset + 1]\n}\n\nBuffer.prototype.readUInt32LE = function readUInt32LE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length)\n\n  return ((this[offset]) |\n      (this[offset + 1] << 8) |\n      (this[offset + 2] << 16)) +\n      (this[offset + 3] * 0x1000000)\n}\n\nBuffer.prototype.readUInt32BE = function readUInt32BE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length)\n\n  return (this[offset] * 0x1000000) +\n    ((this[offset + 1] << 16) |\n    (this[offset + 2] << 8) |\n    this[offset + 3])\n}\n\nBuffer.prototype.readIntLE = function readIntLE (offset, byteLength, noAssert) {\n  offset = offset | 0\n  byteLength = byteLength | 0\n  if (!noAssert) checkOffset(offset, byteLength, this.length)\n\n  var val = this[offset]\n  var mul = 1\n  var i = 0\n  while (++i < byteLength && (mul *= 0x100)) {\n    val += this[offset + i] * mul\n  }\n  mul *= 0x80\n\n  if (val >= mul) val -= Math.pow(2, 8 * byteLength)\n\n  return val\n}\n\nBuffer.prototype.readIntBE = function readIntBE (offset, byteLength, noAssert) {\n  offset = offset | 0\n  byteLength = byteLength | 0\n  if (!noAssert) checkOffset(offset, byteLength, this.length)\n\n  var i = byteLength\n  var mul = 1\n  var val = this[offset + --i]\n  while (i > 0 && (mul *= 0x100)) {\n    val += this[offset + --i] * mul\n  }\n  mul *= 0x80\n\n  if (val >= mul) val -= Math.pow(2, 8 * byteLength)\n\n  return val\n}\n\nBuffer.prototype.readInt8 = function readInt8 (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 1, this.length)\n  if (!(this[offset] & 0x80)) return (this[offset])\n  return ((0xff - this[offset] + 1) * -1)\n}\n\nBuffer.prototype.readInt16LE = function readInt16LE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 2, this.length)\n  var val = this[offset] | (this[offset + 1] << 8)\n  return (val & 0x8000) ? val | 0xFFFF0000 : val\n}\n\nBuffer.prototype.readInt16BE = function readInt16BE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 2, this.length)\n  var val = this[offset + 1] | (this[offset] << 8)\n  return (val & 0x8000) ? val | 0xFFFF0000 : val\n}\n\nBuffer.prototype.readInt32LE = function readInt32LE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length)\n\n  return (this[offset]) |\n    (this[offset + 1] << 8) |\n    (this[offset + 2] << 16) |\n    (this[offset + 3] << 24)\n}\n\nBuffer.prototype.readInt32BE = function readInt32BE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length)\n\n  return (this[offset] << 24) |\n    (this[offset + 1] << 16) |\n    (this[offset + 2] << 8) |\n    (this[offset + 3])\n}\n\nBuffer.prototype.readFloatLE = function readFloatLE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length)\n  return ieee754.read(this, offset, true, 23, 4)\n}\n\nBuffer.prototype.readFloatBE = function readFloatBE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length)\n  return ieee754.read(this, offset, false, 23, 4)\n}\n\nBuffer.prototype.readDoubleLE = function readDoubleLE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 8, this.length)\n  return ieee754.read(this, offset, true, 52, 8)\n}\n\nBuffer.prototype.readDoubleBE = function readDoubleBE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 8, this.length)\n  return ieee754.read(this, offset, false, 52, 8)\n}\n\nfunction checkInt (buf, value, offset, ext, max, min) {\n  if (!Buffer.isBuffer(buf)) throw new TypeError('\"buffer\" argument must be a Buffer instance')\n  if (value > max || value < min) throw new RangeError('\"value\" argument is out of bounds')\n  if (offset + ext > buf.length) throw new RangeError('Index out of range')\n}\n\nBuffer.prototype.writeUIntLE = function writeUIntLE (value, offset, byteLength, noAssert) {\n  value = +value\n  offset = offset | 0\n  byteLength = byteLength | 0\n  if (!noAssert) {\n    var maxBytes = Math.pow(2, 8 * byteLength) - 1\n    checkInt(this, value, offset, byteLength, maxBytes, 0)\n  }\n\n  var mul = 1\n  var i = 0\n  this[offset] = value & 0xFF\n  while (++i < byteLength && (mul *= 0x100)) {\n    this[offset + i] = (value / mul) & 0xFF\n  }\n\n  return offset + byteLength\n}\n\nBuffer.prototype.writeUIntBE = function writeUIntBE (value, offset, byteLength, noAssert) {\n  value = +value\n  offset = offset | 0\n  byteLength = byteLength | 0\n  if (!noAssert) {\n    var maxBytes = Math.pow(2, 8 * byteLength) - 1\n    checkInt(this, value, offset, byteLength, maxBytes, 0)\n  }\n\n  var i = byteLength - 1\n  var mul = 1\n  this[offset + i] = value & 0xFF\n  while (--i >= 0 && (mul *= 0x100)) {\n    this[offset + i] = (value / mul) & 0xFF\n  }\n\n  return offset + byteLength\n}\n\nBuffer.prototype.writeUInt8 = function writeUInt8 (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 1, 0xff, 0)\n  if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value)\n  this[offset] = (value & 0xff)\n  return offset + 1\n}\n\nfunction objectWriteUInt16 (buf, value, offset, littleEndian) {\n  if (value < 0) value = 0xffff + value + 1\n  for (var i = 0, j = Math.min(buf.length - offset, 2); i < j; ++i) {\n    buf[offset + i] = (value & (0xff << (8 * (littleEndian ? i : 1 - i)))) >>>\n      (littleEndian ? i : 1 - i) * 8\n  }\n}\n\nBuffer.prototype.writeUInt16LE = function writeUInt16LE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value & 0xff)\n    this[offset + 1] = (value >>> 8)\n  } else {\n    objectWriteUInt16(this, value, offset, true)\n  }\n  return offset + 2\n}\n\nBuffer.prototype.writeUInt16BE = function writeUInt16BE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value >>> 8)\n    this[offset + 1] = (value & 0xff)\n  } else {\n    objectWriteUInt16(this, value, offset, false)\n  }\n  return offset + 2\n}\n\nfunction objectWriteUInt32 (buf, value, offset, littleEndian) {\n  if (value < 0) value = 0xffffffff + value + 1\n  for (var i = 0, j = Math.min(buf.length - offset, 4); i < j; ++i) {\n    buf[offset + i] = (value >>> (littleEndian ? i : 3 - i) * 8) & 0xff\n  }\n}\n\nBuffer.prototype.writeUInt32LE = function writeUInt32LE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset + 3] = (value >>> 24)\n    this[offset + 2] = (value >>> 16)\n    this[offset + 1] = (value >>> 8)\n    this[offset] = (value & 0xff)\n  } else {\n    objectWriteUInt32(this, value, offset, true)\n  }\n  return offset + 4\n}\n\nBuffer.prototype.writeUInt32BE = function writeUInt32BE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value >>> 24)\n    this[offset + 1] = (value >>> 16)\n    this[offset + 2] = (value >>> 8)\n    this[offset + 3] = (value & 0xff)\n  } else {\n    objectWriteUInt32(this, value, offset, false)\n  }\n  return offset + 4\n}\n\nBuffer.prototype.writeIntLE = function writeIntLE (value, offset, byteLength, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) {\n    var limit = Math.pow(2, 8 * byteLength - 1)\n\n    checkInt(this, value, offset, byteLength, limit - 1, -limit)\n  }\n\n  var i = 0\n  var mul = 1\n  var sub = 0\n  this[offset] = value & 0xFF\n  while (++i < byteLength && (mul *= 0x100)) {\n    if (value < 0 && sub === 0 && this[offset + i - 1] !== 0) {\n      sub = 1\n    }\n    this[offset + i] = ((value / mul) >> 0) - sub & 0xFF\n  }\n\n  return offset + byteLength\n}\n\nBuffer.prototype.writeIntBE = function writeIntBE (value, offset, byteLength, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) {\n    var limit = Math.pow(2, 8 * byteLength - 1)\n\n    checkInt(this, value, offset, byteLength, limit - 1, -limit)\n  }\n\n  var i = byteLength - 1\n  var mul = 1\n  var sub = 0\n  this[offset + i] = value & 0xFF\n  while (--i >= 0 && (mul *= 0x100)) {\n    if (value < 0 && sub === 0 && this[offset + i + 1] !== 0) {\n      sub = 1\n    }\n    this[offset + i] = ((value / mul) >> 0) - sub & 0xFF\n  }\n\n  return offset + byteLength\n}\n\nBuffer.prototype.writeInt8 = function writeInt8 (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 1, 0x7f, -0x80)\n  if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value)\n  if (value < 0) value = 0xff + value + 1\n  this[offset] = (value & 0xff)\n  return offset + 1\n}\n\nBuffer.prototype.writeInt16LE = function writeInt16LE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value & 0xff)\n    this[offset + 1] = (value >>> 8)\n  } else {\n    objectWriteUInt16(this, value, offset, true)\n  }\n  return offset + 2\n}\n\nBuffer.prototype.writeInt16BE = function writeInt16BE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value >>> 8)\n    this[offset + 1] = (value & 0xff)\n  } else {\n    objectWriteUInt16(this, value, offset, false)\n  }\n  return offset + 2\n}\n\nBuffer.prototype.writeInt32LE = function writeInt32LE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value & 0xff)\n    this[offset + 1] = (value >>> 8)\n    this[offset + 2] = (value >>> 16)\n    this[offset + 3] = (value >>> 24)\n  } else {\n    objectWriteUInt32(this, value, offset, true)\n  }\n  return offset + 4\n}\n\nBuffer.prototype.writeInt32BE = function writeInt32BE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)\n  if (value < 0) value = 0xffffffff + value + 1\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value >>> 24)\n    this[offset + 1] = (value >>> 16)\n    this[offset + 2] = (value >>> 8)\n    this[offset + 3] = (value & 0xff)\n  } else {\n    objectWriteUInt32(this, value, offset, false)\n  }\n  return offset + 4\n}\n\nfunction checkIEEE754 (buf, value, offset, ext, max, min) {\n  if (offset + ext > buf.length) throw new RangeError('Index out of range')\n  if (offset < 0) throw new RangeError('Index out of range')\n}\n\nfunction writeFloat (buf, value, offset, littleEndian, noAssert) {\n  if (!noAssert) {\n    checkIEEE754(buf, value, offset, 4, 3.4028234663852886e+38, -3.4028234663852886e+38)\n  }\n  ieee754.write(buf, value, offset, littleEndian, 23, 4)\n  return offset + 4\n}\n\nBuffer.prototype.writeFloatLE = function writeFloatLE (value, offset, noAssert) {\n  return writeFloat(this, value, offset, true, noAssert)\n}\n\nBuffer.prototype.writeFloatBE = function writeFloatBE (value, offset, noAssert) {\n  return writeFloat(this, value, offset, false, noAssert)\n}\n\nfunction writeDouble (buf, value, offset, littleEndian, noAssert) {\n  if (!noAssert) {\n    checkIEEE754(buf, value, offset, 8, 1.7976931348623157E+308, -1.7976931348623157E+308)\n  }\n  ieee754.write(buf, value, offset, littleEndian, 52, 8)\n  return offset + 8\n}\n\nBuffer.prototype.writeDoubleLE = function writeDoubleLE (value, offset, noAssert) {\n  return writeDouble(this, value, offset, true, noAssert)\n}\n\nBuffer.prototype.writeDoubleBE = function writeDoubleBE (value, offset, noAssert) {\n  return writeDouble(this, value, offset, false, noAssert)\n}\n\n// copy(targetBuffer, targetStart=0, sourceStart=0, sourceEnd=buffer.length)\nBuffer.prototype.copy = function copy (target, targetStart, start, end) {\n  if (!start) start = 0\n  if (!end && end !== 0) end = this.length\n  if (targetStart >= target.length) targetStart = target.length\n  if (!targetStart) targetStart = 0\n  if (end > 0 && end < start) end = start\n\n  // Copy 0 bytes; we're done\n  if (end === start) return 0\n  if (target.length === 0 || this.length === 0) return 0\n\n  // Fatal error conditions\n  if (targetStart < 0) {\n    throw new RangeError('targetStart out of bounds')\n  }\n  if (start < 0 || start >= this.length) throw new RangeError('sourceStart out of bounds')\n  if (end < 0) throw new RangeError('sourceEnd out of bounds')\n\n  // Are we oob?\n  if (end > this.length) end = this.length\n  if (target.length - targetStart < end - start) {\n    end = target.length - targetStart + start\n  }\n\n  var len = end - start\n  var i\n\n  if (this === target && start < targetStart && targetStart < end) {\n    // descending copy from end\n    for (i = len - 1; i >= 0; --i) {\n      target[i + targetStart] = this[i + start]\n    }\n  } else if (len < 1000 || !Buffer.TYPED_ARRAY_SUPPORT) {\n    // ascending copy from start\n    for (i = 0; i < len; ++i) {\n      target[i + targetStart] = this[i + start]\n    }\n  } else {\n    Uint8Array.prototype.set.call(\n      target,\n      this.subarray(start, start + len),\n      targetStart\n    )\n  }\n\n  return len\n}\n\n// Usage:\n//    buffer.fill(number[, offset[, end]])\n//    buffer.fill(buffer[, offset[, end]])\n//    buffer.fill(string[, offset[, end]][, encoding])\nBuffer.prototype.fill = function fill (val, start, end, encoding) {\n  // Handle string cases:\n  if (typeof val === 'string') {\n    if (typeof start === 'string') {\n      encoding = start\n      start = 0\n      end = this.length\n    } else if (typeof end === 'string') {\n      encoding = end\n      end = this.length\n    }\n    if (val.length === 1) {\n      var code = val.charCodeAt(0)\n      if (code < 256) {\n        val = code\n      }\n    }\n    if (encoding !== undefined && typeof encoding !== 'string') {\n      throw new TypeError('encoding must be a string')\n    }\n    if (typeof encoding === 'string' && !Buffer.isEncoding(encoding)) {\n      throw new TypeError('Unknown encoding: ' + encoding)\n    }\n  } else if (typeof val === 'number') {\n    val = val & 255\n  }\n\n  // Invalid ranges are not set to a default, so can range check early.\n  if (start < 0 || this.length < start || this.length < end) {\n    throw new RangeError('Out of range index')\n  }\n\n  if (end <= start) {\n    return this\n  }\n\n  start = start >>> 0\n  end = end === undefined ? this.length : end >>> 0\n\n  if (!val) val = 0\n\n  var i\n  if (typeof val === 'number') {\n    for (i = start; i < end; ++i) {\n      this[i] = val\n    }\n  } else {\n    var bytes = Buffer.isBuffer(val)\n      ? val\n      : utf8ToBytes(new Buffer(val, encoding).toString())\n    var len = bytes.length\n    for (i = 0; i < end - start; ++i) {\n      this[i + start] = bytes[i % len]\n    }\n  }\n\n  return this\n}\n\n// HELPER FUNCTIONS\n// ================\n\nvar INVALID_BASE64_RE = /[^+\\/0-9A-Za-z-_]/g\n\nfunction base64clean (str) {\n  // Node strips out invalid characters like \\n and \\t from the string, base64-js does not\n  str = stringtrim(str).replace(INVALID_BASE64_RE, '')\n  // Node converts strings with length < 2 to ''\n  if (str.length < 2) return ''\n  // Node allows for non-padded base64 strings (missing trailing ===), base64-js does not\n  while (str.length % 4 !== 0) {\n    str = str + '='\n  }\n  return str\n}\n\nfunction stringtrim (str) {\n  if (str.trim) return str.trim()\n  return str.replace(/^\\s+|\\s+$/g, '')\n}\n\nfunction toHex (n) {\n  if (n < 16) return '0' + n.toString(16)\n  return n.toString(16)\n}\n\nfunction utf8ToBytes (string, units) {\n  units = units || Infinity\n  var codePoint\n  var length = string.length\n  var leadSurrogate = null\n  var bytes = []\n\n  for (var i = 0; i < length; ++i) {\n    codePoint = string.charCodeAt(i)\n\n    // is surrogate component\n    if (codePoint > 0xD7FF && codePoint < 0xE000) {\n      // last char was a lead\n      if (!leadSurrogate) {\n        // no lead yet\n        if (codePoint > 0xDBFF) {\n          // unexpected trail\n          if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n          continue\n        } else if (i + 1 === length) {\n          // unpaired lead\n          if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n          continue\n        }\n\n        // valid lead\n        leadSurrogate = codePoint\n\n        continue\n      }\n\n      // 2 leads in a row\n      if (codePoint < 0xDC00) {\n        if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n        leadSurrogate = codePoint\n        continue\n      }\n\n      // valid surrogate pair\n      codePoint = (leadSurrogate - 0xD800 << 10 | codePoint - 0xDC00) + 0x10000\n    } else if (leadSurrogate) {\n      // valid bmp char, but last char was a lead\n      if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n    }\n\n    leadSurrogate = null\n\n    // encode utf8\n    if (codePoint < 0x80) {\n      if ((units -= 1) < 0) break\n      bytes.push(codePoint)\n    } else if (codePoint < 0x800) {\n      if ((units -= 2) < 0) break\n      bytes.push(\n        codePoint >> 0x6 | 0xC0,\n        codePoint & 0x3F | 0x80\n      )\n    } else if (codePoint < 0x10000) {\n      if ((units -= 3) < 0) break\n      bytes.push(\n        codePoint >> 0xC | 0xE0,\n        codePoint >> 0x6 & 0x3F | 0x80,\n        codePoint & 0x3F | 0x80\n      )\n    } else if (codePoint < 0x110000) {\n      if ((units -= 4) < 0) break\n      bytes.push(\n        codePoint >> 0x12 | 0xF0,\n        codePoint >> 0xC & 0x3F | 0x80,\n        codePoint >> 0x6 & 0x3F | 0x80,\n        codePoint & 0x3F | 0x80\n      )\n    } else {\n      throw new Error('Invalid code point')\n    }\n  }\n\n  return bytes\n}\n\nfunction asciiToBytes (str) {\n  var byteArray = []\n  for (var i = 0; i < str.length; ++i) {\n    // Node's code seems to be doing this and not & 0x7F..\n    byteArray.push(str.charCodeAt(i) & 0xFF)\n  }\n  return byteArray\n}\n\nfunction utf16leToBytes (str, units) {\n  var c, hi, lo\n  var byteArray = []\n  for (var i = 0; i < str.length; ++i) {\n    if ((units -= 2) < 0) break\n\n    c = str.charCodeAt(i)\n    hi = c >> 8\n    lo = c % 256\n    byteArray.push(lo)\n    byteArray.push(hi)\n  }\n\n  return byteArray\n}\n\nfunction base64ToBytes (str) {\n  return base64.toByteArray(base64clean(str))\n}\n\nfunction blitBuffer (src, dst, offset, length) {\n  for (var i = 0; i < length; ++i) {\n    if ((i + offset >= dst.length) || (i >= src.length)) break\n    dst[i + offset] = src[i]\n  }\n  return i\n}\n\nfunction isnan (val) {\n  return val !== val // eslint-disable-line no-self-compare\n}\n","/**\n * This is the web browser implementation of `debug()`.\n *\n * Expose `debug()` as the module.\n */\n\nexports = module.exports = require('./debug');\nexports.log = log;\nexports.formatArgs = formatArgs;\nexports.save = save;\nexports.load = load;\nexports.useColors = useColors;\nexports.storage = 'undefined' != typeof chrome\n               && 'undefined' != typeof chrome.storage\n                  ? chrome.storage.local\n                  : localstorage();\n\n/**\n * Colors.\n */\n\nexports.colors = [\n  'lightseagreen',\n  'forestgreen',\n  'goldenrod',\n  'dodgerblue',\n  'darkorchid',\n  'crimson'\n];\n\n/**\n * Currently only WebKit-based Web Inspectors, Firefox >= v31,\n * and the Firebug extension (any Firefox version) are known\n * to support \"%c\" CSS customizations.\n *\n * TODO: add a `localStorage` variable to explicitly enable/disable colors\n */\n\nfunction useColors() {\n  // NB: In an Electron preload script, document will be defined but not fully\n  // initialized. Since we know we're in Chrome, we'll just detect this case\n  // explicitly\n  if (typeof window !== 'undefined' && window && typeof window.process !== 'undefined' && window.process.type === 'renderer') {\n    return true;\n  }\n\n  // is webkit? http://stackoverflow.com/a/16459606/376773\n  // document is undefined in react-native: https://github.com/facebook/react-native/pull/1632\n  return (typeof document !== 'undefined' && document && 'WebkitAppearance' in document.documentElement.style) ||\n    // is firebug? http://stackoverflow.com/a/398120/376773\n    (typeof window !== 'undefined' && window && window.console && (console.firebug || (console.exception && console.table))) ||\n    // is firefox >= v31?\n    // https://developer.mozilla.org/en-US/docs/Tools/Web_Console#Styling_messages\n    (typeof navigator !== 'undefined' && navigator && navigator.userAgent && navigator.userAgent.toLowerCase().match(/firefox\\/(\\d+)/) && parseInt(RegExp.$1, 10) >= 31) ||\n    // double check webkit in userAgent just in case we are in a worker\n    (typeof navigator !== 'undefined' && navigator && navigator.userAgent && navigator.userAgent.toLowerCase().match(/applewebkit\\/(\\d+)/));\n}\n\n/**\n * Map %j to `JSON.stringify()`, since no Web Inspectors do that by default.\n */\n\nexports.formatters.j = function(v) {\n  try {\n    return JSON.stringify(v);\n  } catch (err) {\n    return '[UnexpectedJSONParseError]: ' + err.message;\n  }\n};\n\n\n/**\n * Colorize log arguments if enabled.\n *\n * @api public\n */\n\nfunction formatArgs(args) {\n  var useColors = this.useColors;\n\n  args[0] = (useColors ? '%c' : '')\n    + this.namespace\n    + (useColors ? ' %c' : ' ')\n    + args[0]\n    + (useColors ? '%c ' : ' ')\n    + '+' + exports.humanize(this.diff);\n\n  if (!useColors) return;\n\n  var c = 'color: ' + this.color;\n  args.splice(1, 0, c, 'color: inherit')\n\n  // the final \"%c\" is somewhat tricky, because there could be other\n  // arguments passed either before or after the %c, so we need to\n  // figure out the correct index to insert the CSS into\n  var index = 0;\n  var lastC = 0;\n  args[0].replace(/%[a-zA-Z%]/g, function(match) {\n    if ('%%' === match) return;\n    index++;\n    if ('%c' === match) {\n      // we only are interested in the *last* %c\n      // (the user may have provided their own)\n      lastC = index;\n    }\n  });\n\n  args.splice(lastC, 0, c);\n}\n\n/**\n * Invokes `console.log()` when available.\n * No-op when `console.log` is not a \"function\".\n *\n * @api public\n */\n\nfunction log() {\n  // this hackery is required for IE8/9, where\n  // the `console.log` function doesn't have 'apply'\n  return 'object' === typeof console\n    && console.log\n    && Function.prototype.apply.call(console.log, console, arguments);\n}\n\n/**\n * Save `namespaces`.\n *\n * @param {String} namespaces\n * @api private\n */\n\nfunction save(namespaces) {\n  try {\n    if (null == namespaces) {\n      exports.storage.removeItem('debug');\n    } else {\n      exports.storage.debug = namespaces;\n    }\n  } catch(e) {}\n}\n\n/**\n * Load `namespaces`.\n *\n * @return {String} returns the previously persisted debug modes\n * @api private\n */\n\nfunction load() {\n  try {\n    return exports.storage.debug;\n  } catch(e) {}\n\n  // If debug isn't set in LS, and we're in Electron, try to load $DEBUG\n  if (typeof process !== 'undefined' && 'env' in process) {\n    return process.env.DEBUG;\n  }\n}\n\n/**\n * Enable namespaces listed in `localStorage.debug` initially.\n */\n\nexports.enable(load());\n\n/**\n * Localstorage attempts to return the localstorage.\n *\n * This is necessary because safari throws\n * when a user disables cookies/localstorage\n * and you attempt to access it.\n *\n * @return {LocalStorage}\n * @api private\n */\n\nfunction localstorage() {\n  try {\n    return window.localStorage;\n  } catch (e) {}\n}\n","\n/**\n * This is the common logic for both the Node.js and web browser\n * implementations of `debug()`.\n *\n * Expose `debug()` as the module.\n */\n\nexports = module.exports = createDebug.debug = createDebug.default = createDebug;\nexports.coerce = coerce;\nexports.disable = disable;\nexports.enable = enable;\nexports.enabled = enabled;\nexports.humanize = require('ms');\n\n/**\n * The currently active debug mode names, and names to skip.\n */\n\nexports.names = [];\nexports.skips = [];\n\n/**\n * Map of special \"%n\" handling functions, for the debug \"format\" argument.\n *\n * Valid key names are a single, lower or upper-case letter, i.e. \"n\" and \"N\".\n */\n\nexports.formatters = {};\n\n/**\n * Previous log timestamp.\n */\n\nvar prevTime;\n\n/**\n * Select a color.\n * @param {String} namespace\n * @return {Number}\n * @api private\n */\n\nfunction selectColor(namespace) {\n  var hash = 0, i;\n\n  for (i in namespace) {\n    hash  = ((hash << 5) - hash) + namespace.charCodeAt(i);\n    hash |= 0; // Convert to 32bit integer\n  }\n\n  return exports.colors[Math.abs(hash) % exports.colors.length];\n}\n\n/**\n * Create a debugger with the given `namespace`.\n *\n * @param {String} namespace\n * @return {Function}\n * @api public\n */\n\nfunction createDebug(namespace) {\n\n  function debug() {\n    // disabled?\n    if (!debug.enabled) return;\n\n    var self = debug;\n\n    // set `diff` timestamp\n    var curr = +new Date();\n    var ms = curr - (prevTime || curr);\n    self.diff = ms;\n    self.prev = prevTime;\n    self.curr = curr;\n    prevTime = curr;\n\n    // turn the `arguments` into a proper Array\n    var args = new Array(arguments.length);\n    for (var i = 0; i < args.length; i++) {\n      args[i] = arguments[i];\n    }\n\n    args[0] = exports.coerce(args[0]);\n\n    if ('string' !== typeof args[0]) {\n      // anything else let's inspect with %O\n      args.unshift('%O');\n    }\n\n    // apply any `formatters` transformations\n    var index = 0;\n    args[0] = args[0].replace(/%([a-zA-Z%])/g, function(match, format) {\n      // if we encounter an escaped % then don't increase the array index\n      if (match === '%%') return match;\n      index++;\n      var formatter = exports.formatters[format];\n      if ('function' === typeof formatter) {\n        var val = args[index];\n        match = formatter.call(self, val);\n\n        // now we need to remove `args[index]` since it's inlined in the `format`\n        args.splice(index, 1);\n        index--;\n      }\n      return match;\n    });\n\n    // apply env-specific formatting (colors, etc.)\n    exports.formatArgs.call(self, args);\n\n    var logFn = debug.log || exports.log || console.log.bind(console);\n    logFn.apply(self, args);\n  }\n\n  debug.namespace = namespace;\n  debug.enabled = exports.enabled(namespace);\n  debug.useColors = exports.useColors();\n  debug.color = selectColor(namespace);\n\n  // env-specific initialization logic for debug instances\n  if ('function' === typeof exports.init) {\n    exports.init(debug);\n  }\n\n  return debug;\n}\n\n/**\n * Enables a debug mode by namespaces. This can include modes\n * separated by a colon and wildcards.\n *\n * @param {String} namespaces\n * @api public\n */\n\nfunction enable(namespaces) {\n  exports.save(namespaces);\n\n  var split = (namespaces || '').split(/[\\s,]+/);\n  var len = split.length;\n\n  for (var i = 0; i < len; i++) {\n    if (!split[i]) continue; // ignore empty strings\n    namespaces = split[i].replace(/\\*/g, '.*?');\n    if (namespaces[0] === '-') {\n      exports.skips.push(new RegExp('^' + namespaces.substr(1) + '$'));\n    } else {\n      exports.names.push(new RegExp('^' + namespaces + '$'));\n    }\n  }\n}\n\n/**\n * Disable debug output.\n *\n * @api public\n */\n\nfunction disable() {\n  exports.enable('');\n}\n\n/**\n * Returns true if the given mode name is enabled, false otherwise.\n *\n * @param {String} name\n * @return {Boolean}\n * @api public\n */\n\nfunction enabled(name) {\n  var i, len;\n  for (i = 0, len = exports.skips.length; i < len; i++) {\n    if (exports.skips[i].test(name)) {\n      return false;\n    }\n  }\n  for (i = 0, len = exports.names.length; i < len; i++) {\n    if (exports.names[i].test(name)) {\n      return true;\n    }\n  }\n  return false;\n}\n\n/**\n * Coerce `val`.\n *\n * @param {Mixed} val\n * @return {Mixed}\n * @api private\n */\n\nfunction coerce(val) {\n  if (val instanceof Error) return val.stack || val.message;\n  return val;\n}\n","exports.read = function (buffer, offset, isLE, mLen, nBytes) {\n  var e, m\n  var eLen = nBytes * 8 - mLen - 1\n  var eMax = (1 << eLen) - 1\n  var eBias = eMax >> 1\n  var nBits = -7\n  var i = isLE ? (nBytes - 1) : 0\n  var d = isLE ? -1 : 1\n  var s = buffer[offset + i]\n\n  i += d\n\n  e = s & ((1 << (-nBits)) - 1)\n  s >>= (-nBits)\n  nBits += eLen\n  for (; nBits > 0; e = e * 256 + buffer[offset + i], i += d, nBits -= 8) {}\n\n  m = e & ((1 << (-nBits)) - 1)\n  e >>= (-nBits)\n  nBits += mLen\n  for (; nBits > 0; m = m * 256 + buffer[offset + i], i += d, nBits -= 8) {}\n\n  if (e === 0) {\n    e = 1 - eBias\n  } else if (e === eMax) {\n    return m ? NaN : ((s ? -1 : 1) * Infinity)\n  } else {\n    m = m + Math.pow(2, mLen)\n    e = e - eBias\n  }\n  return (s ? -1 : 1) * m * Math.pow(2, e - mLen)\n}\n\nexports.write = function (buffer, value, offset, isLE, mLen, nBytes) {\n  var e, m, c\n  var eLen = nBytes * 8 - mLen - 1\n  var eMax = (1 << eLen) - 1\n  var eBias = eMax >> 1\n  var rt = (mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0)\n  var i = isLE ? 0 : (nBytes - 1)\n  var d = isLE ? 1 : -1\n  var s = value < 0 || (value === 0 && 1 / value < 0) ? 1 : 0\n\n  value = Math.abs(value)\n\n  if (isNaN(value) || value === Infinity) {\n    m = isNaN(value) ? 1 : 0\n    e = eMax\n  } else {\n    e = Math.floor(Math.log(value) / Math.LN2)\n    if (value * (c = Math.pow(2, -e)) < 1) {\n      e--\n      c *= 2\n    }\n    if (e + eBias >= 1) {\n      value += rt / c\n    } else {\n      value += rt * Math.pow(2, 1 - eBias)\n    }\n    if (value * c >= 2) {\n      e++\n      c /= 2\n    }\n\n    if (e + eBias >= eMax) {\n      m = 0\n      e = eMax\n    } else if (e + eBias >= 1) {\n      m = (value * c - 1) * Math.pow(2, mLen)\n      e = e + eBias\n    } else {\n      m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen)\n      e = 0\n    }\n  }\n\n  for (; mLen >= 8; buffer[offset + i] = m & 0xff, i += d, m /= 256, mLen -= 8) {}\n\n  e = (e << mLen) | m\n  eLen += mLen\n  for (; eLen > 0; buffer[offset + i] = e & 0xff, i += d, e /= 256, eLen -= 8) {}\n\n  buffer[offset + i - d] |= s * 128\n}\n","var toString = {}.toString;\n\nmodule.exports = Array.isArray || function (arr) {\n  return toString.call(arr) == '[object Array]';\n};\n","/*\n * $Id: base64.js,v 2.15 2014/04/05 12:58:57 dankogai Exp dankogai $\n *\n *  Licensed under the MIT license.\n *    http://opensource.org/licenses/mit-license\n *\n *  References:\n *    http://en.wikipedia.org/wiki/Base64\n */\n\n(function(global) {\n    'use strict';\n    // existing version for noConflict()\n    var _Base64 = global.Base64;\n    var version = \"2.1.9\";\n    // if node.js, we use Buffer\n    var buffer;\n    if (typeof module !== 'undefined' && module.exports) {\n        try {\n            buffer = require('buffer').Buffer;\n        } catch (err) {}\n    }\n    // constants\n    var b64chars\n        = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';\n    var b64tab = function(bin) {\n        var t = {};\n        for (var i = 0, l = bin.length; i < l; i++) t[bin.charAt(i)] = i;\n        return t;\n    }(b64chars);\n    var fromCharCode = String.fromCharCode;\n    // encoder stuff\n    var cb_utob = function(c) {\n        if (c.length < 2) {\n            var cc = c.charCodeAt(0);\n            return cc < 0x80 ? c\n                : cc < 0x800 ? (fromCharCode(0xc0 | (cc >>> 6))\n                                + fromCharCode(0x80 | (cc & 0x3f)))\n                : (fromCharCode(0xe0 | ((cc >>> 12) & 0x0f))\n                   + fromCharCode(0x80 | ((cc >>>  6) & 0x3f))\n                   + fromCharCode(0x80 | ( cc         & 0x3f)));\n        } else {\n            var cc = 0x10000\n                + (c.charCodeAt(0) - 0xD800) * 0x400\n                + (c.charCodeAt(1) - 0xDC00);\n            return (fromCharCode(0xf0 | ((cc >>> 18) & 0x07))\n                    + fromCharCode(0x80 | ((cc >>> 12) & 0x3f))\n                    + fromCharCode(0x80 | ((cc >>>  6) & 0x3f))\n                    + fromCharCode(0x80 | ( cc         & 0x3f)));\n        }\n    };\n    var re_utob = /[\\uD800-\\uDBFF][\\uDC00-\\uDFFFF]|[^\\x00-\\x7F]/g;\n    var utob = function(u) {\n        return u.replace(re_utob, cb_utob);\n    };\n    var cb_encode = function(ccc) {\n        var padlen = [0, 2, 1][ccc.length % 3],\n        ord = ccc.charCodeAt(0) << 16\n            | ((ccc.length > 1 ? ccc.charCodeAt(1) : 0) << 8)\n            | ((ccc.length > 2 ? ccc.charCodeAt(2) : 0)),\n        chars = [\n            b64chars.charAt( ord >>> 18),\n            b64chars.charAt((ord >>> 12) & 63),\n            padlen >= 2 ? '=' : b64chars.charAt((ord >>> 6) & 63),\n            padlen >= 1 ? '=' : b64chars.charAt(ord & 63)\n        ];\n        return chars.join('');\n    };\n    var btoa = global.btoa ? function(b) {\n        return global.btoa(b);\n    } : function(b) {\n        return b.replace(/[\\s\\S]{1,3}/g, cb_encode);\n    };\n    var _encode = buffer ? function (u) {\n        return (u.constructor === buffer.constructor ? u : new buffer(u))\n        .toString('base64')\n    }\n    : function (u) { return btoa(utob(u)) }\n    ;\n    var encode = function(u, urisafe) {\n        return !urisafe\n            ? _encode(String(u))\n            : _encode(String(u)).replace(/[+\\/]/g, function(m0) {\n                return m0 == '+' ? '-' : '_';\n            }).replace(/=/g, '');\n    };\n    var encodeURI = function(u) { return encode(u, true) };\n    // decoder stuff\n    var re_btou = new RegExp([\n        '[\\xC0-\\xDF][\\x80-\\xBF]',\n        '[\\xE0-\\xEF][\\x80-\\xBF]{2}',\n        '[\\xF0-\\xF7][\\x80-\\xBF]{3}'\n    ].join('|'), 'g');\n    var cb_btou = function(cccc) {\n        switch(cccc.length) {\n        case 4:\n            var cp = ((0x07 & cccc.charCodeAt(0)) << 18)\n                |    ((0x3f & cccc.charCodeAt(1)) << 12)\n                |    ((0x3f & cccc.charCodeAt(2)) <<  6)\n                |     (0x3f & cccc.charCodeAt(3)),\n            offset = cp - 0x10000;\n            return (fromCharCode((offset  >>> 10) + 0xD800)\n                    + fromCharCode((offset & 0x3FF) + 0xDC00));\n        case 3:\n            return fromCharCode(\n                ((0x0f & cccc.charCodeAt(0)) << 12)\n                    | ((0x3f & cccc.charCodeAt(1)) << 6)\n                    |  (0x3f & cccc.charCodeAt(2))\n            );\n        default:\n            return  fromCharCode(\n                ((0x1f & cccc.charCodeAt(0)) << 6)\n                    |  (0x3f & cccc.charCodeAt(1))\n            );\n        }\n    };\n    var btou = function(b) {\n        return b.replace(re_btou, cb_btou);\n    };\n    var cb_decode = function(cccc) {\n        var len = cccc.length,\n        padlen = len % 4,\n        n = (len > 0 ? b64tab[cccc.charAt(0)] << 18 : 0)\n            | (len > 1 ? b64tab[cccc.charAt(1)] << 12 : 0)\n            | (len > 2 ? b64tab[cccc.charAt(2)] <<  6 : 0)\n            | (len > 3 ? b64tab[cccc.charAt(3)]       : 0),\n        chars = [\n            fromCharCode( n >>> 16),\n            fromCharCode((n >>>  8) & 0xff),\n            fromCharCode( n         & 0xff)\n        ];\n        chars.length -= [0, 0, 2, 1][padlen];\n        return chars.join('');\n    };\n    var atob = global.atob ? function(a) {\n        return global.atob(a);\n    } : function(a){\n        return a.replace(/[\\s\\S]{1,4}/g, cb_decode);\n    };\n    var _decode = buffer ? function(a) {\n        return (a.constructor === buffer.constructor\n                ? a : new buffer(a, 'base64')).toString();\n    }\n    : function(a) { return btou(atob(a)) };\n    var decode = function(a){\n        return _decode(\n            String(a).replace(/[-_]/g, function(m0) { return m0 == '-' ? '+' : '/' })\n                .replace(/[^A-Za-z0-9\\+\\/]/g, '')\n        );\n    };\n    var noConflict = function() {\n        var Base64 = global.Base64;\n        global.Base64 = _Base64;\n        return Base64;\n    };\n    // export Base64\n    global.Base64 = {\n        VERSION: version,\n        atob: atob,\n        btoa: btoa,\n        fromBase64: decode,\n        toBase64: encode,\n        utob: utob,\n        encode: encode,\n        encodeURI: encodeURI,\n        btou: btou,\n        decode: decode,\n        noConflict: noConflict\n    };\n    // if ES5 is available, make Base64.extendString() available\n    if (typeof Object.defineProperty === 'function') {\n        var noEnum = function(v){\n            return {value:v,enumerable:false,writable:true,configurable:true};\n        };\n        global.Base64.extendString = function () {\n            Object.defineProperty(\n                String.prototype, 'fromBase64', noEnum(function () {\n                    return decode(this)\n                }));\n            Object.defineProperty(\n                String.prototype, 'toBase64', noEnum(function (urisafe) {\n                    return encode(this, urisafe)\n                }));\n            Object.defineProperty(\n                String.prototype, 'toBase64URI', noEnum(function () {\n                    return encode(this, true)\n                }));\n        };\n    }\n    // that's it!\n    if (global['Meteor']) {\n       Base64 = global.Base64; // for normal export in Meteor.js\n    }\n})(this);\n","/**\n * Helpers.\n */\n\nvar s = 1000\nvar m = s * 60\nvar h = m * 60\nvar d = h * 24\nvar y = d * 365.25\n\n/**\n * Parse or format the given `val`.\n *\n * Options:\n *\n *  - `long` verbose formatting [false]\n *\n * @param {String|Number} val\n * @param {Object} options\n * @throws {Error} throw an error if val is not a non-empty string or a number\n * @return {String|Number}\n * @api public\n */\n\nmodule.exports = function (val, options) {\n  options = options || {}\n  var type = typeof val\n  if (type === 'string' && val.length > 0) {\n    return parse(val)\n  } else if (type === 'number' && isNaN(val) === false) {\n    return options.long ?\n\t\t\tfmtLong(val) :\n\t\t\tfmtShort(val)\n  }\n  throw new Error('val is not a non-empty string or a valid number. val=' + JSON.stringify(val))\n}\n\n/**\n * Parse the given `str` and return milliseconds.\n *\n * @param {String} str\n * @return {Number}\n * @api private\n */\n\nfunction parse(str) {\n  str = String(str)\n  if (str.length > 10000) {\n    return\n  }\n  var match = /^((?:\\d+)?\\.?\\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|years?|yrs?|y)?$/i.exec(str)\n  if (!match) {\n    return\n  }\n  var n = parseFloat(match[1])\n  var type = (match[2] || 'ms').toLowerCase()\n  switch (type) {\n    case 'years':\n    case 'year':\n    case 'yrs':\n    case 'yr':\n    case 'y':\n      return n * y\n    case 'days':\n    case 'day':\n    case 'd':\n      return n * d\n    case 'hours':\n    case 'hour':\n    case 'hrs':\n    case 'hr':\n    case 'h':\n      return n * h\n    case 'minutes':\n    case 'minute':\n    case 'mins':\n    case 'min':\n    case 'm':\n      return n * m\n    case 'seconds':\n    case 'second':\n    case 'secs':\n    case 'sec':\n    case 's':\n      return n * s\n    case 'milliseconds':\n    case 'millisecond':\n    case 'msecs':\n    case 'msec':\n    case 'ms':\n      return n\n    default:\n      return undefined\n  }\n}\n\n/**\n * Short format for `ms`.\n *\n * @param {Number} ms\n * @return {String}\n * @api private\n */\n\nfunction fmtShort(ms) {\n  if (ms >= d) {\n    return Math.round(ms / d) + 'd'\n  }\n  if (ms >= h) {\n    return Math.round(ms / h) + 'h'\n  }\n  if (ms >= m) {\n    return Math.round(ms / m) + 'm'\n  }\n  if (ms >= s) {\n    return Math.round(ms / s) + 's'\n  }\n  return ms + 'ms'\n}\n\n/**\n * Long format for `ms`.\n *\n * @param {Number} ms\n * @return {String}\n * @api private\n */\n\nfunction fmtLong(ms) {\n  return plural(ms, d, 'day') ||\n    plural(ms, h, 'hour') ||\n    plural(ms, m, 'minute') ||\n    plural(ms, s, 'second') ||\n    ms + ' ms'\n}\n\n/**\n * Pluralization helper.\n */\n\nfunction plural(ms, n, name) {\n  if (ms < n) {\n    return\n  }\n  if (ms < n * 1.5) {\n    return Math.floor(ms / n) + ' ' + name\n  }\n  return Math.ceil(ms / n) + ' ' + name + 's'\n}\n","// shim for using process in browser\nvar process = module.exports = {};\n\n// cached from whatever global is present so that test runners that stub it\n// don't break things.  But we need to wrap it in a try catch in case it is\n// wrapped in strict mode code which doesn't define any globals.  It's inside a\n// function because try/catches deoptimize in certain engines.\n\nvar cachedSetTimeout;\nvar cachedClearTimeout;\n\nfunction defaultSetTimout() {\n    throw new Error('setTimeout has not been defined');\n}\nfunction defaultClearTimeout () {\n    throw new Error('clearTimeout has not been defined');\n}\n(function () {\n    try {\n        if (typeof setTimeout === 'function') {\n            cachedSetTimeout = setTimeout;\n        } else {\n            cachedSetTimeout = defaultSetTimout;\n        }\n    } catch (e) {\n        cachedSetTimeout = defaultSetTimout;\n    }\n    try {\n        if (typeof clearTimeout === 'function') {\n            cachedClearTimeout = clearTimeout;\n        } else {\n            cachedClearTimeout = defaultClearTimeout;\n        }\n    } catch (e) {\n        cachedClearTimeout = defaultClearTimeout;\n    }\n} ())\nfunction runTimeout(fun) {\n    if (cachedSetTimeout === setTimeout) {\n        //normal enviroments in sane situations\n        return setTimeout(fun, 0);\n    }\n    // if setTimeout wasn't available but was latter defined\n    if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {\n        cachedSetTimeout = setTimeout;\n        return setTimeout(fun, 0);\n    }\n    try {\n        // when when somebody has screwed with setTimeout but no I.E. maddness\n        return cachedSetTimeout(fun, 0);\n    } catch(e){\n        try {\n            // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally\n            return cachedSetTimeout.call(null, fun, 0);\n        } catch(e){\n            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error\n            return cachedSetTimeout.call(this, fun, 0);\n        }\n    }\n\n\n}\nfunction runClearTimeout(marker) {\n    if (cachedClearTimeout === clearTimeout) {\n        //normal enviroments in sane situations\n        return clearTimeout(marker);\n    }\n    // if clearTimeout wasn't available but was latter defined\n    if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {\n        cachedClearTimeout = clearTimeout;\n        return clearTimeout(marker);\n    }\n    try {\n        // when when somebody has screwed with setTimeout but no I.E. maddness\n        return cachedClearTimeout(marker);\n    } catch (e){\n        try {\n            // When we are in I.E. but the script has been evaled so I.E. doesn't  trust the global object when called normally\n            return cachedClearTimeout.call(null, marker);\n        } catch (e){\n            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error.\n            // Some versions of I.E. have different rules for clearTimeout vs setTimeout\n            return cachedClearTimeout.call(this, marker);\n        }\n    }\n\n\n\n}\nvar queue = [];\nvar draining = false;\nvar currentQueue;\nvar queueIndex = -1;\n\nfunction cleanUpNextTick() {\n    if (!draining || !currentQueue) {\n        return;\n    }\n    draining = false;\n    if (currentQueue.length) {\n        queue = currentQueue.concat(queue);\n    } else {\n        queueIndex = -1;\n    }\n    if (queue.length) {\n        drainQueue();\n    }\n}\n\nfunction drainQueue() {\n    if (draining) {\n        return;\n    }\n    var timeout = runTimeout(cleanUpNextTick);\n    draining = true;\n\n    var len = queue.length;\n    while(len) {\n        currentQueue = queue;\n        queue = [];\n        while (++queueIndex < len) {\n            if (currentQueue) {\n                currentQueue[queueIndex].run();\n            }\n        }\n        queueIndex = -1;\n        len = queue.length;\n    }\n    currentQueue = null;\n    draining = false;\n    runClearTimeout(timeout);\n}\n\nprocess.nextTick = function (fun) {\n    var args = new Array(arguments.length - 1);\n    if (arguments.length > 1) {\n        for (var i = 1; i < arguments.length; i++) {\n            args[i - 1] = arguments[i];\n        }\n    }\n    queue.push(new Item(fun, args));\n    if (queue.length === 1 && !draining) {\n        runTimeout(drainQueue);\n    }\n};\n\n// v8 likes predictible objects\nfunction Item(fun, array) {\n    this.fun = fun;\n    this.array = array;\n}\nItem.prototype.run = function () {\n    this.fun.apply(null, this.array);\n};\nprocess.title = 'browser';\nprocess.browser = true;\nprocess.env = {};\nprocess.argv = [];\nprocess.version = ''; // empty string to avoid regexp issues\nprocess.versions = {};\n\nfunction noop() {}\n\nprocess.on = noop;\nprocess.addListener = noop;\nprocess.once = noop;\nprocess.off = noop;\nprocess.removeListener = noop;\nprocess.removeAllListeners = noop;\nprocess.emit = noop;\n\nprocess.binding = function (name) {\n    throw new Error('process.binding is not supported');\n};\n\nprocess.cwd = function () { return '/' };\nprocess.chdir = function (dir) {\n    throw new Error('process.chdir is not supported');\n};\nprocess.umask = function() { return 0; };\n","/*! https://mths.be/utf8js v2.1.2 by @mathias */\n;(function(root) {\n\n\t// Detect free variables `exports`\n\tvar freeExports = typeof exports == 'object' && exports;\n\n\t// Detect free variable `module`\n\tvar freeModule = typeof module == 'object' && module &&\n\t\tmodule.exports == freeExports && module;\n\n\t// Detect free variable `global`, from Node.js or Browserified code,\n\t// and use it as `root`\n\tvar freeGlobal = typeof global == 'object' && global;\n\tif (freeGlobal.global === freeGlobal || freeGlobal.window === freeGlobal) {\n\t\troot = freeGlobal;\n\t}\n\n\t/*--------------------------------------------------------------------------*/\n\n\tvar stringFromCharCode = String.fromCharCode;\n\n\t// Taken from https://mths.be/punycode\n\tfunction ucs2decode(string) {\n\t\tvar output = [];\n\t\tvar counter = 0;\n\t\tvar length = string.length;\n\t\tvar value;\n\t\tvar extra;\n\t\twhile (counter < length) {\n\t\t\tvalue = string.charCodeAt(counter++);\n\t\t\tif (value >= 0xD800 && value <= 0xDBFF && counter < length) {\n\t\t\t\t// high surrogate, and there is a next character\n\t\t\t\textra = string.charCodeAt(counter++);\n\t\t\t\tif ((extra & 0xFC00) == 0xDC00) { // low surrogate\n\t\t\t\t\toutput.push(((value & 0x3FF) << 10) + (extra & 0x3FF) + 0x10000);\n\t\t\t\t} else {\n\t\t\t\t\t// unmatched surrogate; only append this code unit, in case the next\n\t\t\t\t\t// code unit is the high surrogate of a surrogate pair\n\t\t\t\t\toutput.push(value);\n\t\t\t\t\tcounter--;\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\toutput.push(value);\n\t\t\t}\n\t\t}\n\t\treturn output;\n\t}\n\n\t// Taken from https://mths.be/punycode\n\tfunction ucs2encode(array) {\n\t\tvar length = array.length;\n\t\tvar index = -1;\n\t\tvar value;\n\t\tvar output = '';\n\t\twhile (++index < length) {\n\t\t\tvalue = array[index];\n\t\t\tif (value > 0xFFFF) {\n\t\t\t\tvalue -= 0x10000;\n\t\t\t\toutput += stringFromCharCode(value >>> 10 & 0x3FF | 0xD800);\n\t\t\t\tvalue = 0xDC00 | value & 0x3FF;\n\t\t\t}\n\t\t\toutput += stringFromCharCode(value);\n\t\t}\n\t\treturn output;\n\t}\n\n\tfunction checkScalarValue(codePoint) {\n\t\tif (codePoint >= 0xD800 && codePoint <= 0xDFFF) {\n\t\t\tthrow Error(\n\t\t\t\t'Lone surrogate U+' + codePoint.toString(16).toUpperCase() +\n\t\t\t\t' is not a scalar value'\n\t\t\t);\n\t\t}\n\t}\n\t/*--------------------------------------------------------------------------*/\n\n\tfunction createByte(codePoint, shift) {\n\t\treturn stringFromCharCode(((codePoint >> shift) & 0x3F) | 0x80);\n\t}\n\n\tfunction encodeCodePoint(codePoint) {\n\t\tif ((codePoint & 0xFFFFFF80) == 0) { // 1-byte sequence\n\t\t\treturn stringFromCharCode(codePoint);\n\t\t}\n\t\tvar symbol = '';\n\t\tif ((codePoint & 0xFFFFF800) == 0) { // 2-byte sequence\n\t\t\tsymbol = stringFromCharCode(((codePoint >> 6) & 0x1F) | 0xC0);\n\t\t}\n\t\telse if ((codePoint & 0xFFFF0000) == 0) { // 3-byte sequence\n\t\t\tcheckScalarValue(codePoint);\n\t\t\tsymbol = stringFromCharCode(((codePoint >> 12) & 0x0F) | 0xE0);\n\t\t\tsymbol += createByte(codePoint, 6);\n\t\t}\n\t\telse if ((codePoint & 0xFFE00000) == 0) { // 4-byte sequence\n\t\t\tsymbol = stringFromCharCode(((codePoint >> 18) & 0x07) | 0xF0);\n\t\t\tsymbol += createByte(codePoint, 12);\n\t\t\tsymbol += createByte(codePoint, 6);\n\t\t}\n\t\tsymbol += stringFromCharCode((codePoint & 0x3F) | 0x80);\n\t\treturn symbol;\n\t}\n\n\tfunction utf8encode(string) {\n\t\tvar codePoints = ucs2decode(string);\n\t\tvar length = codePoints.length;\n\t\tvar index = -1;\n\t\tvar codePoint;\n\t\tvar byteString = '';\n\t\twhile (++index < length) {\n\t\t\tcodePoint = codePoints[index];\n\t\t\tbyteString += encodeCodePoint(codePoint);\n\t\t}\n\t\treturn byteString;\n\t}\n\n\t/*--------------------------------------------------------------------------*/\n\n\tfunction readContinuationByte() {\n\t\tif (byteIndex >= byteCount) {\n\t\t\tthrow Error('Invalid byte index');\n\t\t}\n\n\t\tvar continuationByte = byteArray[byteIndex] & 0xFF;\n\t\tbyteIndex++;\n\n\t\tif ((continuationByte & 0xC0) == 0x80) {\n\t\t\treturn continuationByte & 0x3F;\n\t\t}\n\n\t\t// If we end up here, it’s not a continuation byte\n\t\tthrow Error('Invalid continuation byte');\n\t}\n\n\tfunction decodeSymbol() {\n\t\tvar byte1;\n\t\tvar byte2;\n\t\tvar byte3;\n\t\tvar byte4;\n\t\tvar codePoint;\n\n\t\tif (byteIndex > byteCount) {\n\t\t\tthrow Error('Invalid byte index');\n\t\t}\n\n\t\tif (byteIndex == byteCount) {\n\t\t\treturn false;\n\t\t}\n\n\t\t// Read first byte\n\t\tbyte1 = byteArray[byteIndex] & 0xFF;\n\t\tbyteIndex++;\n\n\t\t// 1-byte sequence (no continuation bytes)\n\t\tif ((byte1 & 0x80) == 0) {\n\t\t\treturn byte1;\n\t\t}\n\n\t\t// 2-byte sequence\n\t\tif ((byte1 & 0xE0) == 0xC0) {\n\t\t\tbyte2 = readContinuationByte();\n\t\t\tcodePoint = ((byte1 & 0x1F) << 6) | byte2;\n\t\t\tif (codePoint >= 0x80) {\n\t\t\t\treturn codePoint;\n\t\t\t} else {\n\t\t\t\tthrow Error('Invalid continuation byte');\n\t\t\t}\n\t\t}\n\n\t\t// 3-byte sequence (may include unpaired surrogates)\n\t\tif ((byte1 & 0xF0) == 0xE0) {\n\t\t\tbyte2 = readContinuationByte();\n\t\t\tbyte3 = readContinuationByte();\n\t\t\tcodePoint = ((byte1 & 0x0F) << 12) | (byte2 << 6) | byte3;\n\t\t\tif (codePoint >= 0x0800) {\n\t\t\t\tcheckScalarValue(codePoint);\n\t\t\t\treturn codePoint;\n\t\t\t} else {\n\t\t\t\tthrow Error('Invalid continuation byte');\n\t\t\t}\n\t\t}\n\n\t\t// 4-byte sequence\n\t\tif ((byte1 & 0xF8) == 0xF0) {\n\t\t\tbyte2 = readContinuationByte();\n\t\t\tbyte3 = readContinuationByte();\n\t\t\tbyte4 = readContinuationByte();\n\t\t\tcodePoint = ((byte1 & 0x07) << 0x12) | (byte2 << 0x0C) |\n\t\t\t\t(byte3 << 0x06) | byte4;\n\t\t\tif (codePoint >= 0x010000 && codePoint <= 0x10FFFF) {\n\t\t\t\treturn codePoint;\n\t\t\t}\n\t\t}\n\n\t\tthrow Error('Invalid UTF-8 detected');\n\t}\n\n\tvar byteArray;\n\tvar byteCount;\n\tvar byteIndex;\n\tfunction utf8decode(byteString) {\n\t\tbyteArray = ucs2decode(byteString);\n\t\tbyteCount = byteArray.length;\n\t\tbyteIndex = 0;\n\t\tvar codePoints = [];\n\t\tvar tmp;\n\t\twhile ((tmp = decodeSymbol()) !== false) {\n\t\t\tcodePoints.push(tmp);\n\t\t}\n\t\treturn ucs2encode(codePoints);\n\t}\n\n\t/*--------------------------------------------------------------------------*/\n\n\tvar utf8 = {\n\t\t'version': '2.1.2',\n\t\t'encode': utf8encode,\n\t\t'decode': utf8decode\n\t};\n\n\t// Some AMD build optimizers, like r.js, check for specific condition patterns\n\t// like the following:\n\tif (\n\t\ttypeof define == 'function' &&\n\t\ttypeof define.amd == 'object' &&\n\t\tdefine.amd\n\t) {\n\t\tdefine(function() {\n\t\t\treturn utf8;\n\t\t});\n\t}\telse if (freeExports && !freeExports.nodeType) {\n\t\tif (freeModule) { // in Node.js or RingoJS v0.8.0+\n\t\t\tfreeModule.exports = utf8;\n\t\t} else { // in Narwhal or RingoJS v0.7.0-\n\t\t\tvar object = {};\n\t\t\tvar hasOwnProperty = object.hasOwnProperty;\n\t\t\tfor (var key in utf8) {\n\t\t\t\thasOwnProperty.call(utf8, key) && (freeExports[key] = utf8[key]);\n\t\t\t}\n\t\t}\n\t} else { // in Rhino or a web browser\n\t\troot.utf8 = utf8;\n\t}\n\n}(this));\n"]}"} \ No newline at end of file diff --git a/dist/GitHub.bundle.min.js b/dist/GitHub.bundle.min.js new file mode 100644 index 00000000..33a983b1 --- /dev/null +++ b/dist/GitHub.bundle.min.js @@ -0,0 +1,4 @@ +!function(e){if("object"==typeof exports&&"undefined"!=typeof module)module.exports=e();else if("function"==typeof define&&define.amd)define([],e);else{var t;t="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof self?self:this,t.GitHub=e()}}(function(){var e;return function e(t,r,n){function o(u,s){if(!r[u]){if(!t[u]){var a="function"==typeof require&&require;if(!s&&a)return a(u,!0);if(i)return i(u,!0);var f=new Error("Cannot find module '"+u+"'");throw f.code="MODULE_NOT_FOUND",f}var c=r[u]={exports:{}};t[u][0].call(c.exports,function(e){var r=t[u][1][e];return o(r?r:e)},c,c.exports,e,t,r,n)}return r[u].exports}for(var i="function"==typeof require&&require,u=0;u1&&void 0!==arguments[1]?arguments[1]:"https://api.github.com";o(this,e),this.__apiBase=r,this.__auth=t||{}}return i(e,[{key:"getGist",value:function(e){return new s.default(e,this.__auth,this.__apiBase)}},{key:"getUser",value:function(e){return new f.default(e,this.__auth,this.__apiBase)}},{key:"getOrganization",value:function(e){return new v.default(e,this.__auth,this.__apiBase)}},{key:"getTeam",value:function(e){return new w.default(e,this.__auth,this.__apiBase)}},{key:"getRepo",value:function(e,t){return new g.default(this._getFullName(e,t),this.__auth,this.__apiBase)}},{key:"getIssues",value:function(e,t){return new l.default(this._getFullName(e,t),this.__auth,this.__apiBase)}},{key:"search",value:function(e){return new p.default(e,this.__auth,this.__apiBase)}},{key:"getRateLimit",value:function(){return new y.default(this.__auth,this.__apiBase)}},{key:"getMarkdown",value:function(){return new T.default(this.__auth,this.__apiBase)}},{key:"getProject",value:function(e){return new A.default(e,this.__auth,this.__apiBase)}},{key:"_getFullName",value:function(e,t){var r=e;return t&&(r=e+"/"+t),r}}]),e}();t.exports=P},{"./Gist":1,"./Issue":3,"./Markdown":4,"./Organization":5,"./Project":6,"./RateLimit":7,"./Repository":8,"./Search":10,"./Team":11,"./User":12}],3:[function(e,t,r){"use strict";function n(e){return e&&e.__esModule?e:{default:e}}function o(e,t){if(!(e instanceof t))throw new TypeError("Cannot call a class as a function")}function i(e,t){if(!e)throw new ReferenceError("this hasn't been initialised - super() hasn't been called");return!t||"object"!=typeof t&&"function"!=typeof t?e:t}function u(e,t){if("function"!=typeof t&&null!==t)throw new TypeError("Super expression must either be null or a function, not "+typeof t);e.prototype=Object.create(t&&t.prototype,{constructor:{value:e,enumerable:!1,writable:!0,configurable:!0}}),t&&(Object.setPrototypeOf?Object.setPrototypeOf(e,t):e.__proto__=t)}var s=function(){function e(e,t){for(var r=0;r0&&void 0!==arguments[0]?arguments[0]:"",t=e.split(/\s*,\s*/);return t.reduce(function(e,t){return t.search(/rel="next"/)!==-1?(t.match(/<(.*)>/)||[])[1]:e},void 0)}function c(e,t){return function(r){var n=void 0;if(r.hasOwnProperty("config")){var o=r.response,i=o.status,u=o.statusText,s=r.config,a=s.method,f=s.url,c=i+" error making request "+a+" "+f+': "'+u+'"';n=new v(c,t,r),m(c+" "+JSON.stringify(r.data))}else n=r;if(!e)throw m("throwing error"),n;m("going to error callback"),e(n)}}var l="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(e){return typeof e}:function(e){return e&&"function"==typeof Symbol&&e.constructor===Symbol&&e!==Symbol.prototype?"symbol":typeof e},h=function(){function e(e,t){for(var r=0;r0&&void 0!==arguments[0]?arguments[0]:{};return e.visibility||e.affiliation||(e.type=e.type||"all"),e.sort=e.sort||"updated",e.per_page=e.per_page||"100",e}},{key:"_dateToISO",value:function(e){return e&&e instanceof Date&&(e=e.toISOString()),e}},{key:"_request",value:function(e,t,r,n,o){var i=this.__getURL(t),u=(r||{}).AcceptHeader;u&&delete r.AcceptHeader;var s=this.__getRequestHeaders(o,u),f={},h=r&&"object"===("undefined"==typeof r?"undefined":l(r))&&a(e);h&&(f=r,r=void 0);var p={url:i,method:e,headers:s,params:f,data:r,responseType:o?"text":"json"};m(p.method+" to "+p.url);var y=(0,d.default)(p).catch(c(n,t));return n&&y.then(function(e){e.data&&Object.keys(e.data).length>0?n(null,e.data,e):"GET"!==p.method&&Object.keys(e.data).length<1?n(null,e.status<300,e):n(null,e.data,e)}),y}},{key:"_request204or404",value:function(e,t,r){var n=arguments.length>3&&void 0!==arguments[3]?arguments[3]:"GET";return this._request(n,e,t).then(function(e){return r&&r(null,!0,e),!0},function(e){if(404===e.response.status)return r&&r(null,!1,e),!1;throw r&&r(e),e})}},{key:"_requestAllPages",value:function(e,t,r,n){var i=this;return n=n||[],this._request("GET",e,t).then(function(u){var s,a=void 0;if(u.data instanceof Array)a=u.data;else{if(!(u.data.items instanceof Array)){var c="cannot figure out how to append "+u.data+" to the result set";throw new v(c,e,u)}a=u.data.items}(s=n).push.apply(s,o(a));var l=f(u.headers.link);return l&&"number"!=typeof t.page?(m("getting next page: "+l),i._requestAllPages(l,t,r,n)):(r&&r(null,n,u),u.data=n,u)}).catch(c(r,e))}}]),e}();t.exports=b;var w=["GET","HEAD","DELETE"]},{axios:13,debug:40,"js-base64":44}],10:[function(e,t,r){"use strict";function n(e){return e&&e.__esModule?e:{default:e +}}function o(e,t){if(!(e instanceof t))throw new TypeError("Cannot call a class as a function")}function i(e,t){if(!e)throw new ReferenceError("this hasn't been initialised - super() hasn't been called");return!t||"object"!=typeof t&&"function"!=typeof t?e:t}function u(e,t){if("function"!=typeof t&&null!==t)throw new TypeError("Super expression must either be null or a function, not "+typeof t);e.prototype=Object.create(t&&t.prototype,{constructor:{value:e,enumerable:!1,writable:!0,configurable:!0}}),t&&(Object.setPrototypeOf?Object.setPrototypeOf(e,t):e.__proto__=t)}var s=function(){function e(e,t){for(var r=0;r1&&void 0!==arguments[1]?arguments[1]:{},n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:void 0,o={};return Object.keys(this.__defaults).forEach(function(e){o[e]=t.__defaults[e]}),Object.keys(r).forEach(function(e){o[e]=r[e]}),h("searching "+e+" with options:",o),this._requestAllPages("/search/"+e,o,n)}},{key:"forRepositories",value:function(e,t){return this._search("repositories",e,t)}},{key:"forCode",value:function(e,t){return this._search("code",e,t)}},{key:"forIssues",value:function(e,t){return this._search("issues",e,t)}},{key:"forUsers",value:function(e,t){return this._search("users",e,t)}}]),t}(f.default);t.exports=p},{"./Requestable":9,debug:40}],11:[function(e,t,r){"use strict";function n(e){return e&&e.__esModule?e:{default:e}}function o(e,t){if(!(e instanceof t))throw new TypeError("Cannot call a class as a function")}function i(e,t){if(!e)throw new ReferenceError("this hasn't been initialised - super() hasn't been called");return!t||"object"!=typeof t&&"function"!=typeof t?e:t}function u(e,t){if("function"!=typeof t&&null!==t)throw new TypeError("Super expression must either be null or a function, not "+typeof t);e.prototype=Object.create(t&&t.prototype,{constructor:{value:e,enumerable:!1,writable:!0,configurable:!0}}),t&&(Object.setPrototypeOf?Object.setPrototypeOf(e,t):e.__proto__=t)}var s=function(){function e(e,t){for(var r=0;r=200&&e<300}};f.headers={common:{Accept:"application/json, text/plain, */*"}},i.forEach(["delete","get","head"],function(e){f.headers[e]={}}),i.forEach(["post","put","patch"],function(e){f.headers[e]=i.merge(a)}),t.exports=f}).call(this,e("_process"))},{"./adapters/http":14,"./adapters/xhr":14,"./helpers/normalizeHeaderName":34,"./utils":37,_process:46}],27:[function(e,t,r){"use strict";t.exports=function(e,t){return function(){for(var r=new Array(arguments.length),n=0;n>8-s%1*8)){if(r=o.charCodeAt(s+=.75),r>255)throw new n;t=t<<8|r}return u}var i="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";n.prototype=new Error,n.prototype.code=5,n.prototype.name="InvalidCharacterError",t.exports=o},{}],29:[function(e,t,r){"use strict";function n(e){return encodeURIComponent(e).replace(/%40/gi,"@").replace(/%3A/gi,":").replace(/%24/g,"$").replace(/%2C/gi,",").replace(/%20/g,"+").replace(/%5B/gi,"[").replace(/%5D/gi,"]")}var o=e("./../utils");t.exports=function(e,t,r){if(!t)return e;var i;if(r)i=r(t);else if(o.isURLSearchParams(t))i=t.toString();else{var u=[];o.forEach(t,function(e,t){null!==e&&"undefined"!=typeof e&&(o.isArray(e)&&(t+="[]"),o.isArray(e)||(e=[e]),o.forEach(e,function(e){o.isDate(e)?e=e.toISOString():o.isObject(e)&&(e=JSON.stringify(e)),u.push(n(t)+"="+n(e))}))}),i=u.join("&")}return i&&(e+=(e.indexOf("?")===-1?"?":"&")+i),e}},{"./../utils":37}],30:[function(e,t,r){"use strict";t.exports=function(e,t){return e.replace(/\/+$/,"")+"/"+t.replace(/^\/+/,"")}},{}],31:[function(e,t,r){"use strict";var n=e("./../utils");t.exports=n.isStandardBrowserEnv()?function(){return{write:function(e,t,r,o,i,u){var s=[];s.push(e+"="+encodeURIComponent(t)),n.isNumber(r)&&s.push("expires="+new Date(r).toGMTString()),n.isString(o)&&s.push("path="+o),n.isString(i)&&s.push("domain="+i),u===!0&&s.push("secure"),document.cookie=s.join("; ")},read:function(e){var t=document.cookie.match(new RegExp("(^|;\\s*)("+e+")=([^;]*)"));return t?decodeURIComponent(t[3]):null},remove:function(e){this.write(e,"",Date.now()-864e5)}}}():function(){return{write:function(){},read:function(){return null},remove:function(){}}}()},{"./../utils":37}],32:[function(e,t,r){"use strict";t.exports=function(e){return/^([a-z][a-z\d\+\-\.]*:)?\/\//i.test(e)}},{}],33:[function(e,t,r){"use strict";var n=e("./../utils");t.exports=n.isStandardBrowserEnv()?function(){function e(e){var t=e;return r&&(o.setAttribute("href",t),t=o.href),o.setAttribute("href",t),{href:o.href,protocol:o.protocol?o.protocol.replace(/:$/,""):"",host:o.host,search:o.search?o.search.replace(/^\?/,""):"",hash:o.hash?o.hash.replace(/^#/,""):"",hostname:o.hostname,port:o.port,pathname:"/"===o.pathname.charAt(0)?o.pathname:"/"+o.pathname}}var t,r=/(msie|trident)/i.test(navigator.userAgent),o=document.createElement("a");return t=e(window.location.href),function(r){var o=n.isString(r)?e(r):r;return o.protocol===t.protocol&&o.host===t.host}}():function(){return function(){return!0}}()},{"./../utils":37}],34:[function(e,t,r){"use strict";var n=e("../utils");t.exports=function(e,t){n.forEach(e,function(r,n){n!==t&&n.toUpperCase()===t.toUpperCase()&&(e[t]=r,delete e[n])})}},{"../utils":37}],35:[function(e,t,r){"use strict";var n=e("./../utils");t.exports=function(e){var t,r,o,i={};return e?(n.forEach(e.split("\n"),function(e){o=e.indexOf(":"),t=n.trim(e.substr(0,o)).toLowerCase(),r=n.trim(e.substr(o+1)),t&&(i[t]=i[t]?i[t]+", "+r:r)}),i):i}},{"./../utils":37}],36:[function(e,t,r){"use strict";t.exports=function(e){return function(t){return e.apply(null,t)}}},{}],37:[function(e,t,r){"use strict";function n(e){return"[object Array]"===T.call(e)}function o(e){return"[object ArrayBuffer]"===T.call(e)}function i(e){return"undefined"!=typeof FormData&&e instanceof FormData}function u(e){var t;return t="undefined"!=typeof ArrayBuffer&&ArrayBuffer.isView?ArrayBuffer.isView(e):e&&e.buffer&&e.buffer instanceof ArrayBuffer}function s(e){return"string"==typeof e}function a(e){return"number"==typeof e}function f(e){return"undefined"==typeof e}function c(e){return null!==e&&"object"==typeof e}function l(e){return"[object Date]"===T.call(e)}function h(e){return"[object File]"===T.call(e)}function p(e){return"[object Blob]"===T.call(e)}function d(e){return"[object Function]"===T.call(e)}function y(e){return c(e)&&d(e.pipe)}function _(e){return"undefined"!=typeof URLSearchParams&&e instanceof URLSearchParams}function g(e){return e.replace(/^\s*/,"").replace(/\s*$/,"")}function m(){return"undefined"!=typeof window&&"undefined"!=typeof document&&"function"==typeof document.createElement}function v(e,t){if(null!==e&&"undefined"!=typeof e)if("object"==typeof e||n(e)||(e=[e]),n(e))for(var r=0,o=e.length;r0)throw new Error("Invalid string. Length must be a multiple of 4");return"="===e[t-2]?2:"="===e[t-1]?1:0}function o(e){return 3*e.length/4-n(e)}function i(e){var t,r,o,i,u,s,a=e.length;u=n(e),s=new l(3*a/4-u),o=u>0?a-4:a;var f=0;for(t=0,r=0;t>16&255,s[f++]=i>>8&255,s[f++]=255&i;return 2===u?(i=c[e.charCodeAt(t)]<<2|c[e.charCodeAt(t+1)]>>4,s[f++]=255&i):1===u&&(i=c[e.charCodeAt(t)]<<10|c[e.charCodeAt(t+1)]<<4|c[e.charCodeAt(t+2)]>>2,s[f++]=i>>8&255,s[f++]=255&i),s}function u(e){return f[e>>18&63]+f[e>>12&63]+f[e>>6&63]+f[63&e]}function s(e,t,r){for(var n,o=[],i=t;ic?c:a+u));return 1===n?(t=e[r-1],o+=f[t>>2],o+=f[t<<4&63],o+="=="):2===n&&(t=(e[r-2]<<8)+e[r-1],o+=f[t>>10],o+=f[t>>4&63],o+=f[t<<2&63],o+="="),i.push(o),i.join("")}r.byteLength=o,r.toByteArray=i,r.fromByteArray=a;for(var f=[],c=[],l="undefined"!=typeof Uint8Array?Uint8Array:Array,h="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/",p=0,d=h.length;p=o())throw new RangeError("Attempt to allocate Buffer larger than maximum size: 0x"+o().toString(16)+" bytes");return 0|e}function _(e){return+e!=e&&(e=0),u.alloc(+e)}function g(e,t){if(u.isBuffer(e))return e.length;if("undefined"!=typeof ArrayBuffer&&"function"==typeof ArrayBuffer.isView&&(ArrayBuffer.isView(e)||e instanceof ArrayBuffer))return e.byteLength;"string"!=typeof e&&(e=""+e);var r=e.length;if(0===r)return 0;for(var n=!1;;)switch(t){case"ascii":case"latin1":case"binary":return r;case"utf8":case"utf-8":case void 0:return z(e).length;case"ucs2":case"ucs-2":case"utf16le":case"utf-16le":return 2*r;case"hex":return r>>>1;case"base64":return V(e).length;default:if(n)return z(e).length;t=(""+t).toLowerCase(),n=!0}}function m(e,t,r){var n=!1;if((void 0===t||t<0)&&(t=0),t>this.length)return"";if((void 0===r||r>this.length)&&(r=this.length),r<=0)return"";if(r>>>=0,t>>>=0,r<=t)return"";for(e||(e="utf8");;)switch(e){case"hex":return x(this,t,r);case"utf8":case"utf-8":return q(this,t,r);case"ascii":return C(this,t,r);case"latin1":case"binary":return j(this,t,r);case"base64":return O(this,t,r);case"ucs2":case"ucs-2":case"utf16le":case"utf-16le":return B(this,t,r);default:if(n)throw new TypeError("Unknown encoding: "+e);e=(e+"").toLowerCase(),n=!0}}function v(e,t,r){var n=e[t];e[t]=e[r],e[r]=n}function b(e,t,r,n,o){if(0===e.length)return-1;if("string"==typeof r?(n=r,r=0):r>2147483647?r=2147483647:r<-2147483648&&(r=-2147483648),r=+r,isNaN(r)&&(r=o?0:e.length-1),r<0&&(r=e.length+r),r>=e.length){if(o)return-1;r=e.length-1}else if(r<0){if(!o)return-1;r=0}if("string"==typeof t&&(t=u.from(t,n)),u.isBuffer(t))return 0===t.length?-1:w(e,t,r,n,o);if("number"==typeof t)return t&=255,u.TYPED_ARRAY_SUPPORT&&"function"==typeof Uint8Array.prototype.indexOf?o?Uint8Array.prototype.indexOf.call(e,t,r):Uint8Array.prototype.lastIndexOf.call(e,t,r):w(e,[t],r,n,o);throw new TypeError("val must be string, number or Buffer")}function w(e,t,r,n,o){function i(e,t){return 1===u?e[t]:e.readUInt16BE(t*u)}var u=1,s=e.length,a=t.length;if(void 0!==n&&(n=String(n).toLowerCase(),"ucs2"===n||"ucs-2"===n||"utf16le"===n||"utf-16le"===n)){if(e.length<2||t.length<2)return-1;u=2,s/=2,a/=2,r/=2}var f;if(o){var c=-1;for(f=r;fs&&(r=s-a),f=r;f>=0;f--){for(var l=!0,h=0;ho&&(n=o)):n=o;var i=t.length;if(i%2!==0)throw new TypeError("Invalid hex string");n>i/2&&(n=i/2);for(var u=0;u239?4:i>223?3:i>191?2:1;if(o+s<=r){var a,f,c,l;switch(s){case 1:i<128&&(u=i);break;case 2:a=e[o+1],128===(192&a)&&(l=(31&i)<<6|63&a,l>127&&(u=l));break;case 3:a=e[o+1],f=e[o+2],128===(192&a)&&128===(192&f)&&(l=(15&i)<<12|(63&a)<<6|63&f,l>2047&&(l<55296||l>57343)&&(u=l));break;case 4:a=e[o+1],f=e[o+2],c=e[o+3],128===(192&a)&&128===(192&f)&&128===(192&c)&&(l=(15&i)<<18|(63&a)<<12|(63&f)<<6|63&c,l>65535&&l<1114112&&(u=l))}}null===u?(u=65533,s=1):u>65535&&(u-=65536,n.push(u>>>10&1023|55296),u=56320|1023&u),n.push(u),o+=s}return S(n)}function S(e){var t=e.length;if(t<=ee)return String.fromCharCode.apply(String,e);for(var r="",n=0;nn)&&(r=n);for(var o="",i=t;ir)throw new RangeError("Trying to access beyond buffer length")}function I(e,t,r,n,o,i){if(!u.isBuffer(e))throw new TypeError('"buffer" argument must be a Buffer instance');if(t>o||te.length)throw new RangeError("Index out of range")}function L(e,t,r,n){t<0&&(t=65535+t+1);for(var o=0,i=Math.min(e.length-r,2);o>>8*(n?o:1-o)}function D(e,t,r,n){t<0&&(t=4294967295+t+1);for(var o=0,i=Math.min(e.length-r,4);o>>8*(n?o:3-o)&255}function M(e,t,r,n,o,i){if(r+n>e.length)throw new RangeError("Index out of range");if(r<0)throw new RangeError("Index out of range")}function G(e,t,r,n,o){return o||M(e,t,r,4,3.4028234663852886e38,-3.4028234663852886e38),Z.write(e,t,r,n,23,4),r+4}function N(e,t,r,n,o){return o||M(e,t,r,8,1.7976931348623157e308,-1.7976931348623157e308),Z.write(e,t,r,n,52,8),r+8}function H(e){if(e=Y(e).replace(te,""),e.length<2)return"";for(;e.length%4!==0;)e+="=";return e}function Y(e){return e.trim?e.trim():e.replace(/^\s+|\s+$/g,"")}function F(e){return e<16?"0"+e.toString(16):e.toString(16)}function z(e,t){t=t||1/0;for(var r,n=e.length,o=null,i=[],u=0;u55295&&r<57344){if(!o){if(r>56319){(t-=3)>-1&&i.push(239,191,189);continue}if(u+1===n){(t-=3)>-1&&i.push(239,191,189);continue}o=r;continue}if(r<56320){(t-=3)>-1&&i.push(239,191,189),o=r;continue}r=(o-55296<<10|r-56320)+65536}else o&&(t-=3)>-1&&i.push(239,191,189);if(o=null,r<128){if((t-=1)<0)break;i.push(r)}else if(r<2048){if((t-=2)<0)break;i.push(r>>6|192,63&r|128)}else if(r<65536){if((t-=3)<0)break;i.push(r>>12|224,r>>6&63|128,63&r|128)}else{if(!(r<1114112))throw new Error("Invalid code point");if((t-=4)<0)break;i.push(r>>18|240,r>>12&63|128,r>>6&63|128,63&r|128)}}return i}function J(e){for(var t=[],r=0;r>8,o=r%256,i.push(o),i.push(n);return i}function V(e){return $.toByteArray(H(e))}function W(e,t,r,n){for(var o=0;o=t.length||o>=e.length);++o)t[o+r]=e[o];return o}function K(e){return e!==e}var $=e("base64-js"),Z=e("ieee754"),Q=e("isarray");r.Buffer=u,r.SlowBuffer=_,r.INSPECT_MAX_BYTES=50,u.TYPED_ARRAY_SUPPORT=void 0!==t.TYPED_ARRAY_SUPPORT?t.TYPED_ARRAY_SUPPORT:n(),r.kMaxLength=o(),u.poolSize=8192,u._augment=function(e){return e.__proto__=u.prototype,e},u.from=function(e,t,r){return s(null,e,t,r)},u.TYPED_ARRAY_SUPPORT&&(u.prototype.__proto__=Uint8Array.prototype,u.__proto__=Uint8Array,"undefined"!=typeof Symbol&&Symbol.species&&u[Symbol.species]===u&&Object.defineProperty(u,Symbol.species,{value:null,configurable:!0})),u.alloc=function(e,t,r){ +return f(null,e,t,r)},u.allocUnsafe=function(e){return c(null,e)},u.allocUnsafeSlow=function(e){return c(null,e)},u.isBuffer=function(e){return!(null==e||!e._isBuffer)},u.compare=function(e,t){if(!u.isBuffer(e)||!u.isBuffer(t))throw new TypeError("Arguments must be Buffers");if(e===t)return 0;for(var r=e.length,n=t.length,o=0,i=Math.min(r,n);o0&&(e=this.toString("hex",0,t).match(/.{2}/g).join(" "),this.length>t&&(e+=" ... ")),""},u.prototype.compare=function(e,t,r,n,o){if(!u.isBuffer(e))throw new TypeError("Argument must be a Buffer");if(void 0===t&&(t=0),void 0===r&&(r=e?e.length:0),void 0===n&&(n=0),void 0===o&&(o=this.length),t<0||r>e.length||n<0||o>this.length)throw new RangeError("out of range index");if(n>=o&&t>=r)return 0;if(n>=o)return-1;if(t>=r)return 1;if(t>>>=0,r>>>=0,n>>>=0,o>>>=0,this===e)return 0;for(var i=o-n,s=r-t,a=Math.min(i,s),f=this.slice(n,o),c=e.slice(t,r),l=0;lo)&&(r=o),e.length>0&&(r<0||t<0)||t>this.length)throw new RangeError("Attempt to write outside buffer bounds");n||(n="utf8");for(var i=!1;;)switch(n){case"hex":return E(this,e,t,r);case"utf8":case"utf-8":return T(this,e,t,r);case"ascii":return k(this,e,t,r);case"latin1":case"binary":return A(this,e,t,r);case"base64":return P(this,e,t,r);case"ucs2":case"ucs-2":case"utf16le":case"utf-16le":return R(this,e,t,r);default:if(i)throw new TypeError("Unknown encoding: "+n);n=(""+n).toLowerCase(),i=!0}},u.prototype.toJSON=function(){return{type:"Buffer",data:Array.prototype.slice.call(this._arr||this,0)}};var ee=4096;u.prototype.slice=function(e,t){var r=this.length;e=~~e,t=void 0===t?r:~~t,e<0?(e+=r,e<0&&(e=0)):e>r&&(e=r),t<0?(t+=r,t<0&&(t=0)):t>r&&(t=r),t0&&(o*=256);)n+=this[e+--t]*o;return n},u.prototype.readUInt8=function(e,t){return t||U(e,1,this.length),this[e]},u.prototype.readUInt16LE=function(e,t){return t||U(e,2,this.length),this[e]|this[e+1]<<8},u.prototype.readUInt16BE=function(e,t){return t||U(e,2,this.length),this[e]<<8|this[e+1]},u.prototype.readUInt32LE=function(e,t){return t||U(e,4,this.length),(this[e]|this[e+1]<<8|this[e+2]<<16)+16777216*this[e+3]},u.prototype.readUInt32BE=function(e,t){return t||U(e,4,this.length),16777216*this[e]+(this[e+1]<<16|this[e+2]<<8|this[e+3])},u.prototype.readIntLE=function(e,t,r){e|=0,t|=0,r||U(e,t,this.length);for(var n=this[e],o=1,i=0;++i=o&&(n-=Math.pow(2,8*t)),n},u.prototype.readIntBE=function(e,t,r){e|=0,t|=0,r||U(e,t,this.length);for(var n=t,o=1,i=this[e+--n];n>0&&(o*=256);)i+=this[e+--n]*o;return o*=128,i>=o&&(i-=Math.pow(2,8*t)),i},u.prototype.readInt8=function(e,t){return t||U(e,1,this.length),128&this[e]?(255-this[e]+1)*-1:this[e]},u.prototype.readInt16LE=function(e,t){t||U(e,2,this.length);var r=this[e]|this[e+1]<<8;return 32768&r?4294901760|r:r},u.prototype.readInt16BE=function(e,t){t||U(e,2,this.length);var r=this[e+1]|this[e]<<8;return 32768&r?4294901760|r:r},u.prototype.readInt32LE=function(e,t){return t||U(e,4,this.length),this[e]|this[e+1]<<8|this[e+2]<<16|this[e+3]<<24},u.prototype.readInt32BE=function(e,t){return t||U(e,4,this.length),this[e]<<24|this[e+1]<<16|this[e+2]<<8|this[e+3]},u.prototype.readFloatLE=function(e,t){return t||U(e,4,this.length),Z.read(this,e,!0,23,4)},u.prototype.readFloatBE=function(e,t){return t||U(e,4,this.length),Z.read(this,e,!1,23,4)},u.prototype.readDoubleLE=function(e,t){return t||U(e,8,this.length),Z.read(this,e,!0,52,8)},u.prototype.readDoubleBE=function(e,t){return t||U(e,8,this.length),Z.read(this,e,!1,52,8)},u.prototype.writeUIntLE=function(e,t,r,n){if(e=+e,t|=0,r|=0,!n){var o=Math.pow(2,8*r)-1;I(this,e,t,r,o,0)}var i=1,u=0;for(this[t]=255&e;++u=0&&(u*=256);)this[t+i]=e/u&255;return t+r},u.prototype.writeUInt8=function(e,t,r){return e=+e,t|=0,r||I(this,e,t,1,255,0),u.TYPED_ARRAY_SUPPORT||(e=Math.floor(e)),this[t]=255&e,t+1},u.prototype.writeUInt16LE=function(e,t,r){return e=+e,t|=0,r||I(this,e,t,2,65535,0),u.TYPED_ARRAY_SUPPORT?(this[t]=255&e,this[t+1]=e>>>8):L(this,e,t,!0),t+2},u.prototype.writeUInt16BE=function(e,t,r){return e=+e,t|=0,r||I(this,e,t,2,65535,0),u.TYPED_ARRAY_SUPPORT?(this[t]=e>>>8,this[t+1]=255&e):L(this,e,t,!1),t+2},u.prototype.writeUInt32LE=function(e,t,r){return e=+e,t|=0,r||I(this,e,t,4,4294967295,0),u.TYPED_ARRAY_SUPPORT?(this[t+3]=e>>>24,this[t+2]=e>>>16,this[t+1]=e>>>8,this[t]=255&e):D(this,e,t,!0),t+4},u.prototype.writeUInt32BE=function(e,t,r){return e=+e,t|=0,r||I(this,e,t,4,4294967295,0),u.TYPED_ARRAY_SUPPORT?(this[t]=e>>>24,this[t+1]=e>>>16,this[t+2]=e>>>8,this[t+3]=255&e):D(this,e,t,!1),t+4},u.prototype.writeIntLE=function(e,t,r,n){if(e=+e,t|=0,!n){var o=Math.pow(2,8*r-1);I(this,e,t,r,o-1,-o)}var i=0,u=1,s=0;for(this[t]=255&e;++i>0)-s&255;return t+r},u.prototype.writeIntBE=function(e,t,r,n){if(e=+e,t|=0,!n){var o=Math.pow(2,8*r-1);I(this,e,t,r,o-1,-o)}var i=r-1,u=1,s=0;for(this[t+i]=255&e;--i>=0&&(u*=256);)e<0&&0===s&&0!==this[t+i+1]&&(s=1),this[t+i]=(e/u>>0)-s&255;return t+r},u.prototype.writeInt8=function(e,t,r){return e=+e,t|=0,r||I(this,e,t,1,127,-128),u.TYPED_ARRAY_SUPPORT||(e=Math.floor(e)),e<0&&(e=255+e+1),this[t]=255&e,t+1},u.prototype.writeInt16LE=function(e,t,r){return e=+e,t|=0,r||I(this,e,t,2,32767,-32768),u.TYPED_ARRAY_SUPPORT?(this[t]=255&e,this[t+1]=e>>>8):L(this,e,t,!0),t+2},u.prototype.writeInt16BE=function(e,t,r){return e=+e,t|=0,r||I(this,e,t,2,32767,-32768),u.TYPED_ARRAY_SUPPORT?(this[t]=e>>>8,this[t+1]=255&e):L(this,e,t,!1),t+2},u.prototype.writeInt32LE=function(e,t,r){return e=+e,t|=0,r||I(this,e,t,4,2147483647,-2147483648),u.TYPED_ARRAY_SUPPORT?(this[t]=255&e,this[t+1]=e>>>8,this[t+2]=e>>>16,this[t+3]=e>>>24):D(this,e,t,!0),t+4},u.prototype.writeInt32BE=function(e,t,r){return e=+e,t|=0,r||I(this,e,t,4,2147483647,-2147483648),e<0&&(e=4294967295+e+1),u.TYPED_ARRAY_SUPPORT?(this[t]=e>>>24,this[t+1]=e>>>16,this[t+2]=e>>>8,this[t+3]=255&e):D(this,e,t,!1),t+4},u.prototype.writeFloatLE=function(e,t,r){return G(this,e,t,!0,r)},u.prototype.writeFloatBE=function(e,t,r){return G(this,e,t,!1,r)},u.prototype.writeDoubleLE=function(e,t,r){return N(this,e,t,!0,r)},u.prototype.writeDoubleBE=function(e,t,r){return N(this,e,t,!1,r)},u.prototype.copy=function(e,t,r,n){if(r||(r=0),n||0===n||(n=this.length),t>=e.length&&(t=e.length),t||(t=0),n>0&&n=this.length)throw new RangeError("sourceStart out of bounds");if(n<0)throw new RangeError("sourceEnd out of bounds");n>this.length&&(n=this.length),e.length-t=0;--o)e[o+t]=this[o+r];else if(i<1e3||!u.TYPED_ARRAY_SUPPORT)for(o=0;o>>=0,r=void 0===r?this.length:r>>>0,e||(e=0);var i;if("number"==typeof e)for(i=t;i=31||"undefined"!=typeof navigator&&navigator&&navigator.userAgent&&navigator.userAgent.toLowerCase().match(/applewebkit\/(\d+)/))}function i(e){var t=this.useColors;if(e[0]=(t?"%c":"")+this.namespace+(t?" %c":" ")+e[0]+(t?"%c ":" ")+"+"+r.humanize(this.diff),t){var n="color: "+this.color;e.splice(1,0,n,"color: inherit");var o=0,i=0;e[0].replace(/%[a-zA-Z%]/g,function(e){"%%"!==e&&(o++,"%c"===e&&(i=o))}),e.splice(i,0,n)}}function u(){return"object"==typeof console&&console.log&&Function.prototype.apply.call(console.log,console,arguments)}function s(e){try{null==e?r.storage.removeItem("debug"):r.storage.debug=e}catch(e){}}function a(){try{return r.storage.debug}catch(e){}if("undefined"!=typeof n&&"env"in n)return n.env.DEBUG}function f(){try{return window.localStorage}catch(e){}}r=t.exports=e("./debug"),r.log=u,r.formatArgs=i,r.save=s,r.load=a,r.useColors=o,r.storage="undefined"!=typeof chrome&&"undefined"!=typeof chrome.storage?chrome.storage.local:f(),r.colors=["lightseagreen","forestgreen","goldenrod","dodgerblue","darkorchid","crimson"],r.formatters.j=function(e){try{return JSON.stringify(e)}catch(e){return"[UnexpectedJSONParseError]: "+e.message}},r.enable(a())}).call(this,e("_process"))},{"./debug":41,_process:46}],41:[function(e,t,r){function n(e){var t,n=0;for(t in e)n=(n<<5)-n+e.charCodeAt(t),n|=0;return r.colors[Math.abs(n)%r.colors.length]}function o(e){function t(){if(t.enabled){var e=t,n=+new Date,o=n-(f||n);e.diff=o,e.prev=f,e.curr=n,f=n;for(var i=new Array(arguments.length),u=0;u>1,c=-7,l=r?o-1:0,h=r?-1:1,p=e[t+l];for(l+=h,i=p&(1<<-c)-1,p>>=-c,c+=s;c>0;i=256*i+e[t+l],l+=h,c-=8);for(u=i&(1<<-c)-1,i>>=-c,c+=n;c>0;u=256*u+e[t+l],l+=h,c-=8);if(0===i)i=1-f;else{if(i===a)return u?NaN:(p?-1:1)*(1/0);u+=Math.pow(2,n),i-=f}return(p?-1:1)*u*Math.pow(2,i-n)},r.write=function(e,t,r,n,o,i){var u,s,a,f=8*i-o-1,c=(1<>1,h=23===o?Math.pow(2,-24)-Math.pow(2,-77):0,p=n?0:i-1,d=n?1:-1,y=t<0||0===t&&1/t<0?1:0;for(t=Math.abs(t),isNaN(t)||t===1/0?(s=isNaN(t)?1:0,u=c):(u=Math.floor(Math.log(t)/Math.LN2),t*(a=Math.pow(2,-u))<1&&(u--,a*=2),t+=u+l>=1?h/a:h*Math.pow(2,1-l),t*a>=2&&(u++,a/=2),u+l>=c?(s=0,u=c):u+l>=1?(s=(t*a-1)*Math.pow(2,o),u+=l):(s=t*Math.pow(2,l-1)*Math.pow(2,o),u=0));o>=8;e[r+p]=255&s,p+=d,s/=256,o-=8);for(u=u<0;e[r+p]=255&u,p+=d,u/=256,f-=8);e[r+p-d]|=128*y}},{}],43:[function(e,t,r){var n={}.toString;t.exports=Array.isArray||function(e){return"[object Array]"==n.call(e)}},{}],44:[function(e,t,r){!function(r){"use strict";var n,o=r.Base64,i="2.1.9";if("undefined"!=typeof t&&t.exports)try{n=e("buffer").Buffer}catch(e){}var u="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/",s=function(e){for(var t={},r=0,n=e.length;r>>6)+a(128|63&t):a(224|t>>>12&15)+a(128|t>>>6&63)+a(128|63&t)}var t=65536+1024*(e.charCodeAt(0)-55296)+(e.charCodeAt(1)-56320);return a(240|t>>>18&7)+a(128|t>>>12&63)+a(128|t>>>6&63)+a(128|63&t)},c=/[\uD800-\uDBFF][\uDC00-\uDFFFF]|[^\x00-\x7F]/g,l=function(e){return e.replace(c,f)},h=function(e){var t=[0,2,1][e.length%3],r=e.charCodeAt(0)<<16|(e.length>1?e.charCodeAt(1):0)<<8|(e.length>2?e.charCodeAt(2):0),n=[u.charAt(r>>>18),u.charAt(r>>>12&63),t>=2?"=":u.charAt(r>>>6&63),t>=1?"=":u.charAt(63&r)];return n.join("")},p=r.btoa?function(e){return r.btoa(e)}:function(e){return e.replace(/[\s\S]{1,3}/g,h)},d=n?function(e){return(e.constructor===n.constructor?e:new n(e)).toString("base64")}:function(e){return p(l(e))},y=function(e,t){return t?d(String(e)).replace(/[+\/]/g,function(e){return"+"==e?"-":"_"}).replace(/=/g,""):d(String(e))},_=function(e){return y(e,!0)},g=new RegExp(["[À-ß][€-¿]","[à-ï][€-¿]{2}","[ð-÷][€-¿]{3}"].join("|"),"g"),m=function(e){switch(e.length){case 4:var t=(7&e.charCodeAt(0))<<18|(63&e.charCodeAt(1))<<12|(63&e.charCodeAt(2))<<6|63&e.charCodeAt(3),r=t-65536;return a((r>>>10)+55296)+a((1023&r)+56320);case 3:return a((15&e.charCodeAt(0))<<12|(63&e.charCodeAt(1))<<6|63&e.charCodeAt(2));default:return a((31&e.charCodeAt(0))<<6|63&e.charCodeAt(1))}},v=function(e){return e.replace(g,m)},b=function(e){var t=e.length,r=t%4,n=(t>0?s[e.charAt(0)]<<18:0)|(t>1?s[e.charAt(1)]<<12:0)|(t>2?s[e.charAt(2)]<<6:0)|(t>3?s[e.charAt(3)]:0),o=[a(n>>>16),a(n>>>8&255),a(255&n)];return o.length-=[0,0,2,1][r],o.join("")},w=r.atob?function(e){return r.atob(e)}:function(e){return e.replace(/[\s\S]{1,4}/g,b)},E=n?function(e){return(e.constructor===n.constructor?e:new n(e,"base64")).toString()}:function(e){return v(w(e))},T=function(e){return E(String(e).replace(/[-_]/g,function(e){return"-"==e?"+":"/"}).replace(/[^A-Za-z0-9\+\/]/g,""))},k=function(){var e=r.Base64;return r.Base64=o,e};if(r.Base64={VERSION:i,atob:w,btoa:p,fromBase64:T,toBase64:y,utob:l,encode:y,encodeURI:_,btou:v,decode:T,noConflict:k},"function"==typeof Object.defineProperty){var A=function(e){return{value:e,enumerable:!1,writable:!0,configurable:!0}};r.Base64.extendString=function(){Object.defineProperty(String.prototype,"fromBase64",A(function(){return T(this)})),Object.defineProperty(String.prototype,"toBase64",A(function(e){return y(this,e)})),Object.defineProperty(String.prototype,"toBase64URI",A(function(){return y(this,!0)}))}}r.Meteor&&(Base64=r.Base64)}(this)},{buffer:39}],45:[function(e,t,r){function n(e){if(e=String(e),!(e.length>1e4)){var t=/^((?:\d+)?\.?\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|years?|yrs?|y)?$/i.exec(e);if(t){var r=parseFloat(t[1]),n=(t[2]||"ms").toLowerCase();switch(n){case"years":case"year":case"yrs":case"yr":case"y":return r*l;case"days":case"day":case"d":return r*c;case"hours":case"hour":case"hrs":case"hr":case"h":return r*f;case"minutes":case"minute":case"mins":case"min":case"m":return r*a;case"seconds":case"second":case"secs":case"sec":case"s":return r*s;case"milliseconds":case"millisecond":case"msecs":case"msec":case"ms":return r;default:return}}}}function o(e){return e>=c?Math.round(e/c)+"d":e>=f?Math.round(e/f)+"h":e>=a?Math.round(e/a)+"m":e>=s?Math.round(e/s)+"s":e+"ms"}function i(e){return u(e,c,"day")||u(e,f,"hour")||u(e,a,"minute")||u(e,s,"second")||e+" ms"}function u(e,t,r){if(!(e0)return n(e);if("number"===r&&isNaN(e)===!1)return t.long?i(e):o(e);throw new Error("val is not a non-empty string or a valid number. val="+JSON.stringify(e))}},{}],46:[function(e,t,r){function n(){throw new Error("setTimeout has not been defined")}function o(){throw new Error("clearTimeout has not been defined")}function i(e){if(l===setTimeout)return setTimeout(e,0);if((l===n||!l)&&setTimeout)return l=setTimeout,setTimeout(e,0);try{return l(e,0)}catch(t){try{return l.call(null,e,0)}catch(t){return l.call(this,e,0)}}}function u(e){if(h===clearTimeout)return clearTimeout(e);if((h===o||!h)&&clearTimeout)return h=clearTimeout,clearTimeout(e);try{return h(e)}catch(t){try{return h.call(null,e)}catch(t){return h.call(this,e)}}}function s(){_&&d&&(_=!1,d.length?y=d.concat(y):g=-1,y.length&&a())}function a(){if(!_){var e=i(s);_=!0;for(var t=y.length;t;){for(d=y,y=[];++g1)for(var r=1;r=55296&&t<=56319&&o65535&&(t-=65536,o+=b(t>>>10&1023|55296),t=56320|1023&t),o+=b(t);return o}function s(e){if(e>=55296&&e<=57343)throw Error("Lone surrogate U+"+e.toString(16).toUpperCase()+" is not a scalar value")}function a(e,t){return b(e>>t&63|128)}function f(e){if(0==(4294967168&e))return b(e);var t="";return 0==(4294965248&e)?t=b(e>>6&31|192):0==(4294901760&e)?(s(e),t=b(e>>12&15|224),t+=a(e,6)):0==(4292870144&e)&&(t=b(e>>18&7|240),t+=a(e,12),t+=a(e,6)),t+=b(63&e|128)}function c(e){for(var t,r=i(e),n=r.length,o=-1,u="";++o=m)throw Error("Invalid byte index");var e=255&g[v];if(v++,128==(192&e))return 63&e;throw Error("Invalid continuation byte")}function h(){var e,t,r,n,o;if(v>m)throw Error("Invalid byte index");if(v==m)return!1;if(e=255&g[v],v++,0==(128&e))return e;if(192==(224&e)){if(t=l(),o=(31&e)<<6|t,o>=128)return o;throw Error("Invalid continuation byte")}if(224==(240&e)){if(t=l(),r=l(),o=(15&e)<<12|t<<6|r,o>=2048)return s(o),o;throw Error("Invalid continuation byte")}if(240==(248&e)&&(t=l(),r=l(),n=l(),o=(7&e)<<18|t<<12|r<<6|n,o>=65536&&o<=1114111))return o;throw Error("Invalid UTF-8 detected")}function p(e){g=i(e),m=g.length,v=0;for(var t,r=[];(t=h())!==!1;)r.push(t);return u(r)}var d="object"==typeof n&&n,y="object"==typeof r&&r&&r.exports==d&&r,_="object"==typeof t&&t;_.global!==_&&_.window!==_||(o=_);var g,m,v,b=String.fromCharCode,w={version:"2.1.2",encode:c,decode:p};if("function"==typeof e&&"object"==typeof e.amd&&e.amd)e(function(){return w});else if(d&&!d.nodeType)if(y)y.exports=w;else{var E={},T=E.hasOwnProperty;for(var k in w)T.call(w,k)&&(d[k]=w[k])}else o.utf8=w}(this)}).call(this,"undefined"!=typeof global?global:"undefined"!=typeof self?self:"undefined"!=typeof window?window:{})},{}]},{},[2])(2)}); +//# sourceMappingURL=GitHub.bundle.min.js.map diff --git a/dist/GitHub.bundle.min.js.map b/dist/GitHub.bundle.min.js.map new file mode 100644 index 00000000..568a06ec --- /dev/null +++ b/dist/GitHub.bundle.min.js.map @@ -0,0 +1 @@ +{"version":3,"sources":["node_modules/browser-pack/_prelude.js","lib/Gist.js","lib/GitHub.js","lib/Issue.js","lib/Markdown.js","lib/Organization.js","lib/Project.js","lib/RateLimit.js","lib/Repository.js","lib/Requestable.js","lib/Search.js","lib/Team.js","lib/User.js","node_modules/axios/index.js","node_modules/axios/lib/adapters/xhr.js","node_modules/axios/lib/axios.js","node_modules/axios/lib/cancel/Cancel.js","node_modules/axios/lib/cancel/CancelToken.js","node_modules/axios/lib/cancel/isCancel.js","node_modules/axios/lib/core/Axios.js","node_modules/axios/lib/core/InterceptorManager.js","node_modules/axios/lib/core/createError.js","node_modules/axios/lib/core/dispatchRequest.js","node_modules/axios/lib/core/enhanceError.js","node_modules/axios/lib/core/settle.js","node_modules/axios/lib/core/transformData.js","node_modules/axios/lib/defaults.js","node_modules/axios/lib/helpers/bind.js","node_modules/axios/lib/helpers/btoa.js","node_modules/axios/lib/helpers/buildURL.js","node_modules/axios/lib/helpers/combineURLs.js","node_modules/axios/lib/helpers/cookies.js","node_modules/axios/lib/helpers/isAbsoluteURL.js","node_modules/axios/lib/helpers/isURLSameOrigin.js","node_modules/axios/lib/helpers/normalizeHeaderName.js","node_modules/axios/lib/helpers/parseHeaders.js","node_modules/axios/lib/helpers/spread.js","node_modules/axios/lib/utils.js","node_modules/base64-js/index.js","node_modules/buffer/index.js","node_modules/debug/src/browser.js","node_modules/debug/src/debug.js","node_modules/ieee754/index.js","node_modules/isarray/index.js","node_modules/js-base64/base64.js","node_modules/ms/index.js","node_modules/process/browser.js","node_modules/utf8/utf8.js"],"names":["f","exports","module","define","amd","g","window","global","self","this","GitHub","e","t","n","r","s","o","u","a","require","i","Error","code","l","call","length","1","_Requestable2","Gist","id","auth","apiBase","_classCallCheck","_this","_possibleConstructorReturn","__proto__","Object","getPrototypeOf","__id","cb","_request","gist","_this2","then","response","data","_request204or404","_requestAllPages","revision","comment","body","_Gist","_User","_Issue","_Search","_RateLimit","_Repository","_Organization","_Team","_Markdown","_Project","arguments","undefined","__apiBase","__auth","_Gist2","default","user","_User2","organization","_Organization2","teamId","_Team2","repo","_Repository2","_getFullName","_Issue2","query","_Search2","_RateLimit2","_Markdown2","_Project2","fullname","Issue","repository","__repository","issueData","options","issue","milestone","milestoneData","labelData","label","Markdown","Organization","__name","requestOptions","_getOptionsWithDefaults","direction","username","AcceptHeader","Project","colId","position","listProjectColumns","_ref","Promise","all","map","column","cardsInColumns","cards","reduce","prev","_ref2","push","apply","_toConsumableArray","catch","err","cardId","column_id","RateLimit","_utf","_jsBase","_debug","log","_debug2","Repository","__fullname","__currentTree","branch","sha","ref","number","base","head","since","_dateToISO","until","path","treeSHA","content","postBody","_getContentObject","_utf2","encode","encoding","Buffer","toString","Blob","Base64","_typeof","JSON","stringify","baseTreeSHA","blobSHA","newTree","base_tree","tree","mode","type","baseSHA","parent","message","parents","commitSHA","force","raw","encodeURI","oldBranch","newBranch","_this3","getRef","object","createRef","_this4","getSha","deleteCommit","oldPath","newPath","_this5","oldSha","getTree","_ref2$data","createTree","_ref3","commit","_ref4","updateHead","_this6","filePath","shouldEncode","author","committer","methodHasNoBody","method","METHODS_WITH_NO_BODY","indexOf","getNextPage","linksHeader","links","split","nextUrl","link","search","match","callbackErrorOrThrow","error","hasOwnProperty","_object$response","status","statusText","_object$config","config","url","ResponseError","_axios","request","Requestable","token","password","__AcceptHeader","__authorizationHeader","newCacheBuster","Date","getTime","replace","headers","Content-Type","Accept","Authorization","visibility","affiliation","sort","per_page","date","toISOString","__getURL","__getRequestHeaders","queryParams","shouldUseDataAsParams","params","responseType","requestPromise","_axios2","keys","results","_results","thisGroup","Array","items","page","Search","defaults","__defaults","withOptions","forEach","prop","_search","Team","__teamId","owner","User","__user","endpoint","__getScopedUrl","before","utils","settle","buildURL","parseHeaders","isURLSameOrigin","createError","btoa","bind","resolve","reject","requestData","requestHeaders","isFormData","XMLHttpRequest","loadEvent","xDomain","process","env","NODE_ENV","XDomainRequest","onprogress","ontimeout","open","toUpperCase","paramsSerializer","timeout","readyState","responseURL","responseHeaders","getAllResponseHeaders","responseData","responseText","onerror","isStandardBrowserEnv","cookies","xsrfValue","withCredentials","xsrfCookieName","read","xsrfHeaderName","val","key","toLowerCase","setRequestHeader","onDownloadProgress","addEventListener","onUploadProgress","upload","cancelToken","promise","cancel","abort","send","createInstance","defaultConfig","context","Axios","instance","prototype","extend","axios","create","instanceConfig","merge","Cancel","CancelToken","isCancel","promises","spread","__CANCEL__","executor","TypeError","resolvePromise","reason","throwIfRequested","source","c","value","interceptors","InterceptorManager","dispatchRequest","isAbsoluteURL","combineURLs","baseURL","chain","interceptor","unshift","fulfilled","rejected","shift","handlers","use","eject","fn","h","enhanceError","throwIfCancellationRequested","transformData","transformRequest","common","adapter","transformResponse","validateStatus","fns","setContentTypeIfUnset","isUndefined","getDefaultAdapter","normalizeHeaderName","PROTECTION_PREFIX","DEFAULT_CONTENT_TYPE","isArrayBuffer","isStream","isFile","isBlob","isArrayBufferView","buffer","isURLSearchParams","isObject","parse","maxContentLength","thisArg","args","E","input","block","charCode","str","String","output","idx","chars","charAt","charCodeAt","name","encodeURIComponent","serializedParams","parts","isArray","v","isDate","join","relativeURL","write","expires","domain","secure","cookie","isNumber","toGMTString","isString","document","RegExp","decodeURIComponent","remove","now","test","resolveURL","href","msie","urlParsingNode","setAttribute","protocol","host","hash","hostname","port","pathname","originURL","navigator","userAgent","createElement","location","requestURL","parsed","normalizedName","line","trim","substr","callback","arr","FormData","result","ArrayBuffer","isView","isFunction","pipe","URLSearchParams","obj","assignValue","b","placeHoldersCount","b64","len","byteLength","toByteArray","j","tmp","placeHolders","Arr","L","revLookup","tripletToBase64","num","lookup","encodeChunk","uint8","start","end","fromByteArray","extraBytes","maxChunkLength","len2","Uint8Array","typedArraySupport","foo","subarray","kMaxLength","TYPED_ARRAY_SUPPORT","createBuffer","that","RangeError","arg","encodingOrOffset","allocUnsafe","from","fromArrayBuffer","fromString","fromObject","assertSize","size","alloc","fill","checked","string","isEncoding","actual","slice","fromArrayLike","array","byteOffset","isBuffer","copy","isnan","SlowBuffer","loweredCase","utf8ToBytes","base64ToBytes","slowToString","hexSlice","utf8Slice","asciiSlice","latin1Slice","base64Slice","utf16leSlice","swap","m","bidirectionalIndexOf","dir","isNaN","arrayIndexOf","lastIndexOf","buf","indexSize","readUInt16BE","arrLength","valLength","foundIndex","found","hexWrite","offset","Number","remaining","strLen","parseInt","utf8Write","blitBuffer","asciiWrite","asciiToBytes","latin1Write","base64Write","ucs2Write","utf16leToBytes","base64","Math","min","res","firstByte","codePoint","bytesPerSequence","secondByte","thirdByte","fourthByte","tempCodePoint","decodeCodePointsArray","codePoints","MAX_ARGUMENTS_LENGTH","fromCharCode","ret","out","toHex","bytes","checkOffset","ext","checkInt","max","objectWriteUInt16","littleEndian","objectWriteUInt32","checkIEEE754","writeFloat","noAssert","ieee754","writeDouble","base64clean","stringtrim","INVALID_BASE64_RE","units","Infinity","leadSurrogate","byteArray","hi","lo","src","dst","INSPECT_MAX_BYTES","poolSize","_augment","Symbol","species","defineProperty","configurable","allocUnsafeSlow","_isBuffer","compare","x","y","concat","list","pos","swap16","swap32","swap64","equals","inspect","target","thisStart","thisEnd","thisCopy","targetCopy","includes","isFinite","toJSON","_arr","newBuf","sliceLen","readUIntLE","mul","readUIntBE","readUInt8","readUInt16LE","readUInt32LE","readUInt32BE","readIntLE","pow","readIntBE","readInt8","readInt16LE","readInt16BE","readInt32LE","readInt32BE","readFloatLE","readFloatBE","readDoubleLE","readDoubleBE","writeUIntLE","maxBytes","writeUIntBE","writeUInt8","floor","writeUInt16LE","writeUInt16BE","writeUInt32LE","writeUInt32BE","writeIntLE","limit","sub","writeIntBE","writeInt8","writeInt16LE","writeInt16BE","writeInt32LE","writeInt32BE","writeFloatLE","writeFloatBE","writeDoubleLE","writeDoubleBE","targetStart","set","useColors","documentElement","style","console","firebug","exception","table","$1","formatArgs","namespace","humanize","diff","color","splice","index","lastC","Function","save","namespaces","storage","removeItem","debug","load","DEBUG","localstorage","localStorage","chrome","local","colors","formatters","enable","selectColor","abs","createDebug","enabled","curr","ms","prevTime","coerce","format","formatter","logFn","init","skips","names","disable","stack","isLE","mLen","nBytes","eLen","eMax","eBias","nBits","d","NaN","rt","LN2","_Base64","version","b64chars","b64tab","bin","cb_utob","cc","re_utob","utob","cb_encode","ccc","padlen","ord","_encode","constructor","urisafe","m0","re_btou","cb_btou","cccc","cp","btou","cb_decode","atob","_decode","decode","noConflict","VERSION","fromBase64","toBase64","noEnum","enumerable","writable","extendString","exec","parseFloat","fmtShort","round","fmtLong","plural","ceil","long","defaultSetTimout","defaultClearTimeout","runTimeout","fun","cachedSetTimeout","setTimeout","runClearTimeout","marker","cachedClearTimeout","clearTimeout","cleanUpNextTick","draining","currentQueue","queue","queueIndex","drainQueue","run","Item","noop","nextTick","title","browser","argv","versions","on","addListener","once","off","removeListener","removeAllListeners","emit","binding","cwd","chdir","umask","root","ucs2decode","extra","counter","ucs2encode","stringFromCharCode","checkScalarValue","createByte","encodeCodePoint","symbol","utf8encode","byteString","readContinuationByte","byteIndex","byteCount","continuationByte","decodeSymbol","byte1","byte2","byte3","byte4","utf8decode","freeExports","freeModule","freeGlobal","utf8","nodeType"],"mappings":"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","file":"GitHub.bundle.min.js","sourcesContent":["(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require==\"function\"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error(\"Cannot find module '\"+o+\"'\");throw f.code=\"MODULE_NOT_FOUND\",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require==\"function\"&&require;for(var o=0;o {\n this.__id = response.data.id;\n return response;\n });\n }\n\n /**\n * Delete a gist.\n * @see https://developer.github.com/v3/gists/#delete-a-gist\n * @param {Requestable.callback} [cb] - will receive true if the request succeeds\n * @return {Promise} - the Promise for the http request\n */\n delete(cb) {\n return this._request('DELETE', `/gists/${this.__id}`, null, cb);\n }\n\n /**\n * Fork a gist.\n * @see https://developer.github.com/v3/gists/#fork-a-gist\n * @param {Requestable.callback} [cb] - the function that will receive the gist\n * @return {Promise} - the Promise for the http request\n */\n fork(cb) {\n return this._request('POST', `/gists/${this.__id}/forks`, null, cb);\n }\n\n /**\n * Update a gist.\n * @see https://developer.github.com/v3/gists/#edit-a-gist\n * @param {Object} gist - the new data for the gist\n * @param {Requestable.callback} [cb] - the function that receives the API result\n * @return {Promise} - the Promise for the http request\n */\n update(gist, cb) {\n return this._request('PATCH', `/gists/${this.__id}`, gist, cb);\n }\n\n /**\n * Star a gist.\n * @see https://developer.github.com/v3/gists/#star-a-gist\n * @param {Requestable.callback} [cb] - will receive true if the request is successful\n * @return {Promise} - the Promise for the http request\n */\n star(cb) {\n return this._request('PUT', `/gists/${this.__id}/star`, null, cb);\n }\n\n /**\n * Unstar a gist.\n * @see https://developer.github.com/v3/gists/#unstar-a-gist\n * @param {Requestable.callback} [cb] - will receive true if the request is successful\n * @return {Promise} - the Promise for the http request\n */\n unstar(cb) {\n return this._request('DELETE', `/gists/${this.__id}/star`, null, cb);\n }\n\n /**\n * Check if a gist is starred by the user.\n * @see https://developer.github.com/v3/gists/#check-if-a-gist-is-starred\n * @param {Requestable.callback} [cb] - will receive true if the gist is starred and false if the gist is not starred\n * @return {Promise} - the Promise for the http request\n */\n isStarred(cb) {\n return this._request204or404(`/gists/${this.__id}/star`, null, cb);\n }\n\n /**\n * List the gist's commits\n * @see https://developer.github.com/v3/gists/#list-gist-commits\n * @param {Requestable.callback} [cb] - will receive the array of commits\n * @return {Promise} - the Promise for the http request\n */\n listCommits(cb) {\n return this._requestAllPages(`/gists/${this.__id}/commits`, null, cb);\n }\n\n /**\n * Fetch one of the gist's revision.\n * @see https://developer.github.com/v3/gists/#get-a-specific-revision-of-a-gist\n * @param {string} revision - the id of the revision\n * @param {Requestable.callback} [cb] - will receive the revision\n * @return {Promise} - the Promise for the http request\n */\n getRevision(revision, cb) {\n return this._request('GET', `/gists/${this.__id}/${revision}`, null, cb);\n }\n\n /**\n * List the gist's comments\n * @see https://developer.github.com/v3/gists/comments/#list-comments-on-a-gist\n * @param {Requestable.callback} [cb] - will receive the array of comments\n * @return {Promise} - the promise for the http request\n */\n listComments(cb) {\n return this._requestAllPages(`/gists/${this.__id}/comments`, null, cb);\n }\n\n /**\n * Fetch one of the gist's comments\n * @see https://developer.github.com/v3/gists/comments/#get-a-single-comment\n * @param {number} comment - the id of the comment\n * @param {Requestable.callback} [cb] - will receive the comment\n * @return {Promise} - the Promise for the http request\n */\n getComment(comment, cb) {\n return this._request('GET', `/gists/${this.__id}/comments/${comment}`, null, cb);\n }\n\n /**\n * Comment on a gist\n * @see https://developer.github.com/v3/gists/comments/#create-a-comment\n * @param {string} comment - the comment to add\n * @param {Requestable.callback} [cb] - the function that receives the API result\n * @return {Promise} - the Promise for the http request\n */\n createComment(comment, cb) {\n return this._request('POST', `/gists/${this.__id}/comments`, {body: comment}, cb);\n }\n\n /**\n * Edit a comment on the gist\n * @see https://developer.github.com/v3/gists/comments/#edit-a-comment\n * @param {number} comment - the id of the comment\n * @param {string} body - the new comment\n * @param {Requestable.callback} [cb] - will receive the modified comment\n * @return {Promise} - the promise for the http request\n */\n editComment(comment, body, cb) {\n return this._request('PATCH', `/gists/${this.__id}/comments/${comment}`, {body: body}, cb);\n }\n\n /**\n * Delete a comment on the gist.\n * @see https://developer.github.com/v3/gists/comments/#delete-a-comment\n * @param {number} comment - the id of the comment\n * @param {Requestable.callback} [cb] - will receive true if the request succeeds\n * @return {Promise} - the Promise for the http request\n */\n deleteComment(comment, cb) {\n return this._request('DELETE', `/gists/${this.__id}/comments/${comment}`, null, cb);\n }\n}\n\nmodule.exports = Gist;\n","/**\n * @file\n * @copyright 2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n * Github.js is freely distributable.\n */\n/* eslint valid-jsdoc: [\"error\", {\"requireReturnDescription\": false}] */\n\nimport Gist from './Gist';\nimport User from './User';\nimport Issue from './Issue';\nimport Search from './Search';\nimport RateLimit from './RateLimit';\nimport Repository from './Repository';\nimport Organization from './Organization';\nimport Team from './Team';\nimport Markdown from './Markdown';\nimport Project from './Project';\n\n/**\n * GitHub encapsulates the functionality to create various API wrapper objects.\n */\nclass GitHub {\n /**\n * Create a new GitHub.\n * @param {Requestable.auth} [auth] - the credentials to authenticate to Github. If auth is\n * not provided requests will be made unauthenticated\n * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n */\n constructor(auth, apiBase = 'https://api.github.com') {\n this.__apiBase = apiBase;\n this.__auth = auth || {};\n }\n\n /**\n * Create a new Gist wrapper\n * @param {number} [id] - the id for the gist, leave undefined when creating a new gist\n * @return {Gist}\n */\n getGist(id) {\n return new Gist(id, this.__auth, this.__apiBase);\n }\n\n /**\n * Create a new User wrapper\n * @param {string} [user] - the name of the user to get information about\n * leave undefined for the authenticated user\n * @return {User}\n */\n getUser(user) {\n return new User(user, this.__auth, this.__apiBase);\n }\n\n /**\n * Create a new Organization wrapper\n * @param {string} organization - the name of the organization\n * @return {Organization}\n */\n getOrganization(organization) {\n return new Organization(organization, this.__auth, this.__apiBase);\n }\n\n /**\n * create a new Team wrapper\n * @param {string} teamId - the name of the team\n * @return {team}\n */\n getTeam(teamId) {\n return new Team(teamId, this.__auth, this.__apiBase);\n }\n\n /**\n * Create a new Repository wrapper\n * @param {string} user - the user who owns the respository\n * @param {string} repo - the name of the repository\n * @return {Repository}\n */\n getRepo(user, repo) {\n return new Repository(this._getFullName(user, repo), this.__auth, this.__apiBase);\n }\n\n /**\n * Create a new Issue wrapper\n * @param {string} user - the user who owns the respository\n * @param {string} repo - the name of the repository\n * @return {Issue}\n */\n getIssues(user, repo) {\n return new Issue(this._getFullName(user, repo), this.__auth, this.__apiBase);\n }\n\n /**\n * Create a new Search wrapper\n * @param {string} query - the query to search for\n * @return {Search}\n */\n search(query) {\n return new Search(query, this.__auth, this.__apiBase);\n }\n\n /**\n * Create a new RateLimit wrapper\n * @return {RateLimit}\n */\n getRateLimit() {\n return new RateLimit(this.__auth, this.__apiBase);\n }\n\n /**\n * Create a new Markdown wrapper\n * @return {Markdown}\n */\n getMarkdown() {\n return new Markdown(this.__auth, this.__apiBase);\n }\n\n /**\n * Create a new Project wrapper\n * @param {string} id - the id of the project\n * @return {Markdown}\n */\n getProject(id) {\n return new Project(id, this.__auth, this.__apiBase);\n }\n\n /**\n * Computes the full repository name\n * @param {string} user - the username (or the full name)\n * @param {string} repo - the repository name, must not be passed if `user` is the full name\n * @return {string} the repository's full name\n */\n _getFullName(user, repo) {\n let fullname = user;\n\n if (repo) {\n fullname = `${user}/${repo}`;\n }\n\n return fullname;\n }\n}\n\nmodule.exports = GitHub;\n","/**\n * @file\n * @copyright 2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n * Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\n\n/**\n * Issue wraps the functionality to get issues for repositories\n */\nclass Issue extends Requestable {\n /**\n * Create a new Issue\n * @param {string} repository - the full name of the repository (`:user/:repo`) to get issues for\n * @param {Requestable.auth} [auth] - information required to authenticate to Github\n * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n */\n constructor(repository, auth, apiBase) {\n super(auth, apiBase);\n this.__repository = repository;\n }\n\n /**\n * Create a new issue\n * @see https://developer.github.com/v3/issues/#create-an-issue\n * @param {Object} issueData - the issue to create\n * @param {Requestable.callback} [cb] - will receive the created issue\n * @return {Promise} - the promise for the http request\n */\n createIssue(issueData, cb) {\n return this._request('POST', `/repos/${this.__repository}/issues`, issueData, cb);\n }\n\n /**\n * List the issues for the repository\n * @see https://developer.github.com/v3/issues/#list-issues-for-a-repository\n * @param {Object} options - filtering options\n * @param {Requestable.callback} [cb] - will receive the array of issues\n * @return {Promise} - the promise for the http request\n */\n listIssues(options, cb) {\n return this._requestAllPages(`/repos/${this.__repository}/issues`, options, cb);\n }\n\n /**\n * List the events for an issue\n * @see https://developer.github.com/v3/issues/events/#list-events-for-an-issue\n * @param {number} issue - the issue to get events for\n * @param {Requestable.callback} [cb] - will receive the list of events\n * @return {Promise} - the promise for the http request\n */\n listIssueEvents(issue, cb) {\n return this._request('GET', `/repos/${this.__repository}/issues/${issue}/events`, null, cb);\n }\n\n /**\n * List comments on an issue\n * @see https://developer.github.com/v3/issues/comments/#list-comments-on-an-issue\n * @param {number} issue - the id of the issue to get comments from\n * @param {Requestable.callback} [cb] - will receive the comments\n * @return {Promise} - the promise for the http request\n */\n listIssueComments(issue, cb) {\n return this._request('GET', `/repos/${this.__repository}/issues/${issue}/comments`, null, cb);\n }\n\n /**\n * Get a single comment on an issue\n * @see https://developer.github.com/v3/issues/comments/#get-a-single-comment\n * @param {number} id - the comment id to get\n * @param {Requestable.callback} [cb] - will receive the comment\n * @return {Promise} - the promise for the http request\n */\n getIssueComment(id, cb) {\n return this._request('GET', `/repos/${this.__repository}/issues/comments/${id}`, null, cb);\n }\n\n /**\n * Comment on an issue\n * @see https://developer.github.com/v3/issues/comments/#create-a-comment\n * @param {number} issue - the id of the issue to comment on\n * @param {string} comment - the comment to add\n * @param {Requestable.callback} [cb] - will receive the created comment\n * @return {Promise} - the promise for the http request\n */\n createIssueComment(issue, comment, cb) {\n return this._request('POST', `/repos/${this.__repository}/issues/${issue}/comments`, {body: comment}, cb);\n }\n\n /**\n * Edit a comment on an issue\n * @see https://developer.github.com/v3/issues/comments/#edit-a-comment\n * @param {number} id - the comment id to edit\n * @param {string} comment - the comment to edit\n * @param {Requestable.callback} [cb] - will receive the edited comment\n * @return {Promise} - the promise for the http request\n */\n editIssueComment(id, comment, cb) {\n return this._request('PATCH', `/repos/${this.__repository}/issues/comments/${id}`, {body: comment}, cb);\n }\n\n /**\n * Delete a comment on an issue\n * @see https://developer.github.com/v3/issues/comments/#delete-a-comment\n * @param {number} id - the comment id to delete\n * @param {Requestable.callback} [cb] - will receive true if the request is successful\n * @return {Promise} - the promise for the http request\n */\n deleteIssueComment(id, cb) {\n return this._request('DELETE', `/repos/${this.__repository}/issues/comments/${id}`, null, cb);\n }\n\n /**\n * Edit an issue\n * @see https://developer.github.com/v3/issues/#edit-an-issue\n * @param {number} issue - the issue number to edit\n * @param {Object} issueData - the new issue data\n * @param {Requestable.callback} [cb] - will receive the modified issue\n * @return {Promise} - the promise for the http request\n */\n editIssue(issue, issueData, cb) {\n return this._request('PATCH', `/repos/${this.__repository}/issues/${issue}`, issueData, cb);\n }\n\n /**\n * Get a particular issue\n * @see https://developer.github.com/v3/issues/#get-a-single-issue\n * @param {number} issue - the issue number to fetch\n * @param {Requestable.callback} [cb] - will receive the issue\n * @return {Promise} - the promise for the http request\n */\n getIssue(issue, cb) {\n return this._request('GET', `/repos/${this.__repository}/issues/${issue}`, null, cb);\n }\n\n /**\n * List the milestones for the repository\n * @see https://developer.github.com/v3/issues/milestones/#list-milestones-for-a-repository\n * @param {Object} options - filtering options\n * @param {Requestable.callback} [cb] - will receive the array of milestones\n * @return {Promise} - the promise for the http request\n */\n listMilestones(options, cb) {\n return this._request('GET', `/repos/${this.__repository}/milestones`, options, cb);\n }\n\n /**\n * Get a milestone\n * @see https://developer.github.com/v3/issues/milestones/#get-a-single-milestone\n * @param {string} milestone - the id of the milestone to fetch\n * @param {Requestable.callback} [cb] - will receive the milestone\n * @return {Promise} - the promise for the http request\n */\n getMilestone(milestone, cb) {\n return this._request('GET', `/repos/${this.__repository}/milestones/${milestone}`, null, cb);\n }\n\n /**\n * Create a new milestone\n * @see https://developer.github.com/v3/issues/milestones/#create-a-milestone\n * @param {Object} milestoneData - the milestone definition\n * @param {Requestable.callback} [cb] - will receive the milestone\n * @return {Promise} - the promise for the http request\n */\n createMilestone(milestoneData, cb) {\n return this._request('POST', `/repos/${this.__repository}/milestones`, milestoneData, cb);\n }\n\n /**\n * Edit a milestone\n * @see https://developer.github.com/v3/issues/milestones/#update-a-milestone\n * @param {string} milestone - the id of the milestone to edit\n * @param {Object} milestoneData - the updates to make to the milestone\n * @param {Requestable.callback} [cb] - will receive the updated milestone\n * @return {Promise} - the promise for the http request\n */\n editMilestone(milestone, milestoneData, cb) {\n return this._request('PATCH', `/repos/${this.__repository}/milestones/${milestone}`, milestoneData, cb);\n }\n\n /**\n * Delete a milestone (this is distinct from closing a milestone)\n * @see https://developer.github.com/v3/issues/milestones/#delete-a-milestone\n * @param {string} milestone - the id of the milestone to delete\n * @param {Requestable.callback} [cb] - will receive the status\n * @return {Promise} - the promise for the http request\n */\n deleteMilestone(milestone, cb) {\n return this._request('DELETE', `/repos/${this.__repository}/milestones/${milestone}`, null, cb);\n }\n\n /**\n * Create a new label\n * @see https://developer.github.com/v3/issues/labels/#create-a-label\n * @param {Object} labelData - the label definition\n * @param {Requestable.callback} [cb] - will receive the object representing the label\n * @return {Promise} - the promise for the http request\n */\n createLabel(labelData, cb) {\n return this._request('POST', `/repos/${this.__repository}/labels`, labelData, cb);\n }\n\n /**\n * List the labels for the repository\n * @see https://developer.github.com/v3/issues/labels/#list-all-labels-for-this-repository\n * @param {Object} options - filtering options\n * @param {Requestable.callback} [cb] - will receive the array of labels\n * @return {Promise} - the promise for the http request\n */\n listLabels(options, cb) {\n return this._request('GET', `/repos/${this.__repository}/labels`, options, cb);\n }\n\n /**\n * Get a label\n * @see https://developer.github.com/v3/issues/labels/#get-a-single-label\n * @param {string} label - the name of the label to fetch\n * @param {Requestable.callback} [cb] - will receive the label\n * @return {Promise} - the promise for the http request\n */\n getLabel(label, cb) {\n return this._request('GET', `/repos/${this.__repository}/labels/${label}`, null, cb);\n }\n\n /**\n * Edit a label\n * @see https://developer.github.com/v3/issues/labels/#update-a-label\n * @param {string} label - the name of the label to edit\n * @param {Object} labelData - the updates to make to the label\n * @param {Requestable.callback} [cb] - will receive the updated label\n * @return {Promise} - the promise for the http request\n */\n editLabel(label, labelData, cb) {\n return this._request('PATCH', `/repos/${this.__repository}/labels/${label}`, labelData, cb);\n }\n\n /**\n * Delete a label\n * @see https://developer.github.com/v3/issues/labels/#delete-a-label\n * @param {string} label - the name of the label to delete\n * @param {Requestable.callback} [cb] - will receive the status\n * @return {Promise} - the promise for the http request\n */\n deleteLabel(label, cb) {\n return this._request('DELETE', `/repos/${this.__repository}/labels/${label}`, null, cb);\n }\n}\n\nmodule.exports = Issue;\n","/**\n * @file\n * @copyright 2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n * Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\n\n/**\n * Renders html from Markdown text\n */\nclass Markdown extends Requestable {\n /**\n * construct a Markdown\n * @param {Requestable.auth} auth - the credentials to authenticate to GitHub\n * @param {string} [apiBase] - the base Github API URL\n * @return {Promise} - the promise for the http request\n */\n constructor(auth, apiBase) {\n super(auth, apiBase);\n }\n\n /**\n * Render html from Markdown text.\n * @see https://developer.github.com/v3/markdown/#render-an-arbitrary-markdown-document\n * @param {Object} options - conversion options\n * @param {string} [options.text] - the markdown text to convert\n * @param {string} [options.mode=markdown] - can be either `markdown` or `gfm`\n * @param {string} [options.context] - repository name if mode is gfm\n * @param {Requestable.callback} [cb] - will receive the converted html\n * @return {Promise} - the promise for the http request\n */\n render(options, cb) {\n return this._request('POST', '/markdown', options, cb);\n }\n}\n\nmodule.exports = Markdown;\n","/**\n * @file\n * @copyright 2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n * Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\n\n/**\n * Organization encapsulates the functionality to create repositories in organizations\n */\nclass Organization extends Requestable {\n /**\n * Create a new Organization\n * @param {string} organization - the name of the organization\n * @param {Requestable.auth} [auth] - information required to authenticate to Github\n * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n */\n constructor(organization, auth, apiBase) {\n super(auth, apiBase);\n this.__name = organization;\n }\n\n /**\n * Create a repository in an organization\n * @see https://developer.github.com/v3/repos/#create\n * @param {Object} options - the repository definition\n * @param {Requestable.callback} [cb] - will receive the created repository\n * @return {Promise} - the promise for the http request\n */\n createRepo(options, cb) {\n return this._request('POST', `/orgs/${this.__name}/repos`, options, cb);\n }\n\n /**\n * List the repositories in an organization\n * @see https://developer.github.com/v3/repos/#list-organization-repositories\n * @param {Requestable.callback} [cb] - will receive the list of repositories\n * @return {Promise} - the promise for the http request\n */\n getRepos(cb) {\n let requestOptions = this._getOptionsWithDefaults({direction: 'desc'});\n\n return this._requestAllPages(`/orgs/${this.__name}/repos`, requestOptions, cb);\n }\n\n /**\n * Query if the user is a member or not\n * @param {string} username - the user in question\n * @param {Requestable.callback} [cb] - will receive true if the user is a member\n * @return {Promise} - the promise for the http request\n */\n isMember(username, cb) {\n return this._request204or404(`/orgs/${this.__name}/members/${username}`, null, cb);\n }\n\n /**\n * List the users who are members of the company\n * @see https://developer.github.com/v3/orgs/members/#members-list\n * @param {object} options - filtering options\n * @param {string} [options.filter=all] - can be either `2fa_disabled` or `all`\n * @param {string} [options.role=all] - can be one of: `all`, `admin`, or `member`\n * @param {Requestable.callback} [cb] - will receive the list of users\n * @return {Promise} - the promise for the http request\n */\n listMembers(options, cb) {\n return this._request('GET', `/orgs/${this.__name}/members`, options, cb);\n }\n\n /**\n * List the Teams in the Organization\n * @see https://developer.github.com/v3/orgs/teams/#list-teams\n * @param {Requestable.callback} [cb] - will receive the list of teams\n * @return {Promise} - the promise for the http request\n */\n getTeams(cb) {\n return this._requestAllPages(`/orgs/${this.__name}/teams`, undefined, cb);\n }\n\n /**\n * Create a team\n * @see https://developer.github.com/v3/orgs/teams/#create-team\n * @param {object} options - Team creation parameters\n * @param {string} options.name - The name of the team\n * @param {string} [options.description] - Team description\n * @param {string} [options.repo_names] - Repos to add the team to\n * @param {string} [options.privacy=secret] - The level of privacy the team should have. Can be either one\n * of: `secret`, or `closed`\n * @param {Requestable.callback} [cb] - will receive the created team\n * @return {Promise} - the promise for the http request\n */\n createTeam(options, cb) {\n return this._request('POST', `/orgs/${this.__name}/teams`, options, cb);\n }\n\n /**\n * Get information about all projects\n * @see https://developer.github.com/v3/projects/#list-organization-projects\n * @param {Requestable.callback} [cb] - will receive the list of projects\n * @return {Promise} - the promise for the http request\n */\n listProjects(cb) {\n return this._requestAllPages(`/orgs/${this.__name}/projects`, {AcceptHeader: 'inertia-preview'}, cb);\n }\n\n /**\n * Create a new project\n * @see https://developer.github.com/v3/repos/projects/#create-a-project\n * @param {Object} options - the description of the project\n * @param {Requestable.callback} cb - will receive the newly created project\n * @return {Promise} - the promise for the http request\n */\n createProject(options, cb) {\n options = options || {};\n options.AcceptHeader = 'inertia-preview';\n return this._request('POST', `/orgs/${this.__name}/projects`, options, cb);\n }\n}\n\nmodule.exports = Organization;\n","/**\n * @file\n * @copyright 2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n * Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\n\n/**\n * Project encapsulates the functionality to create, query, and modify cards and columns.\n */\nclass Project extends Requestable {\n /**\n * Create a Project.\n * @param {string} id - the id of the project\n * @param {Requestable.auth} [auth] - information required to authenticate to Github\n * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n */\n constructor(id, auth, apiBase) {\n super(auth, apiBase, 'inertia-preview');\n this.__id = id;\n }\n\n /**\n * Get information about a project\n * @see https://developer.github.com/v3/projects/#get-a-project\n * @param {Requestable.callback} cb - will receive the project information\n * @return {Promise} - the promise for the http request\n */\n getProject(cb) {\n return this._request('GET', `/projects/${this.__id}`, null, cb);\n }\n\n /**\n * Edit a project\n * @see https://developer.github.com/v3/projects/#update-a-project\n * @param {Object} options - the description of the project\n * @param {Requestable.callback} cb - will receive the modified project\n * @return {Promise} - the promise for the http request\n */\n updateProject(options, cb) {\n return this._request('PATCH', `/projects/${this.__id}`, options, cb);\n }\n\n /**\n * Delete a project\n * @see https://developer.github.com/v3/projects/#delete-a-project\n * @param {Requestable.callback} cb - will receive true if the operation is successful\n * @return {Promise} - the promise for the http request\n */\n deleteProject(cb) {\n return this._request('DELETE', `/projects/${this.__id}`, null, cb);\n }\n\n /**\n * Get information about all columns of a project\n * @see https://developer.github.com/v3/projects/columns/#list-project-columns\n * @param {Requestable.callback} [cb] - will receive the list of columns\n * @return {Promise} - the promise for the http request\n */\n listProjectColumns(cb) {\n return this._requestAllPages(`/projects/${this.__id}/columns`, null, cb);\n }\n\n /**\n * Get information about a column\n * @see https://developer.github.com/v3/projects/columns/#get-a-project-column\n * @param {string} colId - the id of the column\n * @param {Requestable.callback} cb - will receive the column information\n * @return {Promise} - the promise for the http request\n */\n getProjectColumn(colId, cb) {\n return this._request('GET', `/projects/columns/${colId}`, null, cb);\n }\n\n /**\n * Create a new column\n * @see https://developer.github.com/v3/projects/columns/#create-a-project-column\n * @param {Object} options - the description of the column\n * @param {Requestable.callback} cb - will receive the newly created column\n * @return {Promise} - the promise for the http request\n */\n createProjectColumn(options, cb) {\n return this._request('POST', `/projects/${this.__id}/columns`, options, cb);\n }\n\n /**\n * Edit a column\n * @see https://developer.github.com/v3/projects/columns/#update-a-project-column\n * @param {string} colId - the column id\n * @param {Object} options - the description of the column\n * @param {Requestable.callback} cb - will receive the modified column\n * @return {Promise} - the promise for the http request\n */\n updateProjectColumn(colId, options, cb) {\n return this._request('PATCH', `/projects/columns/${colId}`, options, cb);\n }\n\n /**\n * Delete a column\n * @see https://developer.github.com/v3/projects/columns/#delete-a-project-column\n * @param {string} colId - the column to be deleted\n * @param {Requestable.callback} cb - will receive true if the operation is successful\n * @return {Promise} - the promise for the http request\n */\n deleteProjectColumn(colId, cb) {\n return this._request('DELETE', `/projects/columns/${colId}`, null, cb);\n }\n\n /**\n * Move a column\n * @see https://developer.github.com/v3/projects/columns/#move-a-project-column\n * @param {string} colId - the column to be moved\n * @param {string} position - can be one of first, last, or after:,\n * where is the id value of a column in the same project.\n * @param {Requestable.callback} cb - will receive true if the operation is successful\n * @return {Promise} - the promise for the http request\n */\n moveProjectColumn(colId, position, cb) {\n return this._request(\n 'POST',\n `/projects/columns/${colId}/moves`,\n {position: position},\n cb\n );\n }\n\n /**\n * Get information about all cards of a project\n * @see https://developer.github.com/v3/projects/cards/#list-project-cards\n * @param {Requestable.callback} [cb] - will receive the list of cards\n * @return {Promise} - the promise for the http request\n */\n listProjectCards(cb) {\n return this.listProjectColumns()\n .then(({data}) => {\n return Promise.all(data.map((column) => {\n return this._requestAllPages(`/projects/columns/${column.id}/cards`, null);\n }));\n }).then((cardsInColumns) => {\n const cards = cardsInColumns.reduce((prev, {data}) => {\n prev.push(...data);\n return prev;\n }, []);\n if (cb) {\n cb(null, cards);\n }\n return cards;\n }).catch((err) => {\n if (cb) {\n cb(err);\n return;\n }\n throw err;\n });\n }\n\n /**\n * Get information about all cards of a column\n * @see https://developer.github.com/v3/projects/cards/#list-project-cards\n * @param {string} colId - the id of the column\n * @param {Requestable.callback} [cb] - will receive the list of cards\n * @return {Promise} - the promise for the http request\n */\n listColumnCards(colId, cb) {\n return this._requestAllPages(`/projects/columns/${colId}/cards`, null, cb);\n }\n\n /**\n * Get information about a card\n * @see https://developer.github.com/v3/projects/cards/#get-a-project-card\n * @param {string} cardId - the id of the card\n * @param {Requestable.callback} cb - will receive the card information\n * @return {Promise} - the promise for the http request\n */\n getProjectCard(cardId, cb) {\n return this._request('GET', `/projects/columns/cards/${cardId}`, null, cb);\n }\n\n /**\n * Create a new card\n * @see https://developer.github.com/v3/projects/cards/#create-a-project-card\n * @param {string} colId - the column id\n * @param {Object} options - the description of the card\n * @param {Requestable.callback} cb - will receive the newly created card\n * @return {Promise} - the promise for the http request\n */\n createProjectCard(colId, options, cb) {\n return this._request('POST', `/projects/columns/${colId}/cards`, options, cb);\n }\n\n /**\n * Edit a card\n * @see https://developer.github.com/v3/projects/cards/#update-a-project-card\n * @param {string} cardId - the card id\n * @param {Object} options - the description of the card\n * @param {Requestable.callback} cb - will receive the modified card\n * @return {Promise} - the promise for the http request\n */\n updateProjectCard(cardId, options, cb) {\n return this._request('PATCH', `/projects/columns/cards/${cardId}`, options, cb);\n }\n\n /**\n * Delete a card\n * @see https://developer.github.com/v3/projects/cards/#delete-a-project-card\n * @param {string} cardId - the card to be deleted\n * @param {Requestable.callback} cb - will receive true if the operation is successful\n * @return {Promise} - the promise for the http request\n */\n deleteProjectCard(cardId, cb) {\n return this._request('DELETE', `/projects/columns/cards/${cardId}`, null, cb);\n }\n\n /**\n * Move a card\n * @see https://developer.github.com/v3/projects/cards/#move-a-project-card\n * @param {string} cardId - the card to be moved\n * @param {string} position - can be one of top, bottom, or after:,\n * where is the id value of a card in the same project.\n * @param {string} colId - the id value of a column in the same project.\n * @param {Requestable.callback} cb - will receive true if the operation is successful\n * @return {Promise} - the promise for the http request\n */\n moveProjectCard(cardId, position, colId, cb) {\n return this._request(\n 'POST',\n `/projects/columns/cards/${cardId}/moves`,\n {position: position, column_id: colId}, // eslint-disable-line camelcase\n cb\n );\n }\n}\n\nmodule.exports = Project;\n","/**\n * @file\n * @copyright 2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n * Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\n\n/**\n * RateLimit allows users to query their rate-limit status\n */\nclass RateLimit extends Requestable {\n /**\n * construct a RateLimit\n * @param {Requestable.auth} auth - the credentials to authenticate to GitHub\n * @param {string} [apiBase] - the base Github API URL\n * @return {Promise} - the promise for the http request\n */\n constructor(auth, apiBase) {\n super(auth, apiBase);\n }\n\n /**\n * Query the current rate limit\n * @see https://developer.github.com/v3/rate_limit/\n * @param {Requestable.callback} [cb] - will receive the rate-limit data\n * @return {Promise} - the promise for the http request\n */\n getRateLimit(cb) {\n return this._request('GET', '/rate_limit', null, cb);\n }\n}\n\nmodule.exports = RateLimit;\n","/**\n * @file\n * @copyright 2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n * Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\nimport Utf8 from 'utf8';\nimport {\n Base64,\n} from 'js-base64';\nimport debug from 'debug';\nconst log = debug('github:repository');\n\n/**\n * Respository encapsulates the functionality to create, query, and modify files.\n */\nclass Repository extends Requestable {\n /**\n * Create a Repository.\n * @param {string} fullname - the full name of the repository\n * @param {Requestable.auth} [auth] - information required to authenticate to Github\n * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n */\n constructor(fullname, auth, apiBase) {\n super(auth, apiBase);\n this.__fullname = fullname;\n this.__currentTree = {\n branch: null,\n sha: null,\n };\n }\n\n /**\n * Get a reference\n * @see https://developer.github.com/v3/git/refs/#get-a-reference\n * @param {string} ref - the reference to get\n * @param {Requestable.callback} [cb] - will receive the reference's refSpec or a list of refSpecs that match `ref`\n * @return {Promise} - the promise for the http request\n */\n getRef(ref, cb) {\n return this._request('GET', `/repos/${this.__fullname}/git/refs/${ref}`, null, cb);\n }\n\n /**\n * Create a reference\n * @see https://developer.github.com/v3/git/refs/#create-a-reference\n * @param {Object} options - the object describing the ref\n * @param {Requestable.callback} [cb] - will receive the ref\n * @return {Promise} - the promise for the http request\n */\n createRef(options, cb) {\n return this._request('POST', `/repos/${this.__fullname}/git/refs`, options, cb);\n }\n\n /**\n * Delete a reference\n * @see https://developer.github.com/v3/git/refs/#delete-a-reference\n * @param {string} ref - the name of the ref to delte\n * @param {Requestable.callback} [cb] - will receive true if the request is successful\n * @return {Promise} - the promise for the http request\n */\n deleteRef(ref, cb) {\n return this._request('DELETE', `/repos/${this.__fullname}/git/refs/${ref}`, null, cb);\n }\n\n /**\n * Delete a repository\n * @see https://developer.github.com/v3/repos/#delete-a-repository\n * @param {Requestable.callback} [cb] - will receive true if the request is successful\n * @return {Promise} - the promise for the http request\n */\n deleteRepo(cb) {\n return this._request('DELETE', `/repos/${this.__fullname}`, null, cb);\n }\n\n /**\n * List the tags on a repository\n * @see https://developer.github.com/v3/repos/#list-tags\n * @param {Requestable.callback} [cb] - will receive the tag data\n * @return {Promise} - the promise for the http request\n */\n listTags(cb) {\n return this._request('GET', `/repos/${this.__fullname}/tags`, null, cb);\n }\n\n /**\n * List the open pull requests on the repository\n * @see https://developer.github.com/v3/pulls/#list-pull-requests\n * @param {Object} options - options to filter the search\n * @param {Requestable.callback} [cb] - will receive the list of PRs\n * @return {Promise} - the promise for the http request\n */\n listPullRequests(options, cb) {\n options = options || {};\n return this._request('GET', `/repos/${this.__fullname}/pulls`, options, cb);\n }\n\n /**\n * Get information about a specific pull request\n * @see https://developer.github.com/v3/pulls/#get-a-single-pull-request\n * @param {number} number - the PR you wish to fetch\n * @param {Requestable.callback} [cb] - will receive the PR from the API\n * @return {Promise} - the promise for the http request\n */\n getPullRequest(number, cb) {\n return this._request('GET', `/repos/${this.__fullname}/pulls/${number}`, null, cb);\n }\n\n /**\n * List the files of a specific pull request\n * @see https://developer.github.com/v3/pulls/#list-pull-requests-files\n * @param {number|string} number - the PR you wish to fetch\n * @param {Requestable.callback} [cb] - will receive the list of files from the API\n * @return {Promise} - the promise for the http request\n */\n listPullRequestFiles(number, cb) {\n return this._request('GET', `/repos/${this.__fullname}/pulls/${number}/files`, null, cb);\n }\n\n /**\n * Compare two branches/commits/repositories\n * @see https://developer.github.com/v3/repos/commits/#compare-two-commits\n * @param {string} base - the base commit\n * @param {string} head - the head commit\n * @param {Requestable.callback} cb - will receive the comparison\n * @return {Promise} - the promise for the http request\n */\n compareBranches(base, head, cb) {\n return this._request('GET', `/repos/${this.__fullname}/compare/${base}...${head}`, null, cb);\n }\n\n /**\n * List all the branches for the repository\n * @see https://developer.github.com/v3/repos/#list-branches\n * @param {Requestable.callback} cb - will receive the list of branches\n * @return {Promise} - the promise for the http request\n */\n listBranches(cb) {\n return this._request('GET', `/repos/${this.__fullname}/branches`, null, cb);\n }\n\n /**\n * Get a raw blob from the repository\n * @see https://developer.github.com/v3/git/blobs/#get-a-blob\n * @param {string} sha - the sha of the blob to fetch\n * @param {Requestable.callback} cb - will receive the blob from the API\n * @return {Promise} - the promise for the http request\n */\n getBlob(sha, cb) {\n return this._request('GET', `/repos/${this.__fullname}/git/blobs/${sha}`, null, cb, 'raw');\n }\n\n /**\n * Get a single branch\n * @see https://developer.github.com/v3/repos/branches/#get-branch\n * @param {string} branch - the name of the branch to fetch\n * @param {Requestable.callback} cb - will receive the branch from the API\n * @returns {Promise} - the promise for the http request\n */\n getBranch(branch, cb) {\n return this._request('GET', `/repos/${this.__fullname}/branches/${branch}`, null, cb);\n }\n\n /**\n * Get a commit from the repository\n * @see https://developer.github.com/v3/repos/commits/#get-a-single-commit\n * @param {string} sha - the sha for the commit to fetch\n * @param {Requestable.callback} cb - will receive the commit data\n * @return {Promise} - the promise for the http request\n */\n getCommit(sha, cb) {\n return this._request('GET', `/repos/${this.__fullname}/git/commits/${sha}`, null, cb);\n }\n\n /**\n * List the commits on a repository, optionally filtering by path, author or time range\n * @see https://developer.github.com/v3/repos/commits/#list-commits-on-a-repository\n * @param {Object} [options] - the filtering options for commits\n * @param {string} [options.sha] - the SHA or branch to start from\n * @param {string} [options.path] - the path to search on\n * @param {string} [options.author] - the commit author\n * @param {(Date|string)} [options.since] - only commits after this date will be returned\n * @param {(Date|string)} [options.until] - only commits before this date will be returned\n * @param {Requestable.callback} cb - will receive the list of commits found matching the criteria\n * @return {Promise} - the promise for the http request\n */\n listCommits(options, cb) {\n options = options || {};\n\n options.since = this._dateToISO(options.since);\n options.until = this._dateToISO(options.until);\n\n return this._request('GET', `/repos/${this.__fullname}/commits`, options, cb);\n }\n\n /**\n * Gets a single commit information for a repository\n * @see https://developer.github.com/v3/repos/commits/#get-a-single-commit\n * @param {string} ref - the reference for the commit-ish\n * @param {Requestable.callback} cb - will receive the commit information\n * @return {Promise} - the promise for the http request\n */\n getSingleCommit(ref, cb) {\n ref = ref || '';\n return this._request('GET', `/repos/${this.__fullname}/commits/${ref}`, null, cb);\n }\n\n /**\n * Get tha sha for a particular object in the repository. This is a convenience function\n * @see https://developer.github.com/v3/repos/contents/#get-contents\n * @param {string} [branch] - the branch to look in, or the repository's default branch if omitted\n * @param {string} path - the path of the file or directory\n * @param {Requestable.callback} cb - will receive a description of the requested object, including a `SHA` property\n * @return {Promise} - the promise for the http request\n */\n getSha(branch, path, cb) {\n branch = branch ? `?ref=${branch}` : '';\n return this._request('GET', `/repos/${this.__fullname}/contents/${path}${branch}`, null, cb);\n }\n\n /**\n * List the commit statuses for a particular sha, branch, or tag\n * @see https://developer.github.com/v3/repos/statuses/#list-statuses-for-a-specific-ref\n * @param {string} sha - the sha, branch, or tag to get statuses for\n * @param {Requestable.callback} cb - will receive the list of statuses\n * @return {Promise} - the promise for the http request\n */\n listStatuses(sha, cb) {\n return this._request('GET', `/repos/${this.__fullname}/commits/${sha}/statuses`, null, cb);\n }\n\n /**\n * Get a description of a git tree\n * @see https://developer.github.com/v3/git/trees/#get-a-tree\n * @param {string} treeSHA - the SHA of the tree to fetch\n * @param {Requestable.callback} cb - will receive the callback data\n * @return {Promise} - the promise for the http request\n */\n getTree(treeSHA, cb) {\n return this._request('GET', `/repos/${this.__fullname}/git/trees/${treeSHA}`, null, cb);\n }\n\n /**\n * Create a blob\n * @see https://developer.github.com/v3/git/blobs/#create-a-blob\n * @param {(string|Buffer|Blob)} content - the content to add to the repository\n * @param {Requestable.callback} cb - will receive the details of the created blob\n * @return {Promise} - the promise for the http request\n */\n createBlob(content, cb) {\n let postBody = this._getContentObject(content);\n\n log('sending content', postBody);\n return this._request('POST', `/repos/${this.__fullname}/git/blobs`, postBody, cb);\n }\n\n /**\n * Get the object that represents the provided content\n * @param {string|Buffer|Blob} content - the content to send to the server\n * @return {Object} the representation of `content` for the GitHub API\n */\n _getContentObject(content) {\n if (typeof content === 'string') {\n log('contet is a string');\n return {\n content: Utf8.encode(content),\n encoding: 'utf-8',\n };\n\n } else if (typeof Buffer !== 'undefined' && content instanceof Buffer) {\n log('We appear to be in Node');\n return {\n content: content.toString('base64'),\n encoding: 'base64',\n };\n\n } else if (typeof Blob !== 'undefined' && content instanceof Blob) {\n log('We appear to be in the browser');\n return {\n content: Base64.encode(content),\n encoding: 'base64',\n };\n\n } else { // eslint-disable-line\n log(`Not sure what this content is: ${typeof content}, ${JSON.stringify(content)}`);\n throw new Error('Unknown content passed to postBlob. Must be string or Buffer (node) or Blob (web)');\n }\n }\n\n /**\n * Update a tree in Git\n * @see https://developer.github.com/v3/git/trees/#create-a-tree\n * @param {string} baseTreeSHA - the SHA of the tree to update\n * @param {string} path - the path for the new file\n * @param {string} blobSHA - the SHA for the blob to put at `path`\n * @param {Requestable.callback} cb - will receive the new tree that is created\n * @return {Promise} - the promise for the http request\n * @deprecated use {@link Repository#createTree} instead\n */\n updateTree(baseTreeSHA, path, blobSHA, cb) {\n let newTree = {\n base_tree: baseTreeSHA, // eslint-disable-line\n tree: [{\n path: path,\n sha: blobSHA,\n mode: '100644',\n type: 'blob',\n }],\n };\n\n return this._request('POST', `/repos/${this.__fullname}/git/trees`, newTree, cb);\n }\n\n /**\n * Create a new tree in git\n * @see https://developer.github.com/v3/git/trees/#create-a-tree\n * @param {Object} tree - the tree to create\n * @param {string} baseSHA - the root sha of the tree\n * @param {Requestable.callback} cb - will receive the new tree that is created\n * @return {Promise} - the promise for the http request\n */\n createTree(tree, baseSHA, cb) {\n return this._request('POST', `/repos/${this.__fullname}/git/trees`, {\n tree,\n base_tree: baseSHA, // eslint-disable-line camelcase\n }, cb);\n }\n\n /**\n * Add a commit to the repository\n * @see https://developer.github.com/v3/git/commits/#create-a-commit\n * @param {string} parent - the SHA of the parent commit\n * @param {string} tree - the SHA of the tree for this commit\n * @param {string} message - the commit message\n * @param {Requestable.callback} cb - will receive the commit that is created\n * @return {Promise} - the promise for the http request\n */\n commit(parent, tree, message, cb) {\n let data = {\n message,\n tree,\n parents: [parent],\n };\n\n return this._request('POST', `/repos/${this.__fullname}/git/commits`, data, cb)\n .then((response) => {\n this.__currentTree.sha = response.data.sha; // Update latest commit\n return response;\n });\n }\n\n /**\n * Update a ref\n * @see https://developer.github.com/v3/git/refs/#update-a-reference\n * @param {string} ref - the ref to update\n * @param {string} commitSHA - the SHA to point the reference to\n * @param {boolean} force - indicates whether to force or ensure a fast-forward update\n * @param {Requestable.callback} cb - will receive the updated ref back\n * @return {Promise} - the promise for the http request\n */\n updateHead(ref, commitSHA, force, cb) {\n return this._request('PATCH', `/repos/${this.__fullname}/git/refs/${ref}`, {\n sha: commitSHA,\n force: force,\n }, cb);\n }\n\n /**\n * Update commit status\n * @see https://developer.github.com/v3/repos/statuses/\n * @param {string} commitSHA - the SHA of the commit that should be updated\n * @param {object} options - Commit status parameters\n * @param {string} options.state - The state of the status. Can be one of: pending, success, error, or failure.\n * @param {string} [options.target_url] - The target URL to associate with this status.\n * @param {string} [options.description] - A short description of the status.\n * @param {string} [options.context] - A string label to differentiate this status among CI systems.\n * @param {Requestable.callback} cb - will receive the updated commit back\n * @return {Promise} - the promise for the http request\n */\n updateStatus(commitSHA, options, cb) {\n return this._request('POST', `/repos/${this.__fullname}/statuses/${commitSHA}`, options, cb);\n }\n\n /**\n * Update repository information\n * @see https://developer.github.com/v3/repos/#edit\n * @param {object} options - New parameters that will be set to the repository\n * @param {string} options.name - Name of the repository\n * @param {string} [options.description] - A short description of the repository\n * @param {string} [options.homepage] - A URL with more information about the repository\n * @param {boolean} [options.private] - Either true to make the repository private, or false to make it public.\n * @param {boolean} [options.has_issues] - Either true to enable issues for this repository, false to disable them.\n * @param {boolean} [options.has_wiki] - Either true to enable the wiki for this repository, false to disable it.\n * @param {boolean} [options.has_downloads] - Either true to enable downloads, false to disable them.\n * @param {string} [options.default_branch] - Updates the default branch for this repository.\n * @param {Requestable.callback} cb - will receive the updated repository back\n * @return {Promise} - the promise for the http request\n */\n updateRepository(options, cb) {\n return this._request('PATCH', `/repos/${this.__fullname}`, options, cb);\n }\n\n /**\n * Get information about the repository\n * @see https://developer.github.com/v3/repos/#get\n * @param {Requestable.callback} cb - will receive the information about the repository\n * @return {Promise} - the promise for the http request\n */\n getDetails(cb) {\n return this._request('GET', `/repos/${this.__fullname}`, null, cb);\n }\n\n /**\n * List the contributors to the repository\n * @see https://developer.github.com/v3/repos/#list-contributors\n * @param {Requestable.callback} cb - will receive the list of contributors\n * @return {Promise} - the promise for the http request\n */\n getContributors(cb) {\n return this._request('GET', `/repos/${this.__fullname}/contributors`, null, cb);\n }\n\n /**\n * List the contributor stats to the repository\n * @see https://developer.github.com/v3/repos/#list-contributors\n * @param {Requestable.callback} cb - will receive the list of contributors\n * @return {Promise} - the promise for the http request\n */\n getContributorStats(cb) {\n return this._request('GET', `/repos/${this.__fullname}/stats/contributors`, null, cb);\n }\n\n /**\n * List the users who are collaborators on the repository. The currently authenticated user must have\n * push access to use this method\n * @see https://developer.github.com/v3/repos/collaborators/#list-collaborators\n * @param {Requestable.callback} cb - will receive the list of collaborators\n * @return {Promise} - the promise for the http request\n */\n getCollaborators(cb) {\n return this._request('GET', `/repos/${this.__fullname}/collaborators`, null, cb);\n }\n\n /**\n * Check if a user is a collaborator on the repository\n * @see https://developer.github.com/v3/repos/collaborators/#check-if-a-user-is-a-collaborator\n * @param {string} username - the user to check\n * @param {Requestable.callback} cb - will receive true if the user is a collaborator and false if they are not\n * @return {Promise} - the promise for the http request {Boolean} [description]\n */\n isCollaborator(username, cb) {\n return this._request('GET', `/repos/${this.__fullname}/collaborators/${username}`, null, cb);\n }\n\n /**\n * Get the contents of a repository\n * @see https://developer.github.com/v3/repos/contents/#get-contents\n * @param {string} ref - the ref to check\n * @param {string} path - the path containing the content to fetch\n * @param {boolean} raw - `true` if the results should be returned raw instead of GitHub's normalized format\n * @param {Requestable.callback} cb - will receive the fetched data\n * @return {Promise} - the promise for the http request\n */\n getContents(ref, path, raw, cb) {\n path = path ? `${encodeURI(path)}` : '';\n return this._request('GET', `/repos/${this.__fullname}/contents/${path}`, {\n ref,\n }, cb, raw);\n }\n\n /**\n * Get the README of a repository\n * @see https://developer.github.com/v3/repos/contents/#get-the-readme\n * @param {string} ref - the ref to check\n * @param {boolean} raw - `true` if the results should be returned raw instead of GitHub's normalized format\n * @param {Requestable.callback} cb - will receive the fetched data\n * @return {Promise} - the promise for the http request\n */\n getReadme(ref, raw, cb) {\n return this._request('GET', `/repos/${this.__fullname}/readme`, {\n ref,\n }, cb, raw);\n }\n\n /**\n * Fork a repository\n * @see https://developer.github.com/v3/repos/forks/#create-a-fork\n * @param {Requestable.callback} cb - will receive the information about the newly created fork\n * @return {Promise} - the promise for the http request\n */\n fork(cb) {\n return this._request('POST', `/repos/${this.__fullname}/forks`, null, cb);\n }\n\n /**\n * List a repository's forks\n * @see https://developer.github.com/v3/repos/forks/#list-forks\n * @param {Requestable.callback} cb - will receive the list of repositories forked from this one\n * @return {Promise} - the promise for the http request\n */\n listForks(cb) {\n return this._request('GET', `/repos/${this.__fullname}/forks`, null, cb);\n }\n\n /**\n * Create a new branch from an existing branch.\n * @param {string} [oldBranch=master] - the name of the existing branch\n * @param {string} newBranch - the name of the new branch\n * @param {Requestable.callback} cb - will receive the commit data for the head of the new branch\n * @return {Promise} - the promise for the http request\n */\n createBranch(oldBranch, newBranch, cb) {\n if (typeof newBranch === 'function') {\n cb = newBranch;\n newBranch = oldBranch;\n oldBranch = 'master';\n }\n\n return this.getRef(`heads/${oldBranch}`)\n .then((response) => {\n let sha = response.data.object.sha;\n return this.createRef({\n sha,\n ref: `refs/heads/${newBranch}`,\n }, cb);\n });\n }\n\n /**\n * Create a new pull request\n * @see https://developer.github.com/v3/pulls/#create-a-pull-request\n * @param {Object} options - the pull request description\n * @param {Requestable.callback} cb - will receive the new pull request\n * @return {Promise} - the promise for the http request\n */\n createPullRequest(options, cb) {\n return this._request('POST', `/repos/${this.__fullname}/pulls`, options, cb);\n }\n\n /**\n * Update a pull request\n * @see https://developer.github.com/v3/pulls/#update-a-pull-request\n * @param {number|string} number - the number of the pull request to update\n * @param {Object} options - the pull request description\n * @param {Requestable.callback} [cb] - will receive the pull request information\n * @return {Promise} - the promise for the http request\n */\n updatePullRequest(number, options, cb) {\n return this._request('PATCH', `/repos/${this.__fullname}/pulls/${number}`, options, cb);\n }\n\n /**\n * List the hooks for the repository\n * @see https://developer.github.com/v3/repos/hooks/#list-hooks\n * @param {Requestable.callback} cb - will receive the list of hooks\n * @return {Promise} - the promise for the http request\n */\n listHooks(cb) {\n return this._request('GET', `/repos/${this.__fullname}/hooks`, null, cb);\n }\n\n /**\n * Get a hook for the repository\n * @see https://developer.github.com/v3/repos/hooks/#get-single-hook\n * @param {number} id - the id of the webook\n * @param {Requestable.callback} cb - will receive the details of the webook\n * @return {Promise} - the promise for the http request\n */\n getHook(id, cb) {\n return this._request('GET', `/repos/${this.__fullname}/hooks/${id}`, null, cb);\n }\n\n /**\n * Add a new hook to the repository\n * @see https://developer.github.com/v3/repos/hooks/#create-a-hook\n * @param {Object} options - the configuration describing the new hook\n * @param {Requestable.callback} cb - will receive the new webhook\n * @return {Promise} - the promise for the http request\n */\n createHook(options, cb) {\n return this._request('POST', `/repos/${this.__fullname}/hooks`, options, cb);\n }\n\n /**\n * Edit an existing webhook\n * @see https://developer.github.com/v3/repos/hooks/#edit-a-hook\n * @param {number} id - the id of the webhook\n * @param {Object} options - the new description of the webhook\n * @param {Requestable.callback} cb - will receive the updated webhook\n * @return {Promise} - the promise for the http request\n */\n updateHook(id, options, cb) {\n return this._request('PATCH', `/repos/${this.__fullname}/hooks/${id}`, options, cb);\n }\n\n /**\n * Delete a webhook\n * @see https://developer.github.com/v3/repos/hooks/#delete-a-hook\n * @param {number} id - the id of the webhook to be deleted\n * @param {Requestable.callback} cb - will receive true if the call is successful\n * @return {Promise} - the promise for the http request\n */\n deleteHook(id, cb) {\n return this._request('DELETE', `/repos/${this.__fullname}/hooks/${id}`, null, cb);\n }\n\n /**\n * List the deploy keys for the repository\n * @see https://developer.github.com/v3/repos/keys/#list-deploy-keys\n * @param {Requestable.callback} cb - will receive the list of deploy keys\n * @return {Promise} - the promise for the http request\n */\n listKeys(cb) {\n return this._request('GET', `/repos/${this.__fullname}/keys`, null, cb);\n }\n\n /**\n * Get a deploy key for the repository\n * @see https://developer.github.com/v3/repos/keys/#get-a-deploy-key\n * @param {number} id - the id of the deploy key\n * @param {Requestable.callback} cb - will receive the details of the deploy key\n * @return {Promise} - the promise for the http request\n */\n getKey(id, cb) {\n return this._request('GET', `/repos/${this.__fullname}/keys/${id}`, null, cb);\n }\n\n /**\n * Add a new deploy key to the repository\n * @see https://developer.github.com/v3/repos/keys/#add-a-new-deploy-key\n * @param {Object} options - the configuration describing the new deploy key\n * @param {Requestable.callback} cb - will receive the new deploy key\n * @return {Promise} - the promise for the http request\n */\n createKey(options, cb) {\n return this._request('POST', `/repos/${this.__fullname}/keys`, options, cb);\n }\n\n /**\n * Delete a deploy key\n * @see https://developer.github.com/v3/repos/keys/#remove-a-deploy-key\n * @param {number} id - the id of the deploy key to be deleted\n * @param {Requestable.callback} cb - will receive true if the call is successful\n * @return {Promise} - the promise for the http request\n */\n deleteKey(id, cb) {\n return this._request('DELETE', `/repos/${this.__fullname}/keys/${id}`, null, cb);\n }\n\n /**\n * Delete a file from a branch\n * @see https://developer.github.com/v3/repos/contents/#delete-a-file\n * @param {string} branch - the branch to delete from, or the default branch if not specified\n * @param {string} path - the path of the file to remove\n * @param {Requestable.callback} cb - will receive the commit in which the delete occurred\n * @return {Promise} - the promise for the http request\n */\n deleteFile(branch, path, cb) {\n return this.getSha(branch, path)\n .then((response) => {\n const deleteCommit = {\n message: `Delete the file at '${path}'`,\n sha: response.data.sha,\n branch,\n };\n return this._request('DELETE', `/repos/${this.__fullname}/contents/${path}`, deleteCommit, cb);\n });\n }\n\n /**\n * Change all references in a repo from oldPath to new_path\n * @param {string} branch - the branch to carry out the reference change, or the default branch if not specified\n * @param {string} oldPath - original path\n * @param {string} newPath - new reference path\n * @param {Requestable.callback} cb - will receive the commit in which the move occurred\n * @return {Promise} - the promise for the http request\n */\n move(branch, oldPath, newPath, cb) {\n let oldSha;\n return this.getRef(`heads/${branch}`)\n .then(({data: {object}}) => this.getTree(`${object.sha}?recursive=true`))\n .then(({data: {tree, sha}}) => {\n oldSha = sha;\n let newTree = tree.map((ref) => {\n if (ref.path === oldPath) {\n ref.path = newPath;\n }\n if (ref.type === 'tree') {\n delete ref.sha;\n }\n return ref;\n });\n return this.createTree(newTree);\n })\n .then(({data: tree}) => this.commit(oldSha, tree.sha, `Renamed '${oldPath}' to '${newPath}'`))\n .then(({data: commit}) => this.updateHead(`heads/${branch}`, commit.sha, true, cb));\n }\n\n /**\n * Write a file to the repository\n * @see https://developer.github.com/v3/repos/contents/#update-a-file\n * @param {string} branch - the name of the branch\n * @param {string} path - the path for the file\n * @param {string} content - the contents of the file\n * @param {string} message - the commit message\n * @param {Object} [options] - commit options\n * @param {Object} [options.author] - the author of the commit\n * @param {Object} [options.commiter] - the committer\n * @param {boolean} [options.encode] - true if the content should be base64 encoded\n * @param {Requestable.callback} cb - will receive the new commit\n * @return {Promise} - the promise for the http request\n */\n writeFile(branch, path, content, message, options, cb) {\n if (typeof options === 'function') {\n cb = options;\n options = {};\n }\n let filePath = path ? encodeURI(path) : '';\n let shouldEncode = options.encode !== false;\n let commit = {\n branch,\n message,\n author: options.author,\n committer: options.committer,\n content: shouldEncode ? Base64.encode(content) : content,\n };\n\n return this.getSha(branch, filePath)\n .then((response) => {\n commit.sha = response.data.sha;\n return this._request('PUT', `/repos/${this.__fullname}/contents/${filePath}`, commit, cb);\n }, () => {\n return this._request('PUT', `/repos/${this.__fullname}/contents/${filePath}`, commit, cb);\n });\n }\n\n /**\n * Check if a repository is starred by you\n * @see https://developer.github.com/v3/activity/starring/#check-if-you-are-starring-a-repository\n * @param {Requestable.callback} cb - will receive true if the repository is starred and false if the repository\n * is not starred\n * @return {Promise} - the promise for the http request {Boolean} [description]\n */\n isStarred(cb) {\n return this._request204or404(`/user/starred/${this.__fullname}`, null, cb);\n }\n\n /**\n * Star a repository\n * @see https://developer.github.com/v3/activity/starring/#star-a-repository\n * @param {Requestable.callback} cb - will receive true if the repository is starred\n * @return {Promise} - the promise for the http request\n */\n star(cb) {\n return this._request('PUT', `/user/starred/${this.__fullname}`, null, cb);\n }\n\n /**\n * Unstar a repository\n * @see https://developer.github.com/v3/activity/starring/#unstar-a-repository\n * @param {Requestable.callback} cb - will receive true if the repository is unstarred\n * @return {Promise} - the promise for the http request\n */\n unstar(cb) {\n return this._request('DELETE', `/user/starred/${this.__fullname}`, null, cb);\n }\n\n /**\n * Create a new release\n * @see https://developer.github.com/v3/repos/releases/#create-a-release\n * @param {Object} options - the description of the release\n * @param {Requestable.callback} cb - will receive the newly created release\n * @return {Promise} - the promise for the http request\n */\n createRelease(options, cb) {\n return this._request('POST', `/repos/${this.__fullname}/releases`, options, cb);\n }\n\n /**\n * Edit a release\n * @see https://developer.github.com/v3/repos/releases/#edit-a-release\n * @param {string} id - the id of the release\n * @param {Object} options - the description of the release\n * @param {Requestable.callback} cb - will receive the modified release\n * @return {Promise} - the promise for the http request\n */\n updateRelease(id, options, cb) {\n return this._request('PATCH', `/repos/${this.__fullname}/releases/${id}`, options, cb);\n }\n\n /**\n * Get information about all releases\n * @see https://developer.github.com/v3/repos/releases/#list-releases-for-a-repository\n * @param {Requestable.callback} cb - will receive the release information\n * @return {Promise} - the promise for the http request\n */\n listReleases(cb) {\n return this._request('GET', `/repos/${this.__fullname}/releases`, null, cb);\n }\n\n /**\n * Get information about a release\n * @see https://developer.github.com/v3/repos/releases/#get-a-single-release\n * @param {string} id - the id of the release\n * @param {Requestable.callback} cb - will receive the release information\n * @return {Promise} - the promise for the http request\n */\n getRelease(id, cb) {\n return this._request('GET', `/repos/${this.__fullname}/releases/${id}`, null, cb);\n }\n\n /**\n * Delete a release\n * @see https://developer.github.com/v3/repos/releases/#delete-a-release\n * @param {string} id - the release to be deleted\n * @param {Requestable.callback} cb - will receive true if the operation is successful\n * @return {Promise} - the promise for the http request\n */\n deleteRelease(id, cb) {\n return this._request('DELETE', `/repos/${this.__fullname}/releases/${id}`, null, cb);\n }\n\n /**\n * Merge a pull request\n * @see https://developer.github.com/v3/pulls/#merge-a-pull-request-merge-button\n * @param {number|string} number - the number of the pull request to merge\n * @param {Object} options - the merge options for the pull request\n * @param {Requestable.callback} [cb] - will receive the merge information if the operation is successful\n * @return {Promise} - the promise for the http request\n */\n mergePullRequest(number, options, cb) {\n return this._request('PUT', `/repos/${this.__fullname}/pulls/${number}/merge`, options, cb);\n }\n\n /**\n * Get information about all projects\n * @see https://developer.github.com/v3/projects/#list-repository-projects\n * @param {Requestable.callback} [cb] - will receive the list of projects\n * @return {Promise} - the promise for the http request\n */\n listProjects(cb) {\n return this._requestAllPages(`/repos/${this.__fullname}/projects`, {AcceptHeader: 'inertia-preview'}, cb);\n }\n\n /**\n * Create a new project\n * @see https://developer.github.com/v3/projects/#create-a-repository-project\n * @param {Object} options - the description of the project\n * @param {Requestable.callback} cb - will receive the newly created project\n * @return {Promise} - the promise for the http request\n */\n createProject(options, cb) {\n options = options || {};\n options.AcceptHeader = 'inertia-preview';\n return this._request('POST', `/repos/${this.__fullname}/projects`, options, cb);\n }\n\n}\n\nmodule.exports = Repository;\n","/**\n * @file\n * @copyright 2016 Yahoo Inc.\n * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n * Github.js is freely distributable.\n */\n\nimport axios from 'axios';\nimport debug from 'debug';\nimport {Base64} from 'js-base64';\n\nconst log = debug('github:request');\n\n/**\n * The error structure returned when a network call fails\n */\nclass ResponseError extends Error {\n /**\n * Construct a new ResponseError\n * @param {string} message - an message to return instead of the the default error message\n * @param {string} path - the requested path\n * @param {Object} response - the object returned by Axios\n */\n constructor(message, path, response) {\n super(message);\n this.path = path;\n this.request = response.config;\n this.response = (response || {}).response || response;\n this.status = response.status;\n }\n}\n\n/**\n * Requestable wraps the logic for making http requests to the API\n */\nclass Requestable {\n /**\n * Either a username and password or an oauth token for Github\n * @typedef {Object} Requestable.auth\n * @prop {string} [username] - the Github username\n * @prop {string} [password] - the user's password\n * @prop {token} [token] - an OAuth token\n */\n /**\n * Initialize the http internals.\n * @param {Requestable.auth} [auth] - the credentials to authenticate to Github. If auth is\n * not provided request will be made unauthenticated\n * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n * @param {string} [AcceptHeader=v3] - the accept header for the requests\n */\n constructor(auth, apiBase, AcceptHeader) {\n this.__apiBase = apiBase || 'https://api.github.com';\n this.__auth = {\n token: auth.token,\n username: auth.username,\n password: auth.password,\n };\n this.__AcceptHeader = AcceptHeader || 'v3';\n\n if (auth.token) {\n this.__authorizationHeader = 'token ' + auth.token;\n } else if (auth.username && auth.password) {\n this.__authorizationHeader = 'Basic ' + Base64.encode(auth.username + ':' + auth.password);\n }\n }\n\n /**\n * Compute the URL to use to make a request.\n * @private\n * @param {string} path - either a URL relative to the API base or an absolute URL\n * @return {string} - the URL to use\n */\n __getURL(path) {\n let url = path;\n\n if (path.indexOf('//') === -1) {\n url = this.__apiBase + path;\n }\n\n let newCacheBuster = 'timestamp=' + new Date().getTime();\n return url.replace(/(timestamp=\\d+)/, newCacheBuster);\n }\n\n /**\n * Compute the headers required for an API request.\n * @private\n * @param {boolean} raw - if the request should be treated as JSON or as a raw request\n * @param {string} AcceptHeader - the accept header for the request\n * @return {Object} - the headers to use in the request\n */\n __getRequestHeaders(raw, AcceptHeader) {\n let headers = {\n 'Content-Type': 'application/json;charset=UTF-8',\n 'Accept': 'application/vnd.github.' + (AcceptHeader || this.__AcceptHeader),\n };\n\n if (raw) {\n headers.Accept += '.raw';\n }\n headers.Accept += '+json';\n\n if (this.__authorizationHeader) {\n headers.Authorization = this.__authorizationHeader;\n }\n\n return headers;\n }\n\n /**\n * Sets the default options for API requests\n * @protected\n * @param {Object} [requestOptions={}] - the current options for the request\n * @return {Object} - the options to pass to the request\n */\n _getOptionsWithDefaults(requestOptions = {}) {\n if (!(requestOptions.visibility || requestOptions.affiliation)) {\n requestOptions.type = requestOptions.type || 'all';\n }\n requestOptions.sort = requestOptions.sort || 'updated';\n requestOptions.per_page = requestOptions.per_page || '100'; // eslint-disable-line\n\n return requestOptions;\n }\n\n /**\n * if a `Date` is passed to this function it will be converted to an ISO string\n * @param {*} date - the object to attempt to cooerce into an ISO date string\n * @return {string} - the ISO representation of `date` or whatever was passed in if it was not a date\n */\n _dateToISO(date) {\n if (date && (date instanceof Date)) {\n date = date.toISOString();\n }\n\n return date;\n }\n\n /**\n * A function that receives the result of the API request.\n * @callback Requestable.callback\n * @param {Requestable.Error} error - the error returned by the API or `null`\n * @param {(Object|true)} result - the data returned by the API or `true` if the API returns `204 No Content`\n * @param {Object} request - the raw {@linkcode https://github.com/mzabriskie/axios#response-schema Response}\n */\n /**\n * Make a request.\n * @param {string} method - the method for the request (GET, PUT, POST, DELETE)\n * @param {string} path - the path for the request\n * @param {*} [data] - the data to send to the server. For HTTP methods that don't have a body the data\n * will be sent as query parameters\n * @param {Requestable.callback} [cb] - the callback for the request\n * @param {boolean} [raw=false] - if the request should be sent as raw. If this is a falsy value then the\n * request will be made as JSON\n * @return {Promise} - the Promise for the http request\n */\n _request(method, path, data, cb, raw) {\n const url = this.__getURL(path);\n\n const AcceptHeader = (data || {}).AcceptHeader;\n if (AcceptHeader) {\n delete data.AcceptHeader;\n }\n const headers = this.__getRequestHeaders(raw, AcceptHeader);\n\n let queryParams = {};\n\n const shouldUseDataAsParams = data && (typeof data === 'object') && methodHasNoBody(method);\n if (shouldUseDataAsParams) {\n queryParams = data;\n data = undefined;\n }\n\n const config = {\n url: url,\n method: method,\n headers: headers,\n params: queryParams,\n data: data,\n responseType: raw ? 'text' : 'json',\n };\n\n log(`${config.method} to ${config.url}`);\n const requestPromise = axios(config).catch(callbackErrorOrThrow(cb, path));\n\n if (cb) {\n requestPromise.then((response) => {\n if (response.data && Object.keys(response.data).length > 0) {\n // When data has results\n cb(null, response.data, response);\n } else if (config.method !== 'GET' && Object.keys(response.data).length < 1) {\n // True when successful submit a request and receive a empty object\n cb(null, (response.status < 300), response);\n } else {\n cb(null, response.data, response);\n }\n });\n }\n\n return requestPromise;\n }\n\n /**\n * Make a request to an endpoint the returns 204 when true and 404 when false\n * @param {string} path - the path to request\n * @param {Object} data - any query parameters for the request\n * @param {Requestable.callback} cb - the callback that will receive `true` or `false`\n * @param {method} [method=GET] - HTTP Method to use\n * @return {Promise} - the promise for the http request\n */\n _request204or404(path, data, cb, method = 'GET') {\n return this._request(method, path, data)\n .then(function success(response) {\n if (cb) {\n cb(null, true, response);\n }\n return true;\n }, function failure(response) {\n if (response.response.status === 404) {\n if (cb) {\n cb(null, false, response);\n }\n return false;\n }\n\n if (cb) {\n cb(response);\n }\n throw response;\n });\n }\n\n /**\n * Make a request and fetch all the available data. Github will paginate responses so for queries\n * that might span multiple pages this method is preferred to {@link Requestable#request}\n * @param {string} path - the path to request\n * @param {Object} options - the query parameters to include\n * @param {Requestable.callback} [cb] - the function to receive the data. The returned data will always be an array.\n * @param {Object[]} results - the partial results. This argument is intended for interal use only.\n * @return {Promise} - a promise which will resolve when all pages have been fetched\n * @deprecated This will be folded into {@link Requestable#_request} in the 2.0 release.\n */\n _requestAllPages(path, options, cb, results) {\n results = results || [];\n\n return this._request('GET', path, options)\n .then((response) => {\n let thisGroup;\n if (response.data instanceof Array) {\n thisGroup = response.data;\n } else if (response.data.items instanceof Array) {\n thisGroup = response.data.items;\n } else {\n let message = `cannot figure out how to append ${response.data} to the result set`;\n throw new ResponseError(message, path, response);\n }\n results.push(...thisGroup);\n\n const nextUrl = getNextPage(response.headers.link);\n if (nextUrl && typeof options.page !== 'number') {\n log(`getting next page: ${nextUrl}`);\n return this._requestAllPages(nextUrl, options, cb, results);\n }\n\n if (cb) {\n cb(null, results, response);\n }\n\n response.data = results;\n return response;\n }).catch(callbackErrorOrThrow(cb, path));\n }\n}\n\nmodule.exports = Requestable;\n\n// ////////////////////////// //\n// Private helper functions //\n// ////////////////////////// //\nconst METHODS_WITH_NO_BODY = ['GET', 'HEAD', 'DELETE'];\nfunction methodHasNoBody(method) {\n return METHODS_WITH_NO_BODY.indexOf(method) !== -1;\n}\n\nfunction getNextPage(linksHeader = '') {\n const links = linksHeader.split(/\\s*,\\s*/); // splits and strips the urls\n return links.reduce(function(nextUrl, link) {\n if (link.search(/rel=\"next\"/) !== -1) {\n return (link.match(/<(.*)>/) || [])[1];\n }\n\n return nextUrl;\n }, undefined);\n}\n\nfunction callbackErrorOrThrow(cb, path) {\n return function handler(object) {\n let error;\n if (object.hasOwnProperty('config')) {\n const {response: {status, statusText}, config: {method, url}} = object;\n let message = (`${status} error making request ${method} ${url}: \"${statusText}\"`);\n error = new ResponseError(message, path, object);\n log(`${message} ${JSON.stringify(object.data)}`);\n } else {\n error = object;\n }\n if (cb) {\n log('going to error callback');\n cb(error);\n } else {\n log('throwing error');\n throw error;\n }\n };\n}\n","/**\n * @file\n * @copyright 2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n * Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\nimport debug from 'debug';\nconst log = debug('github:search');\n\n/**\n * Wrap the Search API\n */\nclass Search extends Requestable {\n /**\n * Create a Search\n * @param {Object} defaults - defaults for the search\n * @param {Requestable.auth} [auth] - information required to authenticate to Github\n * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n */\n constructor(defaults, auth, apiBase) {\n super(auth, apiBase);\n this.__defaults = this._getOptionsWithDefaults(defaults);\n }\n\n /**\n * Available search options\n * @see https://developer.github.com/v3/search/#parameters\n * @typedef {Object} Search.Params\n * @param {string} q - the query to make\n * @param {string} sort - the sort field, one of `stars`, `forks`, or `updated`.\n * Default is [best match](https://developer.github.com/v3/search/#ranking-search-results)\n * @param {string} order - the ordering, either `asc` or `desc`\n */\n /**\n * Perform a search on the GitHub API\n * @private\n * @param {string} path - the scope of the search\n * @param {Search.Params} [withOptions] - additional parameters for the search\n * @param {Requestable.callback} [cb] - will receive the results of the search\n * @return {Promise} - the promise for the http request\n */\n _search(path, withOptions = {}, cb = undefined) {\n let requestOptions = {};\n Object.keys(this.__defaults).forEach((prop) => {\n requestOptions[prop] = this.__defaults[prop];\n });\n Object.keys(withOptions).forEach((prop) => {\n requestOptions[prop] = withOptions[prop];\n });\n\n log(`searching ${path} with options:`, requestOptions);\n return this._requestAllPages(`/search/${path}`, requestOptions, cb);\n }\n\n /**\n * Search for repositories\n * @see https://developer.github.com/v3/search/#search-repositories\n * @param {Search.Params} [options] - additional parameters for the search\n * @param {Requestable.callback} [cb] - will receive the results of the search\n * @return {Promise} - the promise for the http request\n */\n forRepositories(options, cb) {\n return this._search('repositories', options, cb);\n }\n\n /**\n * Search for code\n * @see https://developer.github.com/v3/search/#search-code\n * @param {Search.Params} [options] - additional parameters for the search\n * @param {Requestable.callback} [cb] - will receive the results of the search\n * @return {Promise} - the promise for the http request\n */\n forCode(options, cb) {\n return this._search('code', options, cb);\n }\n\n /**\n * Search for issues\n * @see https://developer.github.com/v3/search/#search-issues\n * @param {Search.Params} [options] - additional parameters for the search\n * @param {Requestable.callback} [cb] - will receive the results of the search\n * @return {Promise} - the promise for the http request\n */\n forIssues(options, cb) {\n return this._search('issues', options, cb);\n }\n\n /**\n * Search for users\n * @see https://developer.github.com/v3/search/#search-users\n * @param {Search.Params} [options] - additional parameters for the search\n * @param {Requestable.callback} [cb] - will receive the results of the search\n * @return {Promise} - the promise for the http request\n */\n forUsers(options, cb) {\n return this._search('users', options, cb);\n }\n}\n\nmodule.exports = Search;\n","/**\n * @file\n * @copyright 2016 Matt Smith (Development Seed)\n * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n * Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\nimport debug from 'debug';\nconst log = debug('github:team');\n\n/**\n * A Team allows scoping of API requests to a particular Github Organization Team.\n */\nclass Team extends Requestable {\n /**\n * Create a Team.\n * @param {string} [teamId] - the id for the team\n * @param {Requestable.auth} [auth] - information required to authenticate to Github\n * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n */\n constructor(teamId, auth, apiBase) {\n super(auth, apiBase);\n this.__teamId = teamId;\n }\n\n /**\n * Get Team information\n * @see https://developer.github.com/v3/orgs/teams/#get-team\n * @param {Requestable.callback} [cb] - will receive the team\n * @return {Promise} - the promise for the http request\n */\n getTeam(cb) {\n log(`Fetching Team ${this.__teamId}`);\n return this._request('Get', `/teams/${this.__teamId}`, undefined, cb);\n }\n\n /**\n * List the Team's repositories\n * @see https://developer.github.com/v3/orgs/teams/#list-team-repos\n * @param {Requestable.callback} [cb] - will receive the list of repositories\n * @return {Promise} - the promise for the http request\n */\n listRepos(cb) {\n log(`Fetching repositories for Team ${this.__teamId}`);\n return this._requestAllPages(`/teams/${this.__teamId}/repos`, undefined, cb);\n }\n\n /**\n * Edit Team information\n * @see https://developer.github.com/v3/orgs/teams/#edit-team\n * @param {object} options - Parameters for team edit\n * @param {string} options.name - The name of the team\n * @param {string} [options.description] - Team description\n * @param {string} [options.repo_names] - Repos to add the team to\n * @param {string} [options.privacy=secret] - The level of privacy the team should have. Can be either one\n * of: `secret`, or `closed`\n * @param {Requestable.callback} [cb] - will receive the updated team\n * @return {Promise} - the promise for the http request\n */\n editTeam(options, cb) {\n log(`Editing Team ${this.__teamId}`);\n return this._request('PATCH', `/teams/${this.__teamId}`, options, cb);\n }\n\n /**\n * List the users who are members of the Team\n * @see https://developer.github.com/v3/orgs/teams/#list-team-members\n * @param {object} options - Parameters for listing team users\n * @param {string} [options.role=all] - can be one of: `all`, `maintainer`, or `member`\n * @param {Requestable.callback} [cb] - will receive the list of users\n * @return {Promise} - the promise for the http request\n */\n listMembers(options, cb) {\n log(`Getting members of Team ${this.__teamId}`);\n return this._requestAllPages(`/teams/${this.__teamId}/members`, options, cb);\n }\n\n /**\n * Get Team membership status for a user\n * @see https://developer.github.com/v3/orgs/teams/#get-team-membership\n * @param {string} username - can be one of: `all`, `maintainer`, or `member`\n * @param {Requestable.callback} [cb] - will receive the membership status of a user\n * @return {Promise} - the promise for the http request\n */\n getMembership(username, cb) {\n log(`Getting membership of user ${username} in Team ${this.__teamId}`);\n return this._request('GET', `/teams/${this.__teamId}/memberships/${username}`, undefined, cb);\n }\n\n /**\n * Add a member to the Team\n * @see https://developer.github.com/v3/orgs/teams/#add-team-membership\n * @param {string} username - can be one of: `all`, `maintainer`, or `member`\n * @param {object} options - Parameters for adding a team member\n * @param {string} [options.role=member] - The role that this user should have in the team. Can be one\n * of: `member`, or `maintainer`\n * @param {Requestable.callback} [cb] - will receive the membership status of added user\n * @return {Promise} - the promise for the http request\n */\n addMembership(username, options, cb) {\n log(`Adding user ${username} to Team ${this.__teamId}`);\n return this._request('PUT', `/teams/${this.__teamId}/memberships/${username}`, options, cb);\n }\n\n /**\n * Get repo management status for team\n * @see https://developer.github.com/v3/orgs/teams/#remove-team-membership\n * @param {string} owner - Organization name\n * @param {string} repo - Repo name\n * @param {Requestable.callback} [cb] - will receive the membership status of added user\n * @return {Promise} - the promise for the http request\n */\n isManagedRepo(owner, repo, cb) {\n log(`Getting repo management by Team ${this.__teamId} for repo ${owner}/${repo}`);\n return this._request204or404(`/teams/${this.__teamId}/repos/${owner}/${repo}`, undefined, cb);\n }\n\n /**\n * Add or Update repo management status for team\n * @see https://developer.github.com/v3/orgs/teams/#add-or-update-team-repository\n * @param {string} owner - Organization name\n * @param {string} repo - Repo name\n * @param {object} options - Parameters for adding or updating repo management for the team\n * @param {string} [options.permission] - The permission to grant the team on this repository. Can be one\n * of: `pull`, `push`, or `admin`\n * @param {Requestable.callback} [cb] - will receive the membership status of added user\n * @return {Promise} - the promise for the http request\n */\n manageRepo(owner, repo, options, cb) {\n log(`Adding or Updating repo management by Team ${this.__teamId} for repo ${owner}/${repo}`);\n return this._request204or404(`/teams/${this.__teamId}/repos/${owner}/${repo}`, options, cb, 'PUT');\n }\n\n /**\n * Remove repo management status for team\n * @see https://developer.github.com/v3/orgs/teams/#remove-team-repository\n * @param {string} owner - Organization name\n * @param {string} repo - Repo name\n * @param {Requestable.callback} [cb] - will receive the membership status of added user\n * @return {Promise} - the promise for the http request\n */\n unmanageRepo(owner, repo, cb) {\n log(`Remove repo management by Team ${this.__teamId} for repo ${owner}/${repo}`);\n return this._request204or404(`/teams/${this.__teamId}/repos/${owner}/${repo}`, undefined, cb, 'DELETE');\n }\n\n /**\n * Delete Team\n * @see https://developer.github.com/v3/orgs/teams/#delete-team\n * @param {Requestable.callback} [cb] - will receive the list of repositories\n * @return {Promise} - the promise for the http request\n */\n deleteTeam(cb) {\n log(`Deleting Team ${this.__teamId}`);\n return this._request204or404(`/teams/${this.__teamId}`, undefined, cb, 'DELETE');\n }\n}\n\nmodule.exports = Team;\n","/**\n * @file\n * @copyright 2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n * Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\nimport debug from 'debug';\nconst log = debug('github:user');\n\n/**\n * A User allows scoping of API requests to a particular Github user.\n */\nclass User extends Requestable {\n /**\n * Create a User.\n * @param {string} [username] - the user to use for user-scoped queries\n * @param {Requestable.auth} [auth] - information required to authenticate to Github\n * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n */\n constructor(username, auth, apiBase) {\n super(auth, apiBase);\n this.__user = username;\n }\n\n /**\n * Get the url for the request. (dependent on if we're requesting for the authenticated user or not)\n * @private\n * @param {string} endpoint - the endpoint being requested\n * @return {string} - the resolved endpoint\n */\n __getScopedUrl(endpoint) {\n if (this.__user) {\n return endpoint ?\n `/users/${this.__user}/${endpoint}` :\n `/users/${this.__user}`\n ;\n\n } else { // eslint-disable-line\n switch (endpoint) {\n case '':\n return '/user';\n\n case 'notifications':\n case 'gists':\n return `/${endpoint}`;\n\n default:\n return `/user/${endpoint}`;\n }\n }\n }\n\n /**\n * List the user's repositories\n * @see https://developer.github.com/v3/repos/#list-user-repositories\n * @param {Object} [options={}] - any options to refine the search\n * @param {Requestable.callback} [cb] - will receive the list of repositories\n * @return {Promise} - the promise for the http request\n */\n listRepos(options, cb) {\n if (typeof options === 'function') {\n cb = options;\n options = {};\n }\n\n options = this._getOptionsWithDefaults(options);\n\n log(`Fetching repositories with options: ${JSON.stringify(options)}`);\n return this._requestAllPages(this.__getScopedUrl('repos'), options, cb);\n }\n\n /**\n * List the orgs that the user belongs to\n * @see https://developer.github.com/v3/orgs/#list-user-organizations\n * @param {Requestable.callback} [cb] - will receive the list of organizations\n * @return {Promise} - the promise for the http request\n */\n listOrgs(cb) {\n return this._request('GET', this.__getScopedUrl('orgs'), null, cb);\n }\n\n /**\n * List the user's gists\n * @see https://developer.github.com/v3/gists/#list-a-users-gists\n * @param {Requestable.callback} [cb] - will receive the list of gists\n * @return {Promise} - the promise for the http request\n */\n listGists(cb) {\n return this._request('GET', this.__getScopedUrl('gists'), null, cb);\n }\n\n /**\n * List the user's starred gists\n * @see https://developer.github.com/v3/gists/#list-starred-gists\n * @param {Requestable.callback} [cb] - will receive the list of gists\n * @return {Promise} - the promise for the http request\n */\n listStarredGists(cb) {\n return this._request('GET', this.__getScopedUrl('gists/starred'), null, cb);\n }\n\n /**\n * List the user's gists\n * @see https://developer.github.com/v3/gists/#list-a-users-gists\n * @param {Requestable.callback} [cb] - will receive the list of gists\n * @return {Promise} - the promise for the http request\n */\n listStarredGists(cb) {\n return this._request('GET', this.__getScopedUrl('gists'), null, cb);\n }\n\n /**\n * List the user's notifications\n * @see https://developer.github.com/v3/activity/notifications/#list-your-notifications\n * @param {Object} [options={}] - any options to refine the search\n * @param {Requestable.callback} [cb] - will receive the list of repositories\n * @return {Promise} - the promise for the http request\n */\n listNotifications(options, cb) {\n options = options || {};\n if (typeof options === 'function') {\n cb = options;\n options = {};\n }\n\n options.since = this._dateToISO(options.since);\n options.before = this._dateToISO(options.before);\n\n return this._request('GET', this.__getScopedUrl('notifications'), options, cb);\n }\n\n /**\n * Show the user's profile\n * @see https://developer.github.com/v3/users/#get-a-single-user\n * @param {Requestable.callback} [cb] - will receive the user's information\n * @return {Promise} - the promise for the http request\n */\n getProfile(cb) {\n return this._request('GET', this.__getScopedUrl(''), null, cb);\n }\n\n /**\n * Gets the list of starred repositories for the user\n * @see https://developer.github.com/v3/activity/starring/#list-repositories-being-starred\n * @param {Requestable.callback} [cb] - will receive the list of starred repositories\n * @return {Promise} - the promise for the http request\n */\n listStarredRepos(cb) {\n let requestOptions = this._getOptionsWithDefaults();\n return this._requestAllPages(this.__getScopedUrl('starred'), requestOptions, cb);\n }\n\n /**\n * List email addresses for a user\n * @see https://developer.github.com/v3/users/emails/#list-email-addresses-for-a-user\n * @param {Requestable.callback} [cb] - will receive the list of emails\n * @return {Promise} - the promise for the http request\n */\n getEmails(cb) {\n return this._request('GET', '/user/emails', null, cb);\n }\n\n /**\n * Have the authenticated user follow this user\n * @see https://developer.github.com/v3/users/followers/#follow-a-user\n * @param {string} username - the user to follow\n * @param {Requestable.callback} [cb] - will receive true if the request succeeds\n * @return {Promise} - the promise for the http request\n */\n follow(username, cb) {\n return this._request('PUT', `/user/following/${this.__user}`, null, cb);\n }\n\n /**\n * Have the currently authenticated user unfollow this user\n * @see https://developer.github.com/v3/users/followers/#follow-a-user\n * @param {string} username - the user to unfollow\n * @param {Requestable.callback} [cb] - receives true if the request succeeds\n * @return {Promise} - the promise for the http request\n */\n unfollow(username, cb) {\n return this._request('DELETE', `/user/following/${this.__user}`, null, cb);\n }\n\n /**\n * Create a new repository for the currently authenticated user\n * @see https://developer.github.com/v3/repos/#create\n * @param {object} options - the repository definition\n * @param {Requestable.callback} [cb] - will receive the API response\n * @return {Promise} - the promise for the http request\n */\n createRepo(options, cb) {\n return this._request('POST', '/user/repos', options, cb);\n }\n}\n\nmodule.exports = User;\n","module.exports = require('./lib/axios');","'use strict';\n\nvar utils = require('./../utils');\nvar settle = require('./../core/settle');\nvar buildURL = require('./../helpers/buildURL');\nvar parseHeaders = require('./../helpers/parseHeaders');\nvar isURLSameOrigin = require('./../helpers/isURLSameOrigin');\nvar createError = require('../core/createError');\nvar btoa = (typeof window !== 'undefined' && window.btoa && window.btoa.bind(window)) || require('./../helpers/btoa');\n\nmodule.exports = function xhrAdapter(config) {\n return new Promise(function dispatchXhrRequest(resolve, reject) {\n var requestData = config.data;\n var requestHeaders = config.headers;\n\n if (utils.isFormData(requestData)) {\n delete requestHeaders['Content-Type']; // Let the browser set it\n }\n\n var request = new XMLHttpRequest();\n var loadEvent = 'onreadystatechange';\n var xDomain = false;\n\n // For IE 8/9 CORS support\n // Only supports POST and GET calls and doesn't returns the response headers.\n // DON'T do this for testing b/c XMLHttpRequest is mocked, not XDomainRequest.\n if (process.env.NODE_ENV !== 'test' &&\n typeof window !== 'undefined' &&\n window.XDomainRequest && !('withCredentials' in request) &&\n !isURLSameOrigin(config.url)) {\n request = new window.XDomainRequest();\n loadEvent = 'onload';\n xDomain = true;\n request.onprogress = function handleProgress() {};\n request.ontimeout = function handleTimeout() {};\n }\n\n // HTTP basic authentication\n if (config.auth) {\n var username = config.auth.username || '';\n var password = config.auth.password || '';\n requestHeaders.Authorization = 'Basic ' + btoa(username + ':' + password);\n }\n\n request.open(config.method.toUpperCase(), buildURL(config.url, config.params, config.paramsSerializer), true);\n\n // Set the request timeout in MS\n request.timeout = config.timeout;\n\n // Listen for ready state\n request[loadEvent] = function handleLoad() {\n if (!request || (request.readyState !== 4 && !xDomain)) {\n return;\n }\n\n // The request errored out and we didn't get a response, this will be\n // handled by onerror instead\n // With one exception: request that using file: protocol, most browsers\n // will return status as 0 even though it's a successful request\n if (request.status === 0 && !(request.responseURL && request.responseURL.indexOf('file:') === 0)) {\n return;\n }\n\n // Prepare the response\n var responseHeaders = 'getAllResponseHeaders' in request ? parseHeaders(request.getAllResponseHeaders()) : null;\n var responseData = !config.responseType || config.responseType === 'text' ? request.responseText : request.response;\n var response = {\n data: responseData,\n // IE sends 1223 instead of 204 (https://github.com/mzabriskie/axios/issues/201)\n status: request.status === 1223 ? 204 : request.status,\n statusText: request.status === 1223 ? 'No Content' : request.statusText,\n headers: responseHeaders,\n config: config,\n request: request\n };\n\n settle(resolve, reject, response);\n\n // Clean up request\n request = null;\n };\n\n // Handle low level network errors\n request.onerror = function handleError() {\n // Real errors are hidden from us by the browser\n // onerror should only fire if it's a network error\n reject(createError('Network Error', config));\n\n // Clean up request\n request = null;\n };\n\n // Handle timeout\n request.ontimeout = function handleTimeout() {\n reject(createError('timeout of ' + config.timeout + 'ms exceeded', config, 'ECONNABORTED'));\n\n // Clean up request\n request = null;\n };\n\n // Add xsrf header\n // This is only done if running in a standard browser environment.\n // Specifically not if we're in a web worker, or react-native.\n if (utils.isStandardBrowserEnv()) {\n var cookies = require('./../helpers/cookies');\n\n // Add xsrf header\n var xsrfValue = (config.withCredentials || isURLSameOrigin(config.url)) && config.xsrfCookieName ?\n cookies.read(config.xsrfCookieName) :\n undefined;\n\n if (xsrfValue) {\n requestHeaders[config.xsrfHeaderName] = xsrfValue;\n }\n }\n\n // Add headers to the request\n if ('setRequestHeader' in request) {\n utils.forEach(requestHeaders, function setRequestHeader(val, key) {\n if (typeof requestData === 'undefined' && key.toLowerCase() === 'content-type') {\n // Remove Content-Type if data is undefined\n delete requestHeaders[key];\n } else {\n // Otherwise add header to the request\n request.setRequestHeader(key, val);\n }\n });\n }\n\n // Add withCredentials to request if needed\n if (config.withCredentials) {\n request.withCredentials = true;\n }\n\n // Add responseType to request if needed\n if (config.responseType) {\n try {\n request.responseType = config.responseType;\n } catch (e) {\n if (request.responseType !== 'json') {\n throw e;\n }\n }\n }\n\n // Handle progress if needed\n if (typeof config.onDownloadProgress === 'function') {\n request.addEventListener('progress', config.onDownloadProgress);\n }\n\n // Not all browsers support upload events\n if (typeof config.onUploadProgress === 'function' && request.upload) {\n request.upload.addEventListener('progress', config.onUploadProgress);\n }\n\n if (config.cancelToken) {\n // Handle cancellation\n config.cancelToken.promise.then(function onCanceled(cancel) {\n if (!request) {\n return;\n }\n\n request.abort();\n reject(cancel);\n // Clean up request\n request = null;\n });\n }\n\n if (requestData === undefined) {\n requestData = null;\n }\n\n // Send the request\n request.send(requestData);\n });\n};\n","'use strict';\n\nvar utils = require('./utils');\nvar bind = require('./helpers/bind');\nvar Axios = require('./core/Axios');\nvar defaults = require('./defaults');\n\n/**\n * Create an instance of Axios\n *\n * @param {Object} defaultConfig The default config for the instance\n * @return {Axios} A new instance of Axios\n */\nfunction createInstance(defaultConfig) {\n var context = new Axios(defaultConfig);\n var instance = bind(Axios.prototype.request, context);\n\n // Copy axios.prototype to instance\n utils.extend(instance, Axios.prototype, context);\n\n // Copy context to instance\n utils.extend(instance, context);\n\n return instance;\n}\n\n// Create the default instance to be exported\nvar axios = createInstance(defaults);\n\n// Expose Axios class to allow class inheritance\naxios.Axios = Axios;\n\n// Factory for creating new instances\naxios.create = function create(instanceConfig) {\n return createInstance(utils.merge(defaults, instanceConfig));\n};\n\n// Expose Cancel & CancelToken\naxios.Cancel = require('./cancel/Cancel');\naxios.CancelToken = require('./cancel/CancelToken');\naxios.isCancel = require('./cancel/isCancel');\n\n// Expose all/spread\naxios.all = function all(promises) {\n return Promise.all(promises);\n};\naxios.spread = require('./helpers/spread');\n\nmodule.exports = axios;\n\n// Allow use of default import syntax in TypeScript\nmodule.exports.default = axios;\n","'use strict';\n\n/**\n * A `Cancel` is an object that is thrown when an operation is canceled.\n *\n * @class\n * @param {string=} message The message.\n */\nfunction Cancel(message) {\n this.message = message;\n}\n\nCancel.prototype.toString = function toString() {\n return 'Cancel' + (this.message ? ': ' + this.message : '');\n};\n\nCancel.prototype.__CANCEL__ = true;\n\nmodule.exports = Cancel;\n","'use strict';\n\nvar Cancel = require('./Cancel');\n\n/**\n * A `CancelToken` is an object that can be used to request cancellation of an operation.\n *\n * @class\n * @param {Function} executor The executor function.\n */\nfunction CancelToken(executor) {\n if (typeof executor !== 'function') {\n throw new TypeError('executor must be a function.');\n }\n\n var resolvePromise;\n this.promise = new Promise(function promiseExecutor(resolve) {\n resolvePromise = resolve;\n });\n\n var token = this;\n executor(function cancel(message) {\n if (token.reason) {\n // Cancellation has already been requested\n return;\n }\n\n token.reason = new Cancel(message);\n resolvePromise(token.reason);\n });\n}\n\n/**\n * Throws a `Cancel` if cancellation has been requested.\n */\nCancelToken.prototype.throwIfRequested = function throwIfRequested() {\n if (this.reason) {\n throw this.reason;\n }\n};\n\n/**\n * Returns an object that contains a new `CancelToken` and a function that, when called,\n * cancels the `CancelToken`.\n */\nCancelToken.source = function source() {\n var cancel;\n var token = new CancelToken(function executor(c) {\n cancel = c;\n });\n return {\n token: token,\n cancel: cancel\n };\n};\n\nmodule.exports = CancelToken;\n","'use strict';\n\nmodule.exports = function isCancel(value) {\n return !!(value && value.__CANCEL__);\n};\n","'use strict';\n\nvar defaults = require('./../defaults');\nvar utils = require('./../utils');\nvar InterceptorManager = require('./InterceptorManager');\nvar dispatchRequest = require('./dispatchRequest');\nvar isAbsoluteURL = require('./../helpers/isAbsoluteURL');\nvar combineURLs = require('./../helpers/combineURLs');\n\n/**\n * Create a new instance of Axios\n *\n * @param {Object} instanceConfig The default config for the instance\n */\nfunction Axios(instanceConfig) {\n this.defaults = instanceConfig;\n this.interceptors = {\n request: new InterceptorManager(),\n response: new InterceptorManager()\n };\n}\n\n/**\n * Dispatch a request\n *\n * @param {Object} config The config specific for this request (merged with this.defaults)\n */\nAxios.prototype.request = function request(config) {\n /*eslint no-param-reassign:0*/\n // Allow for axios('example/url'[, config]) a la fetch API\n if (typeof config === 'string') {\n config = utils.merge({\n url: arguments[0]\n }, arguments[1]);\n }\n\n config = utils.merge(defaults, this.defaults, { method: 'get' }, config);\n\n // Support baseURL config\n if (config.baseURL && !isAbsoluteURL(config.url)) {\n config.url = combineURLs(config.baseURL, config.url);\n }\n\n // Hook up interceptors middleware\n var chain = [dispatchRequest, undefined];\n var promise = Promise.resolve(config);\n\n this.interceptors.request.forEach(function unshiftRequestInterceptors(interceptor) {\n chain.unshift(interceptor.fulfilled, interceptor.rejected);\n });\n\n this.interceptors.response.forEach(function pushResponseInterceptors(interceptor) {\n chain.push(interceptor.fulfilled, interceptor.rejected);\n });\n\n while (chain.length) {\n promise = promise.then(chain.shift(), chain.shift());\n }\n\n return promise;\n};\n\n// Provide aliases for supported request methods\nutils.forEach(['delete', 'get', 'head'], function forEachMethodNoData(method) {\n /*eslint func-names:0*/\n Axios.prototype[method] = function(url, config) {\n return this.request(utils.merge(config || {}, {\n method: method,\n url: url\n }));\n };\n});\n\nutils.forEach(['post', 'put', 'patch'], function forEachMethodWithData(method) {\n /*eslint func-names:0*/\n Axios.prototype[method] = function(url, data, config) {\n return this.request(utils.merge(config || {}, {\n method: method,\n url: url,\n data: data\n }));\n };\n});\n\nmodule.exports = Axios;\n","'use strict';\n\nvar utils = require('./../utils');\n\nfunction InterceptorManager() {\n this.handlers = [];\n}\n\n/**\n * Add a new interceptor to the stack\n *\n * @param {Function} fulfilled The function to handle `then` for a `Promise`\n * @param {Function} rejected The function to handle `reject` for a `Promise`\n *\n * @return {Number} An ID used to remove interceptor later\n */\nInterceptorManager.prototype.use = function use(fulfilled, rejected) {\n this.handlers.push({\n fulfilled: fulfilled,\n rejected: rejected\n });\n return this.handlers.length - 1;\n};\n\n/**\n * Remove an interceptor from the stack\n *\n * @param {Number} id The ID that was returned by `use`\n */\nInterceptorManager.prototype.eject = function eject(id) {\n if (this.handlers[id]) {\n this.handlers[id] = null;\n }\n};\n\n/**\n * Iterate over all the registered interceptors\n *\n * This method is particularly useful for skipping over any\n * interceptors that may have become `null` calling `eject`.\n *\n * @param {Function} fn The function to call for each interceptor\n */\nInterceptorManager.prototype.forEach = function forEach(fn) {\n utils.forEach(this.handlers, function forEachHandler(h) {\n if (h !== null) {\n fn(h);\n }\n });\n};\n\nmodule.exports = InterceptorManager;\n","'use strict';\n\nvar enhanceError = require('./enhanceError');\n\n/**\n * Create an Error with the specified message, config, error code, and response.\n *\n * @param {string} message The error message.\n * @param {Object} config The config.\n * @param {string} [code] The error code (for example, 'ECONNABORTED').\n @ @param {Object} [response] The response.\n * @returns {Error} The created error.\n */\nmodule.exports = function createError(message, config, code, response) {\n var error = new Error(message);\n return enhanceError(error, config, code, response);\n};\n","'use strict';\n\nvar utils = require('./../utils');\nvar transformData = require('./transformData');\nvar isCancel = require('../cancel/isCancel');\nvar defaults = require('../defaults');\n\n/**\n * Throws a `Cancel` if cancellation has been requested.\n */\nfunction throwIfCancellationRequested(config) {\n if (config.cancelToken) {\n config.cancelToken.throwIfRequested();\n }\n}\n\n/**\n * Dispatch a request to the server using the configured adapter.\n *\n * @param {object} config The config that is to be used for the request\n * @returns {Promise} The Promise to be fulfilled\n */\nmodule.exports = function dispatchRequest(config) {\n throwIfCancellationRequested(config);\n\n // Ensure headers exist\n config.headers = config.headers || {};\n\n // Transform request data\n config.data = transformData(\n config.data,\n config.headers,\n config.transformRequest\n );\n\n // Flatten headers\n config.headers = utils.merge(\n config.headers.common || {},\n config.headers[config.method] || {},\n config.headers || {}\n );\n\n utils.forEach(\n ['delete', 'get', 'head', 'post', 'put', 'patch', 'common'],\n function cleanHeaderConfig(method) {\n delete config.headers[method];\n }\n );\n\n var adapter = config.adapter || defaults.adapter;\n\n return adapter(config).then(function onAdapterResolution(response) {\n throwIfCancellationRequested(config);\n\n // Transform response data\n response.data = transformData(\n response.data,\n response.headers,\n config.transformResponse\n );\n\n return response;\n }, function onAdapterRejection(reason) {\n if (!isCancel(reason)) {\n throwIfCancellationRequested(config);\n\n // Transform response data\n if (reason && reason.response) {\n reason.response.data = transformData(\n reason.response.data,\n reason.response.headers,\n config.transformResponse\n );\n }\n }\n\n return Promise.reject(reason);\n });\n};\n","'use strict';\n\n/**\n * Update an Error with the specified config, error code, and response.\n *\n * @param {Error} error The error to update.\n * @param {Object} config The config.\n * @param {string} [code] The error code (for example, 'ECONNABORTED').\n @ @param {Object} [response] The response.\n * @returns {Error} The error.\n */\nmodule.exports = function enhanceError(error, config, code, response) {\n error.config = config;\n if (code) {\n error.code = code;\n }\n error.response = response;\n return error;\n};\n","'use strict';\n\nvar createError = require('./createError');\n\n/**\n * Resolve or reject a Promise based on response status.\n *\n * @param {Function} resolve A function that resolves the promise.\n * @param {Function} reject A function that rejects the promise.\n * @param {object} response The response.\n */\nmodule.exports = function settle(resolve, reject, response) {\n var validateStatus = response.config.validateStatus;\n // Note: status is not exposed by XDomainRequest\n if (!response.status || !validateStatus || validateStatus(response.status)) {\n resolve(response);\n } else {\n reject(createError(\n 'Request failed with status code ' + response.status,\n response.config,\n null,\n response\n ));\n }\n};\n","'use strict';\n\nvar utils = require('./../utils');\n\n/**\n * Transform the data for a request or a response\n *\n * @param {Object|String} data The data to be transformed\n * @param {Array} headers The headers for the request or response\n * @param {Array|Function} fns A single function or Array of functions\n * @returns {*} The resulting transformed data\n */\nmodule.exports = function transformData(data, headers, fns) {\n /*eslint no-param-reassign:0*/\n utils.forEach(fns, function transform(fn) {\n data = fn(data, headers);\n });\n\n return data;\n};\n","'use strict';\n\nvar utils = require('./utils');\nvar normalizeHeaderName = require('./helpers/normalizeHeaderName');\n\nvar PROTECTION_PREFIX = /^\\)\\]\\}',?\\n/;\nvar DEFAULT_CONTENT_TYPE = {\n 'Content-Type': 'application/x-www-form-urlencoded'\n};\n\nfunction setContentTypeIfUnset(headers, value) {\n if (!utils.isUndefined(headers) && utils.isUndefined(headers['Content-Type'])) {\n headers['Content-Type'] = value;\n }\n}\n\nfunction getDefaultAdapter() {\n var adapter;\n if (typeof XMLHttpRequest !== 'undefined') {\n // For browsers use XHR adapter\n adapter = require('./adapters/xhr');\n } else if (typeof process !== 'undefined') {\n // For node use HTTP adapter\n adapter = require('./adapters/http');\n }\n return adapter;\n}\n\nvar defaults = {\n adapter: getDefaultAdapter(),\n\n transformRequest: [function transformRequest(data, headers) {\n normalizeHeaderName(headers, 'Content-Type');\n if (utils.isFormData(data) ||\n utils.isArrayBuffer(data) ||\n utils.isStream(data) ||\n utils.isFile(data) ||\n utils.isBlob(data)\n ) {\n return data;\n }\n if (utils.isArrayBufferView(data)) {\n return data.buffer;\n }\n if (utils.isURLSearchParams(data)) {\n setContentTypeIfUnset(headers, 'application/x-www-form-urlencoded;charset=utf-8');\n return data.toString();\n }\n if (utils.isObject(data)) {\n setContentTypeIfUnset(headers, 'application/json;charset=utf-8');\n return JSON.stringify(data);\n }\n return data;\n }],\n\n transformResponse: [function transformResponse(data) {\n /*eslint no-param-reassign:0*/\n if (typeof data === 'string') {\n data = data.replace(PROTECTION_PREFIX, '');\n try {\n data = JSON.parse(data);\n } catch (e) { /* Ignore */ }\n }\n return data;\n }],\n\n timeout: 0,\n\n xsrfCookieName: 'XSRF-TOKEN',\n xsrfHeaderName: 'X-XSRF-TOKEN',\n\n maxContentLength: -1,\n\n validateStatus: function validateStatus(status) {\n return status >= 200 && status < 300;\n }\n};\n\ndefaults.headers = {\n common: {\n 'Accept': 'application/json, text/plain, */*'\n }\n};\n\nutils.forEach(['delete', 'get', 'head'], function forEachMehtodNoData(method) {\n defaults.headers[method] = {};\n});\n\nutils.forEach(['post', 'put', 'patch'], function forEachMethodWithData(method) {\n defaults.headers[method] = utils.merge(DEFAULT_CONTENT_TYPE);\n});\n\nmodule.exports = defaults;\n","'use strict';\n\nmodule.exports = function bind(fn, thisArg) {\n return function wrap() {\n var args = new Array(arguments.length);\n for (var i = 0; i < args.length; i++) {\n args[i] = arguments[i];\n }\n return fn.apply(thisArg, args);\n };\n};\n","'use strict';\n\n// btoa polyfill for IE<10 courtesy https://github.com/davidchambers/Base64.js\n\nvar chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=';\n\nfunction E() {\n this.message = 'String contains an invalid character';\n}\nE.prototype = new Error;\nE.prototype.code = 5;\nE.prototype.name = 'InvalidCharacterError';\n\nfunction btoa(input) {\n var str = String(input);\n var output = '';\n for (\n // initialize result and counter\n var block, charCode, idx = 0, map = chars;\n // if the next str index does not exist:\n // change the mapping table to \"=\"\n // check if d has no fractional digits\n str.charAt(idx | 0) || (map = '=', idx % 1);\n // \"8 - idx % 1 * 8\" generates the sequence 2, 4, 6, 8\n output += map.charAt(63 & block >> 8 - idx % 1 * 8)\n ) {\n charCode = str.charCodeAt(idx += 3 / 4);\n if (charCode > 0xFF) {\n throw new E();\n }\n block = block << 8 | charCode;\n }\n return output;\n}\n\nmodule.exports = btoa;\n","'use strict';\n\nvar utils = require('./../utils');\n\nfunction encode(val) {\n return encodeURIComponent(val).\n replace(/%40/gi, '@').\n replace(/%3A/gi, ':').\n replace(/%24/g, '$').\n replace(/%2C/gi, ',').\n replace(/%20/g, '+').\n replace(/%5B/gi, '[').\n replace(/%5D/gi, ']');\n}\n\n/**\n * Build a URL by appending params to the end\n *\n * @param {string} url The base of the url (e.g., http://www.google.com)\n * @param {object} [params] The params to be appended\n * @returns {string} The formatted url\n */\nmodule.exports = function buildURL(url, params, paramsSerializer) {\n /*eslint no-param-reassign:0*/\n if (!params) {\n return url;\n }\n\n var serializedParams;\n if (paramsSerializer) {\n serializedParams = paramsSerializer(params);\n } else if (utils.isURLSearchParams(params)) {\n serializedParams = params.toString();\n } else {\n var parts = [];\n\n utils.forEach(params, function serialize(val, key) {\n if (val === null || typeof val === 'undefined') {\n return;\n }\n\n if (utils.isArray(val)) {\n key = key + '[]';\n }\n\n if (!utils.isArray(val)) {\n val = [val];\n }\n\n utils.forEach(val, function parseValue(v) {\n if (utils.isDate(v)) {\n v = v.toISOString();\n } else if (utils.isObject(v)) {\n v = JSON.stringify(v);\n }\n parts.push(encode(key) + '=' + encode(v));\n });\n });\n\n serializedParams = parts.join('&');\n }\n\n if (serializedParams) {\n url += (url.indexOf('?') === -1 ? '?' : '&') + serializedParams;\n }\n\n return url;\n};\n","'use strict';\n\n/**\n * Creates a new URL by combining the specified URLs\n *\n * @param {string} baseURL The base URL\n * @param {string} relativeURL The relative URL\n * @returns {string} The combined URL\n */\nmodule.exports = function combineURLs(baseURL, relativeURL) {\n return baseURL.replace(/\\/+$/, '') + '/' + relativeURL.replace(/^\\/+/, '');\n};\n","'use strict';\n\nvar utils = require('./../utils');\n\nmodule.exports = (\n utils.isStandardBrowserEnv() ?\n\n // Standard browser envs support document.cookie\n (function standardBrowserEnv() {\n return {\n write: function write(name, value, expires, path, domain, secure) {\n var cookie = [];\n cookie.push(name + '=' + encodeURIComponent(value));\n\n if (utils.isNumber(expires)) {\n cookie.push('expires=' + new Date(expires).toGMTString());\n }\n\n if (utils.isString(path)) {\n cookie.push('path=' + path);\n }\n\n if (utils.isString(domain)) {\n cookie.push('domain=' + domain);\n }\n\n if (secure === true) {\n cookie.push('secure');\n }\n\n document.cookie = cookie.join('; ');\n },\n\n read: function read(name) {\n var match = document.cookie.match(new RegExp('(^|;\\\\s*)(' + name + ')=([^;]*)'));\n return (match ? decodeURIComponent(match[3]) : null);\n },\n\n remove: function remove(name) {\n this.write(name, '', Date.now() - 86400000);\n }\n };\n })() :\n\n // Non standard browser env (web workers, react-native) lack needed support.\n (function nonStandardBrowserEnv() {\n return {\n write: function write() {},\n read: function read() { return null; },\n remove: function remove() {}\n };\n })()\n);\n","'use strict';\n\n/**\n * Determines whether the specified URL is absolute\n *\n * @param {string} url The URL to test\n * @returns {boolean} True if the specified URL is absolute, otherwise false\n */\nmodule.exports = function isAbsoluteURL(url) {\n // A URL is considered absolute if it begins with \"://\" or \"//\" (protocol-relative URL).\n // RFC 3986 defines scheme name as a sequence of characters beginning with a letter and followed\n // by any combination of letters, digits, plus, period, or hyphen.\n return /^([a-z][a-z\\d\\+\\-\\.]*:)?\\/\\//i.test(url);\n};\n","'use strict';\n\nvar utils = require('./../utils');\n\nmodule.exports = (\n utils.isStandardBrowserEnv() ?\n\n // Standard browser envs have full support of the APIs needed to test\n // whether the request URL is of the same origin as current location.\n (function standardBrowserEnv() {\n var msie = /(msie|trident)/i.test(navigator.userAgent);\n var urlParsingNode = document.createElement('a');\n var originURL;\n\n /**\n * Parse a URL to discover it's components\n *\n * @param {String} url The URL to be parsed\n * @returns {Object}\n */\n function resolveURL(url) {\n var href = url;\n\n if (msie) {\n // IE needs attribute set twice to normalize properties\n urlParsingNode.setAttribute('href', href);\n href = urlParsingNode.href;\n }\n\n urlParsingNode.setAttribute('href', href);\n\n // urlParsingNode provides the UrlUtils interface - http://url.spec.whatwg.org/#urlutils\n return {\n href: urlParsingNode.href,\n protocol: urlParsingNode.protocol ? urlParsingNode.protocol.replace(/:$/, '') : '',\n host: urlParsingNode.host,\n search: urlParsingNode.search ? urlParsingNode.search.replace(/^\\?/, '') : '',\n hash: urlParsingNode.hash ? urlParsingNode.hash.replace(/^#/, '') : '',\n hostname: urlParsingNode.hostname,\n port: urlParsingNode.port,\n pathname: (urlParsingNode.pathname.charAt(0) === '/') ?\n urlParsingNode.pathname :\n '/' + urlParsingNode.pathname\n };\n }\n\n originURL = resolveURL(window.location.href);\n\n /**\n * Determine if a URL shares the same origin as the current location\n *\n * @param {String} requestURL The URL to test\n * @returns {boolean} True if URL shares the same origin, otherwise false\n */\n return function isURLSameOrigin(requestURL) {\n var parsed = (utils.isString(requestURL)) ? resolveURL(requestURL) : requestURL;\n return (parsed.protocol === originURL.protocol &&\n parsed.host === originURL.host);\n };\n })() :\n\n // Non standard browser envs (web workers, react-native) lack needed support.\n (function nonStandardBrowserEnv() {\n return function isURLSameOrigin() {\n return true;\n };\n })()\n);\n","'use strict';\n\nvar utils = require('../utils');\n\nmodule.exports = function normalizeHeaderName(headers, normalizedName) {\n utils.forEach(headers, function processHeader(value, name) {\n if (name !== normalizedName && name.toUpperCase() === normalizedName.toUpperCase()) {\n headers[normalizedName] = value;\n delete headers[name];\n }\n });\n};\n","'use strict';\n\nvar utils = require('./../utils');\n\n/**\n * Parse headers into an object\n *\n * ```\n * Date: Wed, 27 Aug 2014 08:58:49 GMT\n * Content-Type: application/json\n * Connection: keep-alive\n * Transfer-Encoding: chunked\n * ```\n *\n * @param {String} headers Headers needing to be parsed\n * @returns {Object} Headers parsed into an object\n */\nmodule.exports = function parseHeaders(headers) {\n var parsed = {};\n var key;\n var val;\n var i;\n\n if (!headers) { return parsed; }\n\n utils.forEach(headers.split('\\n'), function parser(line) {\n i = line.indexOf(':');\n key = utils.trim(line.substr(0, i)).toLowerCase();\n val = utils.trim(line.substr(i + 1));\n\n if (key) {\n parsed[key] = parsed[key] ? parsed[key] + ', ' + val : val;\n }\n });\n\n return parsed;\n};\n","'use strict';\n\n/**\n * Syntactic sugar for invoking a function and expanding an array for arguments.\n *\n * Common use case would be to use `Function.prototype.apply`.\n *\n * ```js\n * function f(x, y, z) {}\n * var args = [1, 2, 3];\n * f.apply(null, args);\n * ```\n *\n * With `spread` this example can be re-written.\n *\n * ```js\n * spread(function(x, y, z) {})([1, 2, 3]);\n * ```\n *\n * @param {Function} callback\n * @returns {Function}\n */\nmodule.exports = function spread(callback) {\n return function wrap(arr) {\n return callback.apply(null, arr);\n };\n};\n","'use strict';\n\nvar bind = require('./helpers/bind');\n\n/*global toString:true*/\n\n// utils is a library of generic helper functions non-specific to axios\n\nvar toString = Object.prototype.toString;\n\n/**\n * Determine if a value is an Array\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if value is an Array, otherwise false\n */\nfunction isArray(val) {\n return toString.call(val) === '[object Array]';\n}\n\n/**\n * Determine if a value is an ArrayBuffer\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if value is an ArrayBuffer, otherwise false\n */\nfunction isArrayBuffer(val) {\n return toString.call(val) === '[object ArrayBuffer]';\n}\n\n/**\n * Determine if a value is a FormData\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if value is an FormData, otherwise false\n */\nfunction isFormData(val) {\n return (typeof FormData !== 'undefined') && (val instanceof FormData);\n}\n\n/**\n * Determine if a value is a view on an ArrayBuffer\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if value is a view on an ArrayBuffer, otherwise false\n */\nfunction isArrayBufferView(val) {\n var result;\n if ((typeof ArrayBuffer !== 'undefined') && (ArrayBuffer.isView)) {\n result = ArrayBuffer.isView(val);\n } else {\n result = (val) && (val.buffer) && (val.buffer instanceof ArrayBuffer);\n }\n return result;\n}\n\n/**\n * Determine if a value is a String\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if value is a String, otherwise false\n */\nfunction isString(val) {\n return typeof val === 'string';\n}\n\n/**\n * Determine if a value is a Number\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if value is a Number, otherwise false\n */\nfunction isNumber(val) {\n return typeof val === 'number';\n}\n\n/**\n * Determine if a value is undefined\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if the value is undefined, otherwise false\n */\nfunction isUndefined(val) {\n return typeof val === 'undefined';\n}\n\n/**\n * Determine if a value is an Object\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if value is an Object, otherwise false\n */\nfunction isObject(val) {\n return val !== null && typeof val === 'object';\n}\n\n/**\n * Determine if a value is a Date\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if value is a Date, otherwise false\n */\nfunction isDate(val) {\n return toString.call(val) === '[object Date]';\n}\n\n/**\n * Determine if a value is a File\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if value is a File, otherwise false\n */\nfunction isFile(val) {\n return toString.call(val) === '[object File]';\n}\n\n/**\n * Determine if a value is a Blob\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if value is a Blob, otherwise false\n */\nfunction isBlob(val) {\n return toString.call(val) === '[object Blob]';\n}\n\n/**\n * Determine if a value is a Function\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if value is a Function, otherwise false\n */\nfunction isFunction(val) {\n return toString.call(val) === '[object Function]';\n}\n\n/**\n * Determine if a value is a Stream\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if value is a Stream, otherwise false\n */\nfunction isStream(val) {\n return isObject(val) && isFunction(val.pipe);\n}\n\n/**\n * Determine if a value is a URLSearchParams object\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if value is a URLSearchParams object, otherwise false\n */\nfunction isURLSearchParams(val) {\n return typeof URLSearchParams !== 'undefined' && val instanceof URLSearchParams;\n}\n\n/**\n * Trim excess whitespace off the beginning and end of a string\n *\n * @param {String} str The String to trim\n * @returns {String} The String freed of excess whitespace\n */\nfunction trim(str) {\n return str.replace(/^\\s*/, '').replace(/\\s*$/, '');\n}\n\n/**\n * Determine if we're running in a standard browser environment\n *\n * This allows axios to run in a web worker, and react-native.\n * Both environments support XMLHttpRequest, but not fully standard globals.\n *\n * web workers:\n * typeof window -> undefined\n * typeof document -> undefined\n *\n * react-native:\n * typeof document.createElement -> undefined\n */\nfunction isStandardBrowserEnv() {\n return (\n typeof window !== 'undefined' &&\n typeof document !== 'undefined' &&\n typeof document.createElement === 'function'\n );\n}\n\n/**\n * Iterate over an Array or an Object invoking a function for each item.\n *\n * If `obj` is an Array callback will be called passing\n * the value, index, and complete array for each item.\n *\n * If 'obj' is an Object callback will be called passing\n * the value, key, and complete object for each property.\n *\n * @param {Object|Array} obj The object to iterate\n * @param {Function} fn The callback to invoke for each item\n */\nfunction forEach(obj, fn) {\n // Don't bother if no value provided\n if (obj === null || typeof obj === 'undefined') {\n return;\n }\n\n // Force an array if not already something iterable\n if (typeof obj !== 'object' && !isArray(obj)) {\n /*eslint no-param-reassign:0*/\n obj = [obj];\n }\n\n if (isArray(obj)) {\n // Iterate over array values\n for (var i = 0, l = obj.length; i < l; i++) {\n fn.call(null, obj[i], i, obj);\n }\n } else {\n // Iterate over object keys\n for (var key in obj) {\n if (Object.prototype.hasOwnProperty.call(obj, key)) {\n fn.call(null, obj[key], key, obj);\n }\n }\n }\n}\n\n/**\n * Accepts varargs expecting each argument to be an object, then\n * immutably merges the properties of each object and returns result.\n *\n * When multiple objects contain the same key the later object in\n * the arguments list will take precedence.\n *\n * Example:\n *\n * ```js\n * var result = merge({foo: 123}, {foo: 456});\n * console.log(result.foo); // outputs 456\n * ```\n *\n * @param {Object} obj1 Object to merge\n * @returns {Object} Result of all merge properties\n */\nfunction merge(/* obj1, obj2, obj3, ... */) {\n var result = {};\n function assignValue(val, key) {\n if (typeof result[key] === 'object' && typeof val === 'object') {\n result[key] = merge(result[key], val);\n } else {\n result[key] = val;\n }\n }\n\n for (var i = 0, l = arguments.length; i < l; i++) {\n forEach(arguments[i], assignValue);\n }\n return result;\n}\n\n/**\n * Extends object a by mutably adding to it the properties of object b.\n *\n * @param {Object} a The object to be extended\n * @param {Object} b The object to copy properties from\n * @param {Object} thisArg The object to bind function to\n * @return {Object} The resulting value of object a\n */\nfunction extend(a, b, thisArg) {\n forEach(b, function assignValue(val, key) {\n if (thisArg && typeof val === 'function') {\n a[key] = bind(val, thisArg);\n } else {\n a[key] = val;\n }\n });\n return a;\n}\n\nmodule.exports = {\n isArray: isArray,\n isArrayBuffer: isArrayBuffer,\n isFormData: isFormData,\n isArrayBufferView: isArrayBufferView,\n isString: isString,\n isNumber: isNumber,\n isObject: isObject,\n isUndefined: isUndefined,\n isDate: isDate,\n isFile: isFile,\n isBlob: isBlob,\n isFunction: isFunction,\n isStream: isStream,\n isURLSearchParams: isURLSearchParams,\n isStandardBrowserEnv: isStandardBrowserEnv,\n forEach: forEach,\n merge: merge,\n extend: extend,\n trim: trim\n};\n","'use strict'\n\nexports.byteLength = byteLength\nexports.toByteArray = toByteArray\nexports.fromByteArray = fromByteArray\n\nvar lookup = []\nvar revLookup = []\nvar Arr = typeof Uint8Array !== 'undefined' ? Uint8Array : Array\n\nvar code = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'\nfor (var i = 0, len = code.length; i < len; ++i) {\n lookup[i] = code[i]\n revLookup[code.charCodeAt(i)] = i\n}\n\nrevLookup['-'.charCodeAt(0)] = 62\nrevLookup['_'.charCodeAt(0)] = 63\n\nfunction placeHoldersCount (b64) {\n var len = b64.length\n if (len % 4 > 0) {\n throw new Error('Invalid string. Length must be a multiple of 4')\n }\n\n // the number of equal signs (place holders)\n // if there are two placeholders, than the two characters before it\n // represent one byte\n // if there is only one, then the three characters before it represent 2 bytes\n // this is just a cheap hack to not do indexOf twice\n return b64[len - 2] === '=' ? 2 : b64[len - 1] === '=' ? 1 : 0\n}\n\nfunction byteLength (b64) {\n // base64 is 4/3 + up to two characters of the original data\n return b64.length * 3 / 4 - placeHoldersCount(b64)\n}\n\nfunction toByteArray (b64) {\n var i, j, l, tmp, placeHolders, arr\n var len = b64.length\n placeHolders = placeHoldersCount(b64)\n\n arr = new Arr(len * 3 / 4 - placeHolders)\n\n // if there are placeholders, only get up to the last complete 4 chars\n l = placeHolders > 0 ? len - 4 : len\n\n var L = 0\n\n for (i = 0, j = 0; i < l; i += 4, j += 3) {\n tmp = (revLookup[b64.charCodeAt(i)] << 18) | (revLookup[b64.charCodeAt(i + 1)] << 12) | (revLookup[b64.charCodeAt(i + 2)] << 6) | revLookup[b64.charCodeAt(i + 3)]\n arr[L++] = (tmp >> 16) & 0xFF\n arr[L++] = (tmp >> 8) & 0xFF\n arr[L++] = tmp & 0xFF\n }\n\n if (placeHolders === 2) {\n tmp = (revLookup[b64.charCodeAt(i)] << 2) | (revLookup[b64.charCodeAt(i + 1)] >> 4)\n arr[L++] = tmp & 0xFF\n } else if (placeHolders === 1) {\n tmp = (revLookup[b64.charCodeAt(i)] << 10) | (revLookup[b64.charCodeAt(i + 1)] << 4) | (revLookup[b64.charCodeAt(i + 2)] >> 2)\n arr[L++] = (tmp >> 8) & 0xFF\n arr[L++] = tmp & 0xFF\n }\n\n return arr\n}\n\nfunction tripletToBase64 (num) {\n return lookup[num >> 18 & 0x3F] + lookup[num >> 12 & 0x3F] + lookup[num >> 6 & 0x3F] + lookup[num & 0x3F]\n}\n\nfunction encodeChunk (uint8, start, end) {\n var tmp\n var output = []\n for (var i = start; i < end; i += 3) {\n tmp = (uint8[i] << 16) + (uint8[i + 1] << 8) + (uint8[i + 2])\n output.push(tripletToBase64(tmp))\n }\n return output.join('')\n}\n\nfunction fromByteArray (uint8) {\n var tmp\n var len = uint8.length\n var extraBytes = len % 3 // if we have 1 byte left, pad 2 bytes\n var output = ''\n var parts = []\n var maxChunkLength = 16383 // must be multiple of 3\n\n // go through the array every three bytes, we'll deal with trailing stuff later\n for (var i = 0, len2 = len - extraBytes; i < len2; i += maxChunkLength) {\n parts.push(encodeChunk(uint8, i, (i + maxChunkLength) > len2 ? len2 : (i + maxChunkLength)))\n }\n\n // pad the end with zeros, but make sure to not forget the extra bytes\n if (extraBytes === 1) {\n tmp = uint8[len - 1]\n output += lookup[tmp >> 2]\n output += lookup[(tmp << 4) & 0x3F]\n output += '=='\n } else if (extraBytes === 2) {\n tmp = (uint8[len - 2] << 8) + (uint8[len - 1])\n output += lookup[tmp >> 10]\n output += lookup[(tmp >> 4) & 0x3F]\n output += lookup[(tmp << 2) & 0x3F]\n output += '='\n }\n\n parts.push(output)\n\n return parts.join('')\n}\n","/*!\n * The buffer module from node.js, for the browser.\n *\n * @author Feross Aboukhadijeh \n * @license MIT\n */\n/* eslint-disable no-proto */\n\n'use strict'\n\nvar base64 = require('base64-js')\nvar ieee754 = require('ieee754')\nvar isArray = require('isarray')\n\nexports.Buffer = Buffer\nexports.SlowBuffer = SlowBuffer\nexports.INSPECT_MAX_BYTES = 50\n\n/**\n * If `Buffer.TYPED_ARRAY_SUPPORT`:\n * === true Use Uint8Array implementation (fastest)\n * === false Use Object implementation (most compatible, even IE6)\n *\n * Browsers that support typed arrays are IE 10+, Firefox 4+, Chrome 7+, Safari 5.1+,\n * Opera 11.6+, iOS 4.2+.\n *\n * Due to various browser bugs, sometimes the Object implementation will be used even\n * when the browser supports typed arrays.\n *\n * Note:\n *\n * - Firefox 4-29 lacks support for adding new properties to `Uint8Array` instances,\n * See: https://bugzilla.mozilla.org/show_bug.cgi?id=695438.\n *\n * - Chrome 9-10 is missing the `TypedArray.prototype.subarray` function.\n *\n * - IE10 has a broken `TypedArray.prototype.subarray` function which returns arrays of\n * incorrect length in some situations.\n\n * We detect these buggy browsers and set `Buffer.TYPED_ARRAY_SUPPORT` to `false` so they\n * get the Object implementation, which is slower but behaves correctly.\n */\nBuffer.TYPED_ARRAY_SUPPORT = global.TYPED_ARRAY_SUPPORT !== undefined\n ? global.TYPED_ARRAY_SUPPORT\n : typedArraySupport()\n\n/*\n * Export kMaxLength after typed array support is determined.\n */\nexports.kMaxLength = kMaxLength()\n\nfunction typedArraySupport () {\n try {\n var arr = new Uint8Array(1)\n arr.__proto__ = {__proto__: Uint8Array.prototype, foo: function () { return 42 }}\n return arr.foo() === 42 && // typed array instances can be augmented\n typeof arr.subarray === 'function' && // chrome 9-10 lack `subarray`\n arr.subarray(1, 1).byteLength === 0 // ie10 has broken `subarray`\n } catch (e) {\n return false\n }\n}\n\nfunction kMaxLength () {\n return Buffer.TYPED_ARRAY_SUPPORT\n ? 0x7fffffff\n : 0x3fffffff\n}\n\nfunction createBuffer (that, length) {\n if (kMaxLength() < length) {\n throw new RangeError('Invalid typed array length')\n }\n if (Buffer.TYPED_ARRAY_SUPPORT) {\n // Return an augmented `Uint8Array` instance, for best performance\n that = new Uint8Array(length)\n that.__proto__ = Buffer.prototype\n } else {\n // Fallback: Return an object instance of the Buffer class\n if (that === null) {\n that = new Buffer(length)\n }\n that.length = length\n }\n\n return that\n}\n\n/**\n * The Buffer constructor returns instances of `Uint8Array` that have their\n * prototype changed to `Buffer.prototype`. Furthermore, `Buffer` is a subclass of\n * `Uint8Array`, so the returned instances will have all the node `Buffer` methods\n * and the `Uint8Array` methods. Square bracket notation works as expected -- it\n * returns a single octet.\n *\n * The `Uint8Array` prototype remains unmodified.\n */\n\nfunction Buffer (arg, encodingOrOffset, length) {\n if (!Buffer.TYPED_ARRAY_SUPPORT && !(this instanceof Buffer)) {\n return new Buffer(arg, encodingOrOffset, length)\n }\n\n // Common case.\n if (typeof arg === 'number') {\n if (typeof encodingOrOffset === 'string') {\n throw new Error(\n 'If encoding is specified then the first argument must be a string'\n )\n }\n return allocUnsafe(this, arg)\n }\n return from(this, arg, encodingOrOffset, length)\n}\n\nBuffer.poolSize = 8192 // not used by this implementation\n\n// TODO: Legacy, not needed anymore. Remove in next major version.\nBuffer._augment = function (arr) {\n arr.__proto__ = Buffer.prototype\n return arr\n}\n\nfunction from (that, value, encodingOrOffset, length) {\n if (typeof value === 'number') {\n throw new TypeError('\"value\" argument must not be a number')\n }\n\n if (typeof ArrayBuffer !== 'undefined' && value instanceof ArrayBuffer) {\n return fromArrayBuffer(that, value, encodingOrOffset, length)\n }\n\n if (typeof value === 'string') {\n return fromString(that, value, encodingOrOffset)\n }\n\n return fromObject(that, value)\n}\n\n/**\n * Functionally equivalent to Buffer(arg, encoding) but throws a TypeError\n * if value is a number.\n * Buffer.from(str[, encoding])\n * Buffer.from(array)\n * Buffer.from(buffer)\n * Buffer.from(arrayBuffer[, byteOffset[, length]])\n **/\nBuffer.from = function (value, encodingOrOffset, length) {\n return from(null, value, encodingOrOffset, length)\n}\n\nif (Buffer.TYPED_ARRAY_SUPPORT) {\n Buffer.prototype.__proto__ = Uint8Array.prototype\n Buffer.__proto__ = Uint8Array\n if (typeof Symbol !== 'undefined' && Symbol.species &&\n Buffer[Symbol.species] === Buffer) {\n // Fix subarray() in ES2016. See: https://github.com/feross/buffer/pull/97\n Object.defineProperty(Buffer, Symbol.species, {\n value: null,\n configurable: true\n })\n }\n}\n\nfunction assertSize (size) {\n if (typeof size !== 'number') {\n throw new TypeError('\"size\" argument must be a number')\n } else if (size < 0) {\n throw new RangeError('\"size\" argument must not be negative')\n }\n}\n\nfunction alloc (that, size, fill, encoding) {\n assertSize(size)\n if (size <= 0) {\n return createBuffer(that, size)\n }\n if (fill !== undefined) {\n // Only pay attention to encoding if it's a string. This\n // prevents accidentally sending in a number that would\n // be interpretted as a start offset.\n return typeof encoding === 'string'\n ? createBuffer(that, size).fill(fill, encoding)\n : createBuffer(that, size).fill(fill)\n }\n return createBuffer(that, size)\n}\n\n/**\n * Creates a new filled Buffer instance.\n * alloc(size[, fill[, encoding]])\n **/\nBuffer.alloc = function (size, fill, encoding) {\n return alloc(null, size, fill, encoding)\n}\n\nfunction allocUnsafe (that, size) {\n assertSize(size)\n that = createBuffer(that, size < 0 ? 0 : checked(size) | 0)\n if (!Buffer.TYPED_ARRAY_SUPPORT) {\n for (var i = 0; i < size; ++i) {\n that[i] = 0\n }\n }\n return that\n}\n\n/**\n * Equivalent to Buffer(num), by default creates a non-zero-filled Buffer instance.\n * */\nBuffer.allocUnsafe = function (size) {\n return allocUnsafe(null, size)\n}\n/**\n * Equivalent to SlowBuffer(num), by default creates a non-zero-filled Buffer instance.\n */\nBuffer.allocUnsafeSlow = function (size) {\n return allocUnsafe(null, size)\n}\n\nfunction fromString (that, string, encoding) {\n if (typeof encoding !== 'string' || encoding === '') {\n encoding = 'utf8'\n }\n\n if (!Buffer.isEncoding(encoding)) {\n throw new TypeError('\"encoding\" must be a valid string encoding')\n }\n\n var length = byteLength(string, encoding) | 0\n that = createBuffer(that, length)\n\n var actual = that.write(string, encoding)\n\n if (actual !== length) {\n // Writing a hex string, for example, that contains invalid characters will\n // cause everything after the first invalid character to be ignored. (e.g.\n // 'abxxcd' will be treated as 'ab')\n that = that.slice(0, actual)\n }\n\n return that\n}\n\nfunction fromArrayLike (that, array) {\n var length = array.length < 0 ? 0 : checked(array.length) | 0\n that = createBuffer(that, length)\n for (var i = 0; i < length; i += 1) {\n that[i] = array[i] & 255\n }\n return that\n}\n\nfunction fromArrayBuffer (that, array, byteOffset, length) {\n array.byteLength // this throws if `array` is not a valid ArrayBuffer\n\n if (byteOffset < 0 || array.byteLength < byteOffset) {\n throw new RangeError('\\'offset\\' is out of bounds')\n }\n\n if (array.byteLength < byteOffset + (length || 0)) {\n throw new RangeError('\\'length\\' is out of bounds')\n }\n\n if (byteOffset === undefined && length === undefined) {\n array = new Uint8Array(array)\n } else if (length === undefined) {\n array = new Uint8Array(array, byteOffset)\n } else {\n array = new Uint8Array(array, byteOffset, length)\n }\n\n if (Buffer.TYPED_ARRAY_SUPPORT) {\n // Return an augmented `Uint8Array` instance, for best performance\n that = array\n that.__proto__ = Buffer.prototype\n } else {\n // Fallback: Return an object instance of the Buffer class\n that = fromArrayLike(that, array)\n }\n return that\n}\n\nfunction fromObject (that, obj) {\n if (Buffer.isBuffer(obj)) {\n var len = checked(obj.length) | 0\n that = createBuffer(that, len)\n\n if (that.length === 0) {\n return that\n }\n\n obj.copy(that, 0, 0, len)\n return that\n }\n\n if (obj) {\n if ((typeof ArrayBuffer !== 'undefined' &&\n obj.buffer instanceof ArrayBuffer) || 'length' in obj) {\n if (typeof obj.length !== 'number' || isnan(obj.length)) {\n return createBuffer(that, 0)\n }\n return fromArrayLike(that, obj)\n }\n\n if (obj.type === 'Buffer' && isArray(obj.data)) {\n return fromArrayLike(that, obj.data)\n }\n }\n\n throw new TypeError('First argument must be a string, Buffer, ArrayBuffer, Array, or array-like object.')\n}\n\nfunction checked (length) {\n // Note: cannot use `length < kMaxLength()` here because that fails when\n // length is NaN (which is otherwise coerced to zero.)\n if (length >= kMaxLength()) {\n throw new RangeError('Attempt to allocate Buffer larger than maximum ' +\n 'size: 0x' + kMaxLength().toString(16) + ' bytes')\n }\n return length | 0\n}\n\nfunction SlowBuffer (length) {\n if (+length != length) { // eslint-disable-line eqeqeq\n length = 0\n }\n return Buffer.alloc(+length)\n}\n\nBuffer.isBuffer = function isBuffer (b) {\n return !!(b != null && b._isBuffer)\n}\n\nBuffer.compare = function compare (a, b) {\n if (!Buffer.isBuffer(a) || !Buffer.isBuffer(b)) {\n throw new TypeError('Arguments must be Buffers')\n }\n\n if (a === b) return 0\n\n var x = a.length\n var y = b.length\n\n for (var i = 0, len = Math.min(x, y); i < len; ++i) {\n if (a[i] !== b[i]) {\n x = a[i]\n y = b[i]\n break\n }\n }\n\n if (x < y) return -1\n if (y < x) return 1\n return 0\n}\n\nBuffer.isEncoding = function isEncoding (encoding) {\n switch (String(encoding).toLowerCase()) {\n case 'hex':\n case 'utf8':\n case 'utf-8':\n case 'ascii':\n case 'latin1':\n case 'binary':\n case 'base64':\n case 'ucs2':\n case 'ucs-2':\n case 'utf16le':\n case 'utf-16le':\n return true\n default:\n return false\n }\n}\n\nBuffer.concat = function concat (list, length) {\n if (!isArray(list)) {\n throw new TypeError('\"list\" argument must be an Array of Buffers')\n }\n\n if (list.length === 0) {\n return Buffer.alloc(0)\n }\n\n var i\n if (length === undefined) {\n length = 0\n for (i = 0; i < list.length; ++i) {\n length += list[i].length\n }\n }\n\n var buffer = Buffer.allocUnsafe(length)\n var pos = 0\n for (i = 0; i < list.length; ++i) {\n var buf = list[i]\n if (!Buffer.isBuffer(buf)) {\n throw new TypeError('\"list\" argument must be an Array of Buffers')\n }\n buf.copy(buffer, pos)\n pos += buf.length\n }\n return buffer\n}\n\nfunction byteLength (string, encoding) {\n if (Buffer.isBuffer(string)) {\n return string.length\n }\n if (typeof ArrayBuffer !== 'undefined' && typeof ArrayBuffer.isView === 'function' &&\n (ArrayBuffer.isView(string) || string instanceof ArrayBuffer)) {\n return string.byteLength\n }\n if (typeof string !== 'string') {\n string = '' + string\n }\n\n var len = string.length\n if (len === 0) return 0\n\n // Use a for loop to avoid recursion\n var loweredCase = false\n for (;;) {\n switch (encoding) {\n case 'ascii':\n case 'latin1':\n case 'binary':\n return len\n case 'utf8':\n case 'utf-8':\n case undefined:\n return utf8ToBytes(string).length\n case 'ucs2':\n case 'ucs-2':\n case 'utf16le':\n case 'utf-16le':\n return len * 2\n case 'hex':\n return len >>> 1\n case 'base64':\n return base64ToBytes(string).length\n default:\n if (loweredCase) return utf8ToBytes(string).length // assume utf8\n encoding = ('' + encoding).toLowerCase()\n loweredCase = true\n }\n }\n}\nBuffer.byteLength = byteLength\n\nfunction slowToString (encoding, start, end) {\n var loweredCase = false\n\n // No need to verify that \"this.length <= MAX_UINT32\" since it's a read-only\n // property of a typed array.\n\n // This behaves neither like String nor Uint8Array in that we set start/end\n // to their upper/lower bounds if the value passed is out of range.\n // undefined is handled specially as per ECMA-262 6th Edition,\n // Section 13.3.3.7 Runtime Semantics: KeyedBindingInitialization.\n if (start === undefined || start < 0) {\n start = 0\n }\n // Return early if start > this.length. Done here to prevent potential uint32\n // coercion fail below.\n if (start > this.length) {\n return ''\n }\n\n if (end === undefined || end > this.length) {\n end = this.length\n }\n\n if (end <= 0) {\n return ''\n }\n\n // Force coersion to uint32. This will also coerce falsey/NaN values to 0.\n end >>>= 0\n start >>>= 0\n\n if (end <= start) {\n return ''\n }\n\n if (!encoding) encoding = 'utf8'\n\n while (true) {\n switch (encoding) {\n case 'hex':\n return hexSlice(this, start, end)\n\n case 'utf8':\n case 'utf-8':\n return utf8Slice(this, start, end)\n\n case 'ascii':\n return asciiSlice(this, start, end)\n\n case 'latin1':\n case 'binary':\n return latin1Slice(this, start, end)\n\n case 'base64':\n return base64Slice(this, start, end)\n\n case 'ucs2':\n case 'ucs-2':\n case 'utf16le':\n case 'utf-16le':\n return utf16leSlice(this, start, end)\n\n default:\n if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)\n encoding = (encoding + '').toLowerCase()\n loweredCase = true\n }\n }\n}\n\n// The property is used by `Buffer.isBuffer` and `is-buffer` (in Safari 5-7) to detect\n// Buffer instances.\nBuffer.prototype._isBuffer = true\n\nfunction swap (b, n, m) {\n var i = b[n]\n b[n] = b[m]\n b[m] = i\n}\n\nBuffer.prototype.swap16 = function swap16 () {\n var len = this.length\n if (len % 2 !== 0) {\n throw new RangeError('Buffer size must be a multiple of 16-bits')\n }\n for (var i = 0; i < len; i += 2) {\n swap(this, i, i + 1)\n }\n return this\n}\n\nBuffer.prototype.swap32 = function swap32 () {\n var len = this.length\n if (len % 4 !== 0) {\n throw new RangeError('Buffer size must be a multiple of 32-bits')\n }\n for (var i = 0; i < len; i += 4) {\n swap(this, i, i + 3)\n swap(this, i + 1, i + 2)\n }\n return this\n}\n\nBuffer.prototype.swap64 = function swap64 () {\n var len = this.length\n if (len % 8 !== 0) {\n throw new RangeError('Buffer size must be a multiple of 64-bits')\n }\n for (var i = 0; i < len; i += 8) {\n swap(this, i, i + 7)\n swap(this, i + 1, i + 6)\n swap(this, i + 2, i + 5)\n swap(this, i + 3, i + 4)\n }\n return this\n}\n\nBuffer.prototype.toString = function toString () {\n var length = this.length | 0\n if (length === 0) return ''\n if (arguments.length === 0) return utf8Slice(this, 0, length)\n return slowToString.apply(this, arguments)\n}\n\nBuffer.prototype.equals = function equals (b) {\n if (!Buffer.isBuffer(b)) throw new TypeError('Argument must be a Buffer')\n if (this === b) return true\n return Buffer.compare(this, b) === 0\n}\n\nBuffer.prototype.inspect = function inspect () {\n var str = ''\n var max = exports.INSPECT_MAX_BYTES\n if (this.length > 0) {\n str = this.toString('hex', 0, max).match(/.{2}/g).join(' ')\n if (this.length > max) str += ' ... '\n }\n return ''\n}\n\nBuffer.prototype.compare = function compare (target, start, end, thisStart, thisEnd) {\n if (!Buffer.isBuffer(target)) {\n throw new TypeError('Argument must be a Buffer')\n }\n\n if (start === undefined) {\n start = 0\n }\n if (end === undefined) {\n end = target ? target.length : 0\n }\n if (thisStart === undefined) {\n thisStart = 0\n }\n if (thisEnd === undefined) {\n thisEnd = this.length\n }\n\n if (start < 0 || end > target.length || thisStart < 0 || thisEnd > this.length) {\n throw new RangeError('out of range index')\n }\n\n if (thisStart >= thisEnd && start >= end) {\n return 0\n }\n if (thisStart >= thisEnd) {\n return -1\n }\n if (start >= end) {\n return 1\n }\n\n start >>>= 0\n end >>>= 0\n thisStart >>>= 0\n thisEnd >>>= 0\n\n if (this === target) return 0\n\n var x = thisEnd - thisStart\n var y = end - start\n var len = Math.min(x, y)\n\n var thisCopy = this.slice(thisStart, thisEnd)\n var targetCopy = target.slice(start, end)\n\n for (var i = 0; i < len; ++i) {\n if (thisCopy[i] !== targetCopy[i]) {\n x = thisCopy[i]\n y = targetCopy[i]\n break\n }\n }\n\n if (x < y) return -1\n if (y < x) return 1\n return 0\n}\n\n// Finds either the first index of `val` in `buffer` at offset >= `byteOffset`,\n// OR the last index of `val` in `buffer` at offset <= `byteOffset`.\n//\n// Arguments:\n// - buffer - a Buffer to search\n// - val - a string, Buffer, or number\n// - byteOffset - an index into `buffer`; will be clamped to an int32\n// - encoding - an optional encoding, relevant is val is a string\n// - dir - true for indexOf, false for lastIndexOf\nfunction bidirectionalIndexOf (buffer, val, byteOffset, encoding, dir) {\n // Empty buffer means no match\n if (buffer.length === 0) return -1\n\n // Normalize byteOffset\n if (typeof byteOffset === 'string') {\n encoding = byteOffset\n byteOffset = 0\n } else if (byteOffset > 0x7fffffff) {\n byteOffset = 0x7fffffff\n } else if (byteOffset < -0x80000000) {\n byteOffset = -0x80000000\n }\n byteOffset = +byteOffset // Coerce to Number.\n if (isNaN(byteOffset)) {\n // byteOffset: it it's undefined, null, NaN, \"foo\", etc, search whole buffer\n byteOffset = dir ? 0 : (buffer.length - 1)\n }\n\n // Normalize byteOffset: negative offsets start from the end of the buffer\n if (byteOffset < 0) byteOffset = buffer.length + byteOffset\n if (byteOffset >= buffer.length) {\n if (dir) return -1\n else byteOffset = buffer.length - 1\n } else if (byteOffset < 0) {\n if (dir) byteOffset = 0\n else return -1\n }\n\n // Normalize val\n if (typeof val === 'string') {\n val = Buffer.from(val, encoding)\n }\n\n // Finally, search either indexOf (if dir is true) or lastIndexOf\n if (Buffer.isBuffer(val)) {\n // Special case: looking for empty string/buffer always fails\n if (val.length === 0) {\n return -1\n }\n return arrayIndexOf(buffer, val, byteOffset, encoding, dir)\n } else if (typeof val === 'number') {\n val = val & 0xFF // Search for a byte value [0-255]\n if (Buffer.TYPED_ARRAY_SUPPORT &&\n typeof Uint8Array.prototype.indexOf === 'function') {\n if (dir) {\n return Uint8Array.prototype.indexOf.call(buffer, val, byteOffset)\n } else {\n return Uint8Array.prototype.lastIndexOf.call(buffer, val, byteOffset)\n }\n }\n return arrayIndexOf(buffer, [ val ], byteOffset, encoding, dir)\n }\n\n throw new TypeError('val must be string, number or Buffer')\n}\n\nfunction arrayIndexOf (arr, val, byteOffset, encoding, dir) {\n var indexSize = 1\n var arrLength = arr.length\n var valLength = val.length\n\n if (encoding !== undefined) {\n encoding = String(encoding).toLowerCase()\n if (encoding === 'ucs2' || encoding === 'ucs-2' ||\n encoding === 'utf16le' || encoding === 'utf-16le') {\n if (arr.length < 2 || val.length < 2) {\n return -1\n }\n indexSize = 2\n arrLength /= 2\n valLength /= 2\n byteOffset /= 2\n }\n }\n\n function read (buf, i) {\n if (indexSize === 1) {\n return buf[i]\n } else {\n return buf.readUInt16BE(i * indexSize)\n }\n }\n\n var i\n if (dir) {\n var foundIndex = -1\n for (i = byteOffset; i < arrLength; i++) {\n if (read(arr, i) === read(val, foundIndex === -1 ? 0 : i - foundIndex)) {\n if (foundIndex === -1) foundIndex = i\n if (i - foundIndex + 1 === valLength) return foundIndex * indexSize\n } else {\n if (foundIndex !== -1) i -= i - foundIndex\n foundIndex = -1\n }\n }\n } else {\n if (byteOffset + valLength > arrLength) byteOffset = arrLength - valLength\n for (i = byteOffset; i >= 0; i--) {\n var found = true\n for (var j = 0; j < valLength; j++) {\n if (read(arr, i + j) !== read(val, j)) {\n found = false\n break\n }\n }\n if (found) return i\n }\n }\n\n return -1\n}\n\nBuffer.prototype.includes = function includes (val, byteOffset, encoding) {\n return this.indexOf(val, byteOffset, encoding) !== -1\n}\n\nBuffer.prototype.indexOf = function indexOf (val, byteOffset, encoding) {\n return bidirectionalIndexOf(this, val, byteOffset, encoding, true)\n}\n\nBuffer.prototype.lastIndexOf = function lastIndexOf (val, byteOffset, encoding) {\n return bidirectionalIndexOf(this, val, byteOffset, encoding, false)\n}\n\nfunction hexWrite (buf, string, offset, length) {\n offset = Number(offset) || 0\n var remaining = buf.length - offset\n if (!length) {\n length = remaining\n } else {\n length = Number(length)\n if (length > remaining) {\n length = remaining\n }\n }\n\n // must be an even number of digits\n var strLen = string.length\n if (strLen % 2 !== 0) throw new TypeError('Invalid hex string')\n\n if (length > strLen / 2) {\n length = strLen / 2\n }\n for (var i = 0; i < length; ++i) {\n var parsed = parseInt(string.substr(i * 2, 2), 16)\n if (isNaN(parsed)) return i\n buf[offset + i] = parsed\n }\n return i\n}\n\nfunction utf8Write (buf, string, offset, length) {\n return blitBuffer(utf8ToBytes(string, buf.length - offset), buf, offset, length)\n}\n\nfunction asciiWrite (buf, string, offset, length) {\n return blitBuffer(asciiToBytes(string), buf, offset, length)\n}\n\nfunction latin1Write (buf, string, offset, length) {\n return asciiWrite(buf, string, offset, length)\n}\n\nfunction base64Write (buf, string, offset, length) {\n return blitBuffer(base64ToBytes(string), buf, offset, length)\n}\n\nfunction ucs2Write (buf, string, offset, length) {\n return blitBuffer(utf16leToBytes(string, buf.length - offset), buf, offset, length)\n}\n\nBuffer.prototype.write = function write (string, offset, length, encoding) {\n // Buffer#write(string)\n if (offset === undefined) {\n encoding = 'utf8'\n length = this.length\n offset = 0\n // Buffer#write(string, encoding)\n } else if (length === undefined && typeof offset === 'string') {\n encoding = offset\n length = this.length\n offset = 0\n // Buffer#write(string, offset[, length][, encoding])\n } else if (isFinite(offset)) {\n offset = offset | 0\n if (isFinite(length)) {\n length = length | 0\n if (encoding === undefined) encoding = 'utf8'\n } else {\n encoding = length\n length = undefined\n }\n // legacy write(string, encoding, offset, length) - remove in v0.13\n } else {\n throw new Error(\n 'Buffer.write(string, encoding, offset[, length]) is no longer supported'\n )\n }\n\n var remaining = this.length - offset\n if (length === undefined || length > remaining) length = remaining\n\n if ((string.length > 0 && (length < 0 || offset < 0)) || offset > this.length) {\n throw new RangeError('Attempt to write outside buffer bounds')\n }\n\n if (!encoding) encoding = 'utf8'\n\n var loweredCase = false\n for (;;) {\n switch (encoding) {\n case 'hex':\n return hexWrite(this, string, offset, length)\n\n case 'utf8':\n case 'utf-8':\n return utf8Write(this, string, offset, length)\n\n case 'ascii':\n return asciiWrite(this, string, offset, length)\n\n case 'latin1':\n case 'binary':\n return latin1Write(this, string, offset, length)\n\n case 'base64':\n // Warning: maxLength not taken into account in base64Write\n return base64Write(this, string, offset, length)\n\n case 'ucs2':\n case 'ucs-2':\n case 'utf16le':\n case 'utf-16le':\n return ucs2Write(this, string, offset, length)\n\n default:\n if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)\n encoding = ('' + encoding).toLowerCase()\n loweredCase = true\n }\n }\n}\n\nBuffer.prototype.toJSON = function toJSON () {\n return {\n type: 'Buffer',\n data: Array.prototype.slice.call(this._arr || this, 0)\n }\n}\n\nfunction base64Slice (buf, start, end) {\n if (start === 0 && end === buf.length) {\n return base64.fromByteArray(buf)\n } else {\n return base64.fromByteArray(buf.slice(start, end))\n }\n}\n\nfunction utf8Slice (buf, start, end) {\n end = Math.min(buf.length, end)\n var res = []\n\n var i = start\n while (i < end) {\n var firstByte = buf[i]\n var codePoint = null\n var bytesPerSequence = (firstByte > 0xEF) ? 4\n : (firstByte > 0xDF) ? 3\n : (firstByte > 0xBF) ? 2\n : 1\n\n if (i + bytesPerSequence <= end) {\n var secondByte, thirdByte, fourthByte, tempCodePoint\n\n switch (bytesPerSequence) {\n case 1:\n if (firstByte < 0x80) {\n codePoint = firstByte\n }\n break\n case 2:\n secondByte = buf[i + 1]\n if ((secondByte & 0xC0) === 0x80) {\n tempCodePoint = (firstByte & 0x1F) << 0x6 | (secondByte & 0x3F)\n if (tempCodePoint > 0x7F) {\n codePoint = tempCodePoint\n }\n }\n break\n case 3:\n secondByte = buf[i + 1]\n thirdByte = buf[i + 2]\n if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80) {\n tempCodePoint = (firstByte & 0xF) << 0xC | (secondByte & 0x3F) << 0x6 | (thirdByte & 0x3F)\n if (tempCodePoint > 0x7FF && (tempCodePoint < 0xD800 || tempCodePoint > 0xDFFF)) {\n codePoint = tempCodePoint\n }\n }\n break\n case 4:\n secondByte = buf[i + 1]\n thirdByte = buf[i + 2]\n fourthByte = buf[i + 3]\n if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80 && (fourthByte & 0xC0) === 0x80) {\n tempCodePoint = (firstByte & 0xF) << 0x12 | (secondByte & 0x3F) << 0xC | (thirdByte & 0x3F) << 0x6 | (fourthByte & 0x3F)\n if (tempCodePoint > 0xFFFF && tempCodePoint < 0x110000) {\n codePoint = tempCodePoint\n }\n }\n }\n }\n\n if (codePoint === null) {\n // we did not generate a valid codePoint so insert a\n // replacement char (U+FFFD) and advance only 1 byte\n codePoint = 0xFFFD\n bytesPerSequence = 1\n } else if (codePoint > 0xFFFF) {\n // encode to utf16 (surrogate pair dance)\n codePoint -= 0x10000\n res.push(codePoint >>> 10 & 0x3FF | 0xD800)\n codePoint = 0xDC00 | codePoint & 0x3FF\n }\n\n res.push(codePoint)\n i += bytesPerSequence\n }\n\n return decodeCodePointsArray(res)\n}\n\n// Based on http://stackoverflow.com/a/22747272/680742, the browser with\n// the lowest limit is Chrome, with 0x10000 args.\n// We go 1 magnitude less, for safety\nvar MAX_ARGUMENTS_LENGTH = 0x1000\n\nfunction decodeCodePointsArray (codePoints) {\n var len = codePoints.length\n if (len <= MAX_ARGUMENTS_LENGTH) {\n return String.fromCharCode.apply(String, codePoints) // avoid extra slice()\n }\n\n // Decode in chunks to avoid \"call stack size exceeded\".\n var res = ''\n var i = 0\n while (i < len) {\n res += String.fromCharCode.apply(\n String,\n codePoints.slice(i, i += MAX_ARGUMENTS_LENGTH)\n )\n }\n return res\n}\n\nfunction asciiSlice (buf, start, end) {\n var ret = ''\n end = Math.min(buf.length, end)\n\n for (var i = start; i < end; ++i) {\n ret += String.fromCharCode(buf[i] & 0x7F)\n }\n return ret\n}\n\nfunction latin1Slice (buf, start, end) {\n var ret = ''\n end = Math.min(buf.length, end)\n\n for (var i = start; i < end; ++i) {\n ret += String.fromCharCode(buf[i])\n }\n return ret\n}\n\nfunction hexSlice (buf, start, end) {\n var len = buf.length\n\n if (!start || start < 0) start = 0\n if (!end || end < 0 || end > len) end = len\n\n var out = ''\n for (var i = start; i < end; ++i) {\n out += toHex(buf[i])\n }\n return out\n}\n\nfunction utf16leSlice (buf, start, end) {\n var bytes = buf.slice(start, end)\n var res = ''\n for (var i = 0; i < bytes.length; i += 2) {\n res += String.fromCharCode(bytes[i] + bytes[i + 1] * 256)\n }\n return res\n}\n\nBuffer.prototype.slice = function slice (start, end) {\n var len = this.length\n start = ~~start\n end = end === undefined ? len : ~~end\n\n if (start < 0) {\n start += len\n if (start < 0) start = 0\n } else if (start > len) {\n start = len\n }\n\n if (end < 0) {\n end += len\n if (end < 0) end = 0\n } else if (end > len) {\n end = len\n }\n\n if (end < start) end = start\n\n var newBuf\n if (Buffer.TYPED_ARRAY_SUPPORT) {\n newBuf = this.subarray(start, end)\n newBuf.__proto__ = Buffer.prototype\n } else {\n var sliceLen = end - start\n newBuf = new Buffer(sliceLen, undefined)\n for (var i = 0; i < sliceLen; ++i) {\n newBuf[i] = this[i + start]\n }\n }\n\n return newBuf\n}\n\n/*\n * Need to make sure that buffer isn't trying to write out of bounds.\n */\nfunction checkOffset (offset, ext, length) {\n if ((offset % 1) !== 0 || offset < 0) throw new RangeError('offset is not uint')\n if (offset + ext > length) throw new RangeError('Trying to access beyond buffer length')\n}\n\nBuffer.prototype.readUIntLE = function readUIntLE (offset, byteLength, noAssert) {\n offset = offset | 0\n byteLength = byteLength | 0\n if (!noAssert) checkOffset(offset, byteLength, this.length)\n\n var val = this[offset]\n var mul = 1\n var i = 0\n while (++i < byteLength && (mul *= 0x100)) {\n val += this[offset + i] * mul\n }\n\n return val\n}\n\nBuffer.prototype.readUIntBE = function readUIntBE (offset, byteLength, noAssert) {\n offset = offset | 0\n byteLength = byteLength | 0\n if (!noAssert) {\n checkOffset(offset, byteLength, this.length)\n }\n\n var val = this[offset + --byteLength]\n var mul = 1\n while (byteLength > 0 && (mul *= 0x100)) {\n val += this[offset + --byteLength] * mul\n }\n\n return val\n}\n\nBuffer.prototype.readUInt8 = function readUInt8 (offset, noAssert) {\n if (!noAssert) checkOffset(offset, 1, this.length)\n return this[offset]\n}\n\nBuffer.prototype.readUInt16LE = function readUInt16LE (offset, noAssert) {\n if (!noAssert) checkOffset(offset, 2, this.length)\n return this[offset] | (this[offset + 1] << 8)\n}\n\nBuffer.prototype.readUInt16BE = function readUInt16BE (offset, noAssert) {\n if (!noAssert) checkOffset(offset, 2, this.length)\n return (this[offset] << 8) | this[offset + 1]\n}\n\nBuffer.prototype.readUInt32LE = function readUInt32LE (offset, noAssert) {\n if (!noAssert) checkOffset(offset, 4, this.length)\n\n return ((this[offset]) |\n (this[offset + 1] << 8) |\n (this[offset + 2] << 16)) +\n (this[offset + 3] * 0x1000000)\n}\n\nBuffer.prototype.readUInt32BE = function readUInt32BE (offset, noAssert) {\n if (!noAssert) checkOffset(offset, 4, this.length)\n\n return (this[offset] * 0x1000000) +\n ((this[offset + 1] << 16) |\n (this[offset + 2] << 8) |\n this[offset + 3])\n}\n\nBuffer.prototype.readIntLE = function readIntLE (offset, byteLength, noAssert) {\n offset = offset | 0\n byteLength = byteLength | 0\n if (!noAssert) checkOffset(offset, byteLength, this.length)\n\n var val = this[offset]\n var mul = 1\n var i = 0\n while (++i < byteLength && (mul *= 0x100)) {\n val += this[offset + i] * mul\n }\n mul *= 0x80\n\n if (val >= mul) val -= Math.pow(2, 8 * byteLength)\n\n return val\n}\n\nBuffer.prototype.readIntBE = function readIntBE (offset, byteLength, noAssert) {\n offset = offset | 0\n byteLength = byteLength | 0\n if (!noAssert) checkOffset(offset, byteLength, this.length)\n\n var i = byteLength\n var mul = 1\n var val = this[offset + --i]\n while (i > 0 && (mul *= 0x100)) {\n val += this[offset + --i] * mul\n }\n mul *= 0x80\n\n if (val >= mul) val -= Math.pow(2, 8 * byteLength)\n\n return val\n}\n\nBuffer.prototype.readInt8 = function readInt8 (offset, noAssert) {\n if (!noAssert) checkOffset(offset, 1, this.length)\n if (!(this[offset] & 0x80)) return (this[offset])\n return ((0xff - this[offset] + 1) * -1)\n}\n\nBuffer.prototype.readInt16LE = function readInt16LE (offset, noAssert) {\n if (!noAssert) checkOffset(offset, 2, this.length)\n var val = this[offset] | (this[offset + 1] << 8)\n return (val & 0x8000) ? val | 0xFFFF0000 : val\n}\n\nBuffer.prototype.readInt16BE = function readInt16BE (offset, noAssert) {\n if (!noAssert) checkOffset(offset, 2, this.length)\n var val = this[offset + 1] | (this[offset] << 8)\n return (val & 0x8000) ? val | 0xFFFF0000 : val\n}\n\nBuffer.prototype.readInt32LE = function readInt32LE (offset, noAssert) {\n if (!noAssert) checkOffset(offset, 4, this.length)\n\n return (this[offset]) |\n (this[offset + 1] << 8) |\n (this[offset + 2] << 16) |\n (this[offset + 3] << 24)\n}\n\nBuffer.prototype.readInt32BE = function readInt32BE (offset, noAssert) {\n if (!noAssert) checkOffset(offset, 4, this.length)\n\n return (this[offset] << 24) |\n (this[offset + 1] << 16) |\n (this[offset + 2] << 8) |\n (this[offset + 3])\n}\n\nBuffer.prototype.readFloatLE = function readFloatLE (offset, noAssert) {\n if (!noAssert) checkOffset(offset, 4, this.length)\n return ieee754.read(this, offset, true, 23, 4)\n}\n\nBuffer.prototype.readFloatBE = function readFloatBE (offset, noAssert) {\n if (!noAssert) checkOffset(offset, 4, this.length)\n return ieee754.read(this, offset, false, 23, 4)\n}\n\nBuffer.prototype.readDoubleLE = function readDoubleLE (offset, noAssert) {\n if (!noAssert) checkOffset(offset, 8, this.length)\n return ieee754.read(this, offset, true, 52, 8)\n}\n\nBuffer.prototype.readDoubleBE = function readDoubleBE (offset, noAssert) {\n if (!noAssert) checkOffset(offset, 8, this.length)\n return ieee754.read(this, offset, false, 52, 8)\n}\n\nfunction checkInt (buf, value, offset, ext, max, min) {\n if (!Buffer.isBuffer(buf)) throw new TypeError('\"buffer\" argument must be a Buffer instance')\n if (value > max || value < min) throw new RangeError('\"value\" argument is out of bounds')\n if (offset + ext > buf.length) throw new RangeError('Index out of range')\n}\n\nBuffer.prototype.writeUIntLE = function writeUIntLE (value, offset, byteLength, noAssert) {\n value = +value\n offset = offset | 0\n byteLength = byteLength | 0\n if (!noAssert) {\n var maxBytes = Math.pow(2, 8 * byteLength) - 1\n checkInt(this, value, offset, byteLength, maxBytes, 0)\n }\n\n var mul = 1\n var i = 0\n this[offset] = value & 0xFF\n while (++i < byteLength && (mul *= 0x100)) {\n this[offset + i] = (value / mul) & 0xFF\n }\n\n return offset + byteLength\n}\n\nBuffer.prototype.writeUIntBE = function writeUIntBE (value, offset, byteLength, noAssert) {\n value = +value\n offset = offset | 0\n byteLength = byteLength | 0\n if (!noAssert) {\n var maxBytes = Math.pow(2, 8 * byteLength) - 1\n checkInt(this, value, offset, byteLength, maxBytes, 0)\n }\n\n var i = byteLength - 1\n var mul = 1\n this[offset + i] = value & 0xFF\n while (--i >= 0 && (mul *= 0x100)) {\n this[offset + i] = (value / mul) & 0xFF\n }\n\n return offset + byteLength\n}\n\nBuffer.prototype.writeUInt8 = function writeUInt8 (value, offset, noAssert) {\n value = +value\n offset = offset | 0\n if (!noAssert) checkInt(this, value, offset, 1, 0xff, 0)\n if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value)\n this[offset] = (value & 0xff)\n return offset + 1\n}\n\nfunction objectWriteUInt16 (buf, value, offset, littleEndian) {\n if (value < 0) value = 0xffff + value + 1\n for (var i = 0, j = Math.min(buf.length - offset, 2); i < j; ++i) {\n buf[offset + i] = (value & (0xff << (8 * (littleEndian ? i : 1 - i)))) >>>\n (littleEndian ? i : 1 - i) * 8\n }\n}\n\nBuffer.prototype.writeUInt16LE = function writeUInt16LE (value, offset, noAssert) {\n value = +value\n offset = offset | 0\n if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)\n if (Buffer.TYPED_ARRAY_SUPPORT) {\n this[offset] = (value & 0xff)\n this[offset + 1] = (value >>> 8)\n } else {\n objectWriteUInt16(this, value, offset, true)\n }\n return offset + 2\n}\n\nBuffer.prototype.writeUInt16BE = function writeUInt16BE (value, offset, noAssert) {\n value = +value\n offset = offset | 0\n if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)\n if (Buffer.TYPED_ARRAY_SUPPORT) {\n this[offset] = (value >>> 8)\n this[offset + 1] = (value & 0xff)\n } else {\n objectWriteUInt16(this, value, offset, false)\n }\n return offset + 2\n}\n\nfunction objectWriteUInt32 (buf, value, offset, littleEndian) {\n if (value < 0) value = 0xffffffff + value + 1\n for (var i = 0, j = Math.min(buf.length - offset, 4); i < j; ++i) {\n buf[offset + i] = (value >>> (littleEndian ? i : 3 - i) * 8) & 0xff\n }\n}\n\nBuffer.prototype.writeUInt32LE = function writeUInt32LE (value, offset, noAssert) {\n value = +value\n offset = offset | 0\n if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)\n if (Buffer.TYPED_ARRAY_SUPPORT) {\n this[offset + 3] = (value >>> 24)\n this[offset + 2] = (value >>> 16)\n this[offset + 1] = (value >>> 8)\n this[offset] = (value & 0xff)\n } else {\n objectWriteUInt32(this, value, offset, true)\n }\n return offset + 4\n}\n\nBuffer.prototype.writeUInt32BE = function writeUInt32BE (value, offset, noAssert) {\n value = +value\n offset = offset | 0\n if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)\n if (Buffer.TYPED_ARRAY_SUPPORT) {\n this[offset] = (value >>> 24)\n this[offset + 1] = (value >>> 16)\n this[offset + 2] = (value >>> 8)\n this[offset + 3] = (value & 0xff)\n } else {\n objectWriteUInt32(this, value, offset, false)\n }\n return offset + 4\n}\n\nBuffer.prototype.writeIntLE = function writeIntLE (value, offset, byteLength, noAssert) {\n value = +value\n offset = offset | 0\n if (!noAssert) {\n var limit = Math.pow(2, 8 * byteLength - 1)\n\n checkInt(this, value, offset, byteLength, limit - 1, -limit)\n }\n\n var i = 0\n var mul = 1\n var sub = 0\n this[offset] = value & 0xFF\n while (++i < byteLength && (mul *= 0x100)) {\n if (value < 0 && sub === 0 && this[offset + i - 1] !== 0) {\n sub = 1\n }\n this[offset + i] = ((value / mul) >> 0) - sub & 0xFF\n }\n\n return offset + byteLength\n}\n\nBuffer.prototype.writeIntBE = function writeIntBE (value, offset, byteLength, noAssert) {\n value = +value\n offset = offset | 0\n if (!noAssert) {\n var limit = Math.pow(2, 8 * byteLength - 1)\n\n checkInt(this, value, offset, byteLength, limit - 1, -limit)\n }\n\n var i = byteLength - 1\n var mul = 1\n var sub = 0\n this[offset + i] = value & 0xFF\n while (--i >= 0 && (mul *= 0x100)) {\n if (value < 0 && sub === 0 && this[offset + i + 1] !== 0) {\n sub = 1\n }\n this[offset + i] = ((value / mul) >> 0) - sub & 0xFF\n }\n\n return offset + byteLength\n}\n\nBuffer.prototype.writeInt8 = function writeInt8 (value, offset, noAssert) {\n value = +value\n offset = offset | 0\n if (!noAssert) checkInt(this, value, offset, 1, 0x7f, -0x80)\n if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value)\n if (value < 0) value = 0xff + value + 1\n this[offset] = (value & 0xff)\n return offset + 1\n}\n\nBuffer.prototype.writeInt16LE = function writeInt16LE (value, offset, noAssert) {\n value = +value\n offset = offset | 0\n if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000)\n if (Buffer.TYPED_ARRAY_SUPPORT) {\n this[offset] = (value & 0xff)\n this[offset + 1] = (value >>> 8)\n } else {\n objectWriteUInt16(this, value, offset, true)\n }\n return offset + 2\n}\n\nBuffer.prototype.writeInt16BE = function writeInt16BE (value, offset, noAssert) {\n value = +value\n offset = offset | 0\n if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000)\n if (Buffer.TYPED_ARRAY_SUPPORT) {\n this[offset] = (value >>> 8)\n this[offset + 1] = (value & 0xff)\n } else {\n objectWriteUInt16(this, value, offset, false)\n }\n return offset + 2\n}\n\nBuffer.prototype.writeInt32LE = function writeInt32LE (value, offset, noAssert) {\n value = +value\n offset = offset | 0\n if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)\n if (Buffer.TYPED_ARRAY_SUPPORT) {\n this[offset] = (value & 0xff)\n this[offset + 1] = (value >>> 8)\n this[offset + 2] = (value >>> 16)\n this[offset + 3] = (value >>> 24)\n } else {\n objectWriteUInt32(this, value, offset, true)\n }\n return offset + 4\n}\n\nBuffer.prototype.writeInt32BE = function writeInt32BE (value, offset, noAssert) {\n value = +value\n offset = offset | 0\n if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)\n if (value < 0) value = 0xffffffff + value + 1\n if (Buffer.TYPED_ARRAY_SUPPORT) {\n this[offset] = (value >>> 24)\n this[offset + 1] = (value >>> 16)\n this[offset + 2] = (value >>> 8)\n this[offset + 3] = (value & 0xff)\n } else {\n objectWriteUInt32(this, value, offset, false)\n }\n return offset + 4\n}\n\nfunction checkIEEE754 (buf, value, offset, ext, max, min) {\n if (offset + ext > buf.length) throw new RangeError('Index out of range')\n if (offset < 0) throw new RangeError('Index out of range')\n}\n\nfunction writeFloat (buf, value, offset, littleEndian, noAssert) {\n if (!noAssert) {\n checkIEEE754(buf, value, offset, 4, 3.4028234663852886e+38, -3.4028234663852886e+38)\n }\n ieee754.write(buf, value, offset, littleEndian, 23, 4)\n return offset + 4\n}\n\nBuffer.prototype.writeFloatLE = function writeFloatLE (value, offset, noAssert) {\n return writeFloat(this, value, offset, true, noAssert)\n}\n\nBuffer.prototype.writeFloatBE = function writeFloatBE (value, offset, noAssert) {\n return writeFloat(this, value, offset, false, noAssert)\n}\n\nfunction writeDouble (buf, value, offset, littleEndian, noAssert) {\n if (!noAssert) {\n checkIEEE754(buf, value, offset, 8, 1.7976931348623157E+308, -1.7976931348623157E+308)\n }\n ieee754.write(buf, value, offset, littleEndian, 52, 8)\n return offset + 8\n}\n\nBuffer.prototype.writeDoubleLE = function writeDoubleLE (value, offset, noAssert) {\n return writeDouble(this, value, offset, true, noAssert)\n}\n\nBuffer.prototype.writeDoubleBE = function writeDoubleBE (value, offset, noAssert) {\n return writeDouble(this, value, offset, false, noAssert)\n}\n\n// copy(targetBuffer, targetStart=0, sourceStart=0, sourceEnd=buffer.length)\nBuffer.prototype.copy = function copy (target, targetStart, start, end) {\n if (!start) start = 0\n if (!end && end !== 0) end = this.length\n if (targetStart >= target.length) targetStart = target.length\n if (!targetStart) targetStart = 0\n if (end > 0 && end < start) end = start\n\n // Copy 0 bytes; we're done\n if (end === start) return 0\n if (target.length === 0 || this.length === 0) return 0\n\n // Fatal error conditions\n if (targetStart < 0) {\n throw new RangeError('targetStart out of bounds')\n }\n if (start < 0 || start >= this.length) throw new RangeError('sourceStart out of bounds')\n if (end < 0) throw new RangeError('sourceEnd out of bounds')\n\n // Are we oob?\n if (end > this.length) end = this.length\n if (target.length - targetStart < end - start) {\n end = target.length - targetStart + start\n }\n\n var len = end - start\n var i\n\n if (this === target && start < targetStart && targetStart < end) {\n // descending copy from end\n for (i = len - 1; i >= 0; --i) {\n target[i + targetStart] = this[i + start]\n }\n } else if (len < 1000 || !Buffer.TYPED_ARRAY_SUPPORT) {\n // ascending copy from start\n for (i = 0; i < len; ++i) {\n target[i + targetStart] = this[i + start]\n }\n } else {\n Uint8Array.prototype.set.call(\n target,\n this.subarray(start, start + len),\n targetStart\n )\n }\n\n return len\n}\n\n// Usage:\n// buffer.fill(number[, offset[, end]])\n// buffer.fill(buffer[, offset[, end]])\n// buffer.fill(string[, offset[, end]][, encoding])\nBuffer.prototype.fill = function fill (val, start, end, encoding) {\n // Handle string cases:\n if (typeof val === 'string') {\n if (typeof start === 'string') {\n encoding = start\n start = 0\n end = this.length\n } else if (typeof end === 'string') {\n encoding = end\n end = this.length\n }\n if (val.length === 1) {\n var code = val.charCodeAt(0)\n if (code < 256) {\n val = code\n }\n }\n if (encoding !== undefined && typeof encoding !== 'string') {\n throw new TypeError('encoding must be a string')\n }\n if (typeof encoding === 'string' && !Buffer.isEncoding(encoding)) {\n throw new TypeError('Unknown encoding: ' + encoding)\n }\n } else if (typeof val === 'number') {\n val = val & 255\n }\n\n // Invalid ranges are not set to a default, so can range check early.\n if (start < 0 || this.length < start || this.length < end) {\n throw new RangeError('Out of range index')\n }\n\n if (end <= start) {\n return this\n }\n\n start = start >>> 0\n end = end === undefined ? this.length : end >>> 0\n\n if (!val) val = 0\n\n var i\n if (typeof val === 'number') {\n for (i = start; i < end; ++i) {\n this[i] = val\n }\n } else {\n var bytes = Buffer.isBuffer(val)\n ? val\n : utf8ToBytes(new Buffer(val, encoding).toString())\n var len = bytes.length\n for (i = 0; i < end - start; ++i) {\n this[i + start] = bytes[i % len]\n }\n }\n\n return this\n}\n\n// HELPER FUNCTIONS\n// ================\n\nvar INVALID_BASE64_RE = /[^+\\/0-9A-Za-z-_]/g\n\nfunction base64clean (str) {\n // Node strips out invalid characters like \\n and \\t from the string, base64-js does not\n str = stringtrim(str).replace(INVALID_BASE64_RE, '')\n // Node converts strings with length < 2 to ''\n if (str.length < 2) return ''\n // Node allows for non-padded base64 strings (missing trailing ===), base64-js does not\n while (str.length % 4 !== 0) {\n str = str + '='\n }\n return str\n}\n\nfunction stringtrim (str) {\n if (str.trim) return str.trim()\n return str.replace(/^\\s+|\\s+$/g, '')\n}\n\nfunction toHex (n) {\n if (n < 16) return '0' + n.toString(16)\n return n.toString(16)\n}\n\nfunction utf8ToBytes (string, units) {\n units = units || Infinity\n var codePoint\n var length = string.length\n var leadSurrogate = null\n var bytes = []\n\n for (var i = 0; i < length; ++i) {\n codePoint = string.charCodeAt(i)\n\n // is surrogate component\n if (codePoint > 0xD7FF && codePoint < 0xE000) {\n // last char was a lead\n if (!leadSurrogate) {\n // no lead yet\n if (codePoint > 0xDBFF) {\n // unexpected trail\n if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n continue\n } else if (i + 1 === length) {\n // unpaired lead\n if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n continue\n }\n\n // valid lead\n leadSurrogate = codePoint\n\n continue\n }\n\n // 2 leads in a row\n if (codePoint < 0xDC00) {\n if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n leadSurrogate = codePoint\n continue\n }\n\n // valid surrogate pair\n codePoint = (leadSurrogate - 0xD800 << 10 | codePoint - 0xDC00) + 0x10000\n } else if (leadSurrogate) {\n // valid bmp char, but last char was a lead\n if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n }\n\n leadSurrogate = null\n\n // encode utf8\n if (codePoint < 0x80) {\n if ((units -= 1) < 0) break\n bytes.push(codePoint)\n } else if (codePoint < 0x800) {\n if ((units -= 2) < 0) break\n bytes.push(\n codePoint >> 0x6 | 0xC0,\n codePoint & 0x3F | 0x80\n )\n } else if (codePoint < 0x10000) {\n if ((units -= 3) < 0) break\n bytes.push(\n codePoint >> 0xC | 0xE0,\n codePoint >> 0x6 & 0x3F | 0x80,\n codePoint & 0x3F | 0x80\n )\n } else if (codePoint < 0x110000) {\n if ((units -= 4) < 0) break\n bytes.push(\n codePoint >> 0x12 | 0xF0,\n codePoint >> 0xC & 0x3F | 0x80,\n codePoint >> 0x6 & 0x3F | 0x80,\n codePoint & 0x3F | 0x80\n )\n } else {\n throw new Error('Invalid code point')\n }\n }\n\n return bytes\n}\n\nfunction asciiToBytes (str) {\n var byteArray = []\n for (var i = 0; i < str.length; ++i) {\n // Node's code seems to be doing this and not & 0x7F..\n byteArray.push(str.charCodeAt(i) & 0xFF)\n }\n return byteArray\n}\n\nfunction utf16leToBytes (str, units) {\n var c, hi, lo\n var byteArray = []\n for (var i = 0; i < str.length; ++i) {\n if ((units -= 2) < 0) break\n\n c = str.charCodeAt(i)\n hi = c >> 8\n lo = c % 256\n byteArray.push(lo)\n byteArray.push(hi)\n }\n\n return byteArray\n}\n\nfunction base64ToBytes (str) {\n return base64.toByteArray(base64clean(str))\n}\n\nfunction blitBuffer (src, dst, offset, length) {\n for (var i = 0; i < length; ++i) {\n if ((i + offset >= dst.length) || (i >= src.length)) break\n dst[i + offset] = src[i]\n }\n return i\n}\n\nfunction isnan (val) {\n return val !== val // eslint-disable-line no-self-compare\n}\n","/**\n * This is the web browser implementation of `debug()`.\n *\n * Expose `debug()` as the module.\n */\n\nexports = module.exports = require('./debug');\nexports.log = log;\nexports.formatArgs = formatArgs;\nexports.save = save;\nexports.load = load;\nexports.useColors = useColors;\nexports.storage = 'undefined' != typeof chrome\n && 'undefined' != typeof chrome.storage\n ? chrome.storage.local\n : localstorage();\n\n/**\n * Colors.\n */\n\nexports.colors = [\n 'lightseagreen',\n 'forestgreen',\n 'goldenrod',\n 'dodgerblue',\n 'darkorchid',\n 'crimson'\n];\n\n/**\n * Currently only WebKit-based Web Inspectors, Firefox >= v31,\n * and the Firebug extension (any Firefox version) are known\n * to support \"%c\" CSS customizations.\n *\n * TODO: add a `localStorage` variable to explicitly enable/disable colors\n */\n\nfunction useColors() {\n // NB: In an Electron preload script, document will be defined but not fully\n // initialized. Since we know we're in Chrome, we'll just detect this case\n // explicitly\n if (typeof window !== 'undefined' && window && typeof window.process !== 'undefined' && window.process.type === 'renderer') {\n return true;\n }\n\n // is webkit? http://stackoverflow.com/a/16459606/376773\n // document is undefined in react-native: https://github.com/facebook/react-native/pull/1632\n return (typeof document !== 'undefined' && document && 'WebkitAppearance' in document.documentElement.style) ||\n // is firebug? http://stackoverflow.com/a/398120/376773\n (typeof window !== 'undefined' && window && window.console && (console.firebug || (console.exception && console.table))) ||\n // is firefox >= v31?\n // https://developer.mozilla.org/en-US/docs/Tools/Web_Console#Styling_messages\n (typeof navigator !== 'undefined' && navigator && navigator.userAgent && navigator.userAgent.toLowerCase().match(/firefox\\/(\\d+)/) && parseInt(RegExp.$1, 10) >= 31) ||\n // double check webkit in userAgent just in case we are in a worker\n (typeof navigator !== 'undefined' && navigator && navigator.userAgent && navigator.userAgent.toLowerCase().match(/applewebkit\\/(\\d+)/));\n}\n\n/**\n * Map %j to `JSON.stringify()`, since no Web Inspectors do that by default.\n */\n\nexports.formatters.j = function(v) {\n try {\n return JSON.stringify(v);\n } catch (err) {\n return '[UnexpectedJSONParseError]: ' + err.message;\n }\n};\n\n\n/**\n * Colorize log arguments if enabled.\n *\n * @api public\n */\n\nfunction formatArgs(args) {\n var useColors = this.useColors;\n\n args[0] = (useColors ? '%c' : '')\n + this.namespace\n + (useColors ? ' %c' : ' ')\n + args[0]\n + (useColors ? '%c ' : ' ')\n + '+' + exports.humanize(this.diff);\n\n if (!useColors) return;\n\n var c = 'color: ' + this.color;\n args.splice(1, 0, c, 'color: inherit')\n\n // the final \"%c\" is somewhat tricky, because there could be other\n // arguments passed either before or after the %c, so we need to\n // figure out the correct index to insert the CSS into\n var index = 0;\n var lastC = 0;\n args[0].replace(/%[a-zA-Z%]/g, function(match) {\n if ('%%' === match) return;\n index++;\n if ('%c' === match) {\n // we only are interested in the *last* %c\n // (the user may have provided their own)\n lastC = index;\n }\n });\n\n args.splice(lastC, 0, c);\n}\n\n/**\n * Invokes `console.log()` when available.\n * No-op when `console.log` is not a \"function\".\n *\n * @api public\n */\n\nfunction log() {\n // this hackery is required for IE8/9, where\n // the `console.log` function doesn't have 'apply'\n return 'object' === typeof console\n && console.log\n && Function.prototype.apply.call(console.log, console, arguments);\n}\n\n/**\n * Save `namespaces`.\n *\n * @param {String} namespaces\n * @api private\n */\n\nfunction save(namespaces) {\n try {\n if (null == namespaces) {\n exports.storage.removeItem('debug');\n } else {\n exports.storage.debug = namespaces;\n }\n } catch(e) {}\n}\n\n/**\n * Load `namespaces`.\n *\n * @return {String} returns the previously persisted debug modes\n * @api private\n */\n\nfunction load() {\n try {\n return exports.storage.debug;\n } catch(e) {}\n\n // If debug isn't set in LS, and we're in Electron, try to load $DEBUG\n if (typeof process !== 'undefined' && 'env' in process) {\n return process.env.DEBUG;\n }\n}\n\n/**\n * Enable namespaces listed in `localStorage.debug` initially.\n */\n\nexports.enable(load());\n\n/**\n * Localstorage attempts to return the localstorage.\n *\n * This is necessary because safari throws\n * when a user disables cookies/localstorage\n * and you attempt to access it.\n *\n * @return {LocalStorage}\n * @api private\n */\n\nfunction localstorage() {\n try {\n return window.localStorage;\n } catch (e) {}\n}\n","\n/**\n * This is the common logic for both the Node.js and web browser\n * implementations of `debug()`.\n *\n * Expose `debug()` as the module.\n */\n\nexports = module.exports = createDebug.debug = createDebug.default = createDebug;\nexports.coerce = coerce;\nexports.disable = disable;\nexports.enable = enable;\nexports.enabled = enabled;\nexports.humanize = require('ms');\n\n/**\n * The currently active debug mode names, and names to skip.\n */\n\nexports.names = [];\nexports.skips = [];\n\n/**\n * Map of special \"%n\" handling functions, for the debug \"format\" argument.\n *\n * Valid key names are a single, lower or upper-case letter, i.e. \"n\" and \"N\".\n */\n\nexports.formatters = {};\n\n/**\n * Previous log timestamp.\n */\n\nvar prevTime;\n\n/**\n * Select a color.\n * @param {String} namespace\n * @return {Number}\n * @api private\n */\n\nfunction selectColor(namespace) {\n var hash = 0, i;\n\n for (i in namespace) {\n hash = ((hash << 5) - hash) + namespace.charCodeAt(i);\n hash |= 0; // Convert to 32bit integer\n }\n\n return exports.colors[Math.abs(hash) % exports.colors.length];\n}\n\n/**\n * Create a debugger with the given `namespace`.\n *\n * @param {String} namespace\n * @return {Function}\n * @api public\n */\n\nfunction createDebug(namespace) {\n\n function debug() {\n // disabled?\n if (!debug.enabled) return;\n\n var self = debug;\n\n // set `diff` timestamp\n var curr = +new Date();\n var ms = curr - (prevTime || curr);\n self.diff = ms;\n self.prev = prevTime;\n self.curr = curr;\n prevTime = curr;\n\n // turn the `arguments` into a proper Array\n var args = new Array(arguments.length);\n for (var i = 0; i < args.length; i++) {\n args[i] = arguments[i];\n }\n\n args[0] = exports.coerce(args[0]);\n\n if ('string' !== typeof args[0]) {\n // anything else let's inspect with %O\n args.unshift('%O');\n }\n\n // apply any `formatters` transformations\n var index = 0;\n args[0] = args[0].replace(/%([a-zA-Z%])/g, function(match, format) {\n // if we encounter an escaped % then don't increase the array index\n if (match === '%%') return match;\n index++;\n var formatter = exports.formatters[format];\n if ('function' === typeof formatter) {\n var val = args[index];\n match = formatter.call(self, val);\n\n // now we need to remove `args[index]` since it's inlined in the `format`\n args.splice(index, 1);\n index--;\n }\n return match;\n });\n\n // apply env-specific formatting (colors, etc.)\n exports.formatArgs.call(self, args);\n\n var logFn = debug.log || exports.log || console.log.bind(console);\n logFn.apply(self, args);\n }\n\n debug.namespace = namespace;\n debug.enabled = exports.enabled(namespace);\n debug.useColors = exports.useColors();\n debug.color = selectColor(namespace);\n\n // env-specific initialization logic for debug instances\n if ('function' === typeof exports.init) {\n exports.init(debug);\n }\n\n return debug;\n}\n\n/**\n * Enables a debug mode by namespaces. This can include modes\n * separated by a colon and wildcards.\n *\n * @param {String} namespaces\n * @api public\n */\n\nfunction enable(namespaces) {\n exports.save(namespaces);\n\n var split = (namespaces || '').split(/[\\s,]+/);\n var len = split.length;\n\n for (var i = 0; i < len; i++) {\n if (!split[i]) continue; // ignore empty strings\n namespaces = split[i].replace(/\\*/g, '.*?');\n if (namespaces[0] === '-') {\n exports.skips.push(new RegExp('^' + namespaces.substr(1) + '$'));\n } else {\n exports.names.push(new RegExp('^' + namespaces + '$'));\n }\n }\n}\n\n/**\n * Disable debug output.\n *\n * @api public\n */\n\nfunction disable() {\n exports.enable('');\n}\n\n/**\n * Returns true if the given mode name is enabled, false otherwise.\n *\n * @param {String} name\n * @return {Boolean}\n * @api public\n */\n\nfunction enabled(name) {\n var i, len;\n for (i = 0, len = exports.skips.length; i < len; i++) {\n if (exports.skips[i].test(name)) {\n return false;\n }\n }\n for (i = 0, len = exports.names.length; i < len; i++) {\n if (exports.names[i].test(name)) {\n return true;\n }\n }\n return false;\n}\n\n/**\n * Coerce `val`.\n *\n * @param {Mixed} val\n * @return {Mixed}\n * @api private\n */\n\nfunction coerce(val) {\n if (val instanceof Error) return val.stack || val.message;\n return val;\n}\n","exports.read = function (buffer, offset, isLE, mLen, nBytes) {\n var e, m\n var eLen = nBytes * 8 - mLen - 1\n var eMax = (1 << eLen) - 1\n var eBias = eMax >> 1\n var nBits = -7\n var i = isLE ? (nBytes - 1) : 0\n var d = isLE ? -1 : 1\n var s = buffer[offset + i]\n\n i += d\n\n e = s & ((1 << (-nBits)) - 1)\n s >>= (-nBits)\n nBits += eLen\n for (; nBits > 0; e = e * 256 + buffer[offset + i], i += d, nBits -= 8) {}\n\n m = e & ((1 << (-nBits)) - 1)\n e >>= (-nBits)\n nBits += mLen\n for (; nBits > 0; m = m * 256 + buffer[offset + i], i += d, nBits -= 8) {}\n\n if (e === 0) {\n e = 1 - eBias\n } else if (e === eMax) {\n return m ? NaN : ((s ? -1 : 1) * Infinity)\n } else {\n m = m + Math.pow(2, mLen)\n e = e - eBias\n }\n return (s ? -1 : 1) * m * Math.pow(2, e - mLen)\n}\n\nexports.write = function (buffer, value, offset, isLE, mLen, nBytes) {\n var e, m, c\n var eLen = nBytes * 8 - mLen - 1\n var eMax = (1 << eLen) - 1\n var eBias = eMax >> 1\n var rt = (mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0)\n var i = isLE ? 0 : (nBytes - 1)\n var d = isLE ? 1 : -1\n var s = value < 0 || (value === 0 && 1 / value < 0) ? 1 : 0\n\n value = Math.abs(value)\n\n if (isNaN(value) || value === Infinity) {\n m = isNaN(value) ? 1 : 0\n e = eMax\n } else {\n e = Math.floor(Math.log(value) / Math.LN2)\n if (value * (c = Math.pow(2, -e)) < 1) {\n e--\n c *= 2\n }\n if (e + eBias >= 1) {\n value += rt / c\n } else {\n value += rt * Math.pow(2, 1 - eBias)\n }\n if (value * c >= 2) {\n e++\n c /= 2\n }\n\n if (e + eBias >= eMax) {\n m = 0\n e = eMax\n } else if (e + eBias >= 1) {\n m = (value * c - 1) * Math.pow(2, mLen)\n e = e + eBias\n } else {\n m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen)\n e = 0\n }\n }\n\n for (; mLen >= 8; buffer[offset + i] = m & 0xff, i += d, m /= 256, mLen -= 8) {}\n\n e = (e << mLen) | m\n eLen += mLen\n for (; eLen > 0; buffer[offset + i] = e & 0xff, i += d, e /= 256, eLen -= 8) {}\n\n buffer[offset + i - d] |= s * 128\n}\n","var toString = {}.toString;\n\nmodule.exports = Array.isArray || function (arr) {\n return toString.call(arr) == '[object Array]';\n};\n","/*\n * $Id: base64.js,v 2.15 2014/04/05 12:58:57 dankogai Exp dankogai $\n *\n * Licensed under the MIT license.\n * http://opensource.org/licenses/mit-license\n *\n * References:\n * http://en.wikipedia.org/wiki/Base64\n */\n\n(function(global) {\n 'use strict';\n // existing version for noConflict()\n var _Base64 = global.Base64;\n var version = \"2.1.9\";\n // if node.js, we use Buffer\n var buffer;\n if (typeof module !== 'undefined' && module.exports) {\n try {\n buffer = require('buffer').Buffer;\n } catch (err) {}\n }\n // constants\n var b64chars\n = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';\n var b64tab = function(bin) {\n var t = {};\n for (var i = 0, l = bin.length; i < l; i++) t[bin.charAt(i)] = i;\n return t;\n }(b64chars);\n var fromCharCode = String.fromCharCode;\n // encoder stuff\n var cb_utob = function(c) {\n if (c.length < 2) {\n var cc = c.charCodeAt(0);\n return cc < 0x80 ? c\n : cc < 0x800 ? (fromCharCode(0xc0 | (cc >>> 6))\n + fromCharCode(0x80 | (cc & 0x3f)))\n : (fromCharCode(0xe0 | ((cc >>> 12) & 0x0f))\n + fromCharCode(0x80 | ((cc >>> 6) & 0x3f))\n + fromCharCode(0x80 | ( cc & 0x3f)));\n } else {\n var cc = 0x10000\n + (c.charCodeAt(0) - 0xD800) * 0x400\n + (c.charCodeAt(1) - 0xDC00);\n return (fromCharCode(0xf0 | ((cc >>> 18) & 0x07))\n + fromCharCode(0x80 | ((cc >>> 12) & 0x3f))\n + fromCharCode(0x80 | ((cc >>> 6) & 0x3f))\n + fromCharCode(0x80 | ( cc & 0x3f)));\n }\n };\n var re_utob = /[\\uD800-\\uDBFF][\\uDC00-\\uDFFFF]|[^\\x00-\\x7F]/g;\n var utob = function(u) {\n return u.replace(re_utob, cb_utob);\n };\n var cb_encode = function(ccc) {\n var padlen = [0, 2, 1][ccc.length % 3],\n ord = ccc.charCodeAt(0) << 16\n | ((ccc.length > 1 ? ccc.charCodeAt(1) : 0) << 8)\n | ((ccc.length > 2 ? ccc.charCodeAt(2) : 0)),\n chars = [\n b64chars.charAt( ord >>> 18),\n b64chars.charAt((ord >>> 12) & 63),\n padlen >= 2 ? '=' : b64chars.charAt((ord >>> 6) & 63),\n padlen >= 1 ? '=' : b64chars.charAt(ord & 63)\n ];\n return chars.join('');\n };\n var btoa = global.btoa ? function(b) {\n return global.btoa(b);\n } : function(b) {\n return b.replace(/[\\s\\S]{1,3}/g, cb_encode);\n };\n var _encode = buffer ? function (u) {\n return (u.constructor === buffer.constructor ? u : new buffer(u))\n .toString('base64')\n }\n : function (u) { return btoa(utob(u)) }\n ;\n var encode = function(u, urisafe) {\n return !urisafe\n ? _encode(String(u))\n : _encode(String(u)).replace(/[+\\/]/g, function(m0) {\n return m0 == '+' ? '-' : '_';\n }).replace(/=/g, '');\n };\n var encodeURI = function(u) { return encode(u, true) };\n // decoder stuff\n var re_btou = new RegExp([\n '[\\xC0-\\xDF][\\x80-\\xBF]',\n '[\\xE0-\\xEF][\\x80-\\xBF]{2}',\n '[\\xF0-\\xF7][\\x80-\\xBF]{3}'\n ].join('|'), 'g');\n var cb_btou = function(cccc) {\n switch(cccc.length) {\n case 4:\n var cp = ((0x07 & cccc.charCodeAt(0)) << 18)\n | ((0x3f & cccc.charCodeAt(1)) << 12)\n | ((0x3f & cccc.charCodeAt(2)) << 6)\n | (0x3f & cccc.charCodeAt(3)),\n offset = cp - 0x10000;\n return (fromCharCode((offset >>> 10) + 0xD800)\n + fromCharCode((offset & 0x3FF) + 0xDC00));\n case 3:\n return fromCharCode(\n ((0x0f & cccc.charCodeAt(0)) << 12)\n | ((0x3f & cccc.charCodeAt(1)) << 6)\n | (0x3f & cccc.charCodeAt(2))\n );\n default:\n return fromCharCode(\n ((0x1f & cccc.charCodeAt(0)) << 6)\n | (0x3f & cccc.charCodeAt(1))\n );\n }\n };\n var btou = function(b) {\n return b.replace(re_btou, cb_btou);\n };\n var cb_decode = function(cccc) {\n var len = cccc.length,\n padlen = len % 4,\n n = (len > 0 ? b64tab[cccc.charAt(0)] << 18 : 0)\n | (len > 1 ? b64tab[cccc.charAt(1)] << 12 : 0)\n | (len > 2 ? b64tab[cccc.charAt(2)] << 6 : 0)\n | (len > 3 ? b64tab[cccc.charAt(3)] : 0),\n chars = [\n fromCharCode( n >>> 16),\n fromCharCode((n >>> 8) & 0xff),\n fromCharCode( n & 0xff)\n ];\n chars.length -= [0, 0, 2, 1][padlen];\n return chars.join('');\n };\n var atob = global.atob ? function(a) {\n return global.atob(a);\n } : function(a){\n return a.replace(/[\\s\\S]{1,4}/g, cb_decode);\n };\n var _decode = buffer ? function(a) {\n return (a.constructor === buffer.constructor\n ? a : new buffer(a, 'base64')).toString();\n }\n : function(a) { return btou(atob(a)) };\n var decode = function(a){\n return _decode(\n String(a).replace(/[-_]/g, function(m0) { return m0 == '-' ? '+' : '/' })\n .replace(/[^A-Za-z0-9\\+\\/]/g, '')\n );\n };\n var noConflict = function() {\n var Base64 = global.Base64;\n global.Base64 = _Base64;\n return Base64;\n };\n // export Base64\n global.Base64 = {\n VERSION: version,\n atob: atob,\n btoa: btoa,\n fromBase64: decode,\n toBase64: encode,\n utob: utob,\n encode: encode,\n encodeURI: encodeURI,\n btou: btou,\n decode: decode,\n noConflict: noConflict\n };\n // if ES5 is available, make Base64.extendString() available\n if (typeof Object.defineProperty === 'function') {\n var noEnum = function(v){\n return {value:v,enumerable:false,writable:true,configurable:true};\n };\n global.Base64.extendString = function () {\n Object.defineProperty(\n String.prototype, 'fromBase64', noEnum(function () {\n return decode(this)\n }));\n Object.defineProperty(\n String.prototype, 'toBase64', noEnum(function (urisafe) {\n return encode(this, urisafe)\n }));\n Object.defineProperty(\n String.prototype, 'toBase64URI', noEnum(function () {\n return encode(this, true)\n }));\n };\n }\n // that's it!\n if (global['Meteor']) {\n Base64 = global.Base64; // for normal export in Meteor.js\n }\n})(this);\n","/**\n * Helpers.\n */\n\nvar s = 1000\nvar m = s * 60\nvar h = m * 60\nvar d = h * 24\nvar y = d * 365.25\n\n/**\n * Parse or format the given `val`.\n *\n * Options:\n *\n * - `long` verbose formatting [false]\n *\n * @param {String|Number} val\n * @param {Object} options\n * @throws {Error} throw an error if val is not a non-empty string or a number\n * @return {String|Number}\n * @api public\n */\n\nmodule.exports = function (val, options) {\n options = options || {}\n var type = typeof val\n if (type === 'string' && val.length > 0) {\n return parse(val)\n } else if (type === 'number' && isNaN(val) === false) {\n return options.long ?\n\t\t\tfmtLong(val) :\n\t\t\tfmtShort(val)\n }\n throw new Error('val is not a non-empty string or a valid number. val=' + JSON.stringify(val))\n}\n\n/**\n * Parse the given `str` and return milliseconds.\n *\n * @param {String} str\n * @return {Number}\n * @api private\n */\n\nfunction parse(str) {\n str = String(str)\n if (str.length > 10000) {\n return\n }\n var match = /^((?:\\d+)?\\.?\\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|years?|yrs?|y)?$/i.exec(str)\n if (!match) {\n return\n }\n var n = parseFloat(match[1])\n var type = (match[2] || 'ms').toLowerCase()\n switch (type) {\n case 'years':\n case 'year':\n case 'yrs':\n case 'yr':\n case 'y':\n return n * y\n case 'days':\n case 'day':\n case 'd':\n return n * d\n case 'hours':\n case 'hour':\n case 'hrs':\n case 'hr':\n case 'h':\n return n * h\n case 'minutes':\n case 'minute':\n case 'mins':\n case 'min':\n case 'm':\n return n * m\n case 'seconds':\n case 'second':\n case 'secs':\n case 'sec':\n case 's':\n return n * s\n case 'milliseconds':\n case 'millisecond':\n case 'msecs':\n case 'msec':\n case 'ms':\n return n\n default:\n return undefined\n }\n}\n\n/**\n * Short format for `ms`.\n *\n * @param {Number} ms\n * @return {String}\n * @api private\n */\n\nfunction fmtShort(ms) {\n if (ms >= d) {\n return Math.round(ms / d) + 'd'\n }\n if (ms >= h) {\n return Math.round(ms / h) + 'h'\n }\n if (ms >= m) {\n return Math.round(ms / m) + 'm'\n }\n if (ms >= s) {\n return Math.round(ms / s) + 's'\n }\n return ms + 'ms'\n}\n\n/**\n * Long format for `ms`.\n *\n * @param {Number} ms\n * @return {String}\n * @api private\n */\n\nfunction fmtLong(ms) {\n return plural(ms, d, 'day') ||\n plural(ms, h, 'hour') ||\n plural(ms, m, 'minute') ||\n plural(ms, s, 'second') ||\n ms + ' ms'\n}\n\n/**\n * Pluralization helper.\n */\n\nfunction plural(ms, n, name) {\n if (ms < n) {\n return\n }\n if (ms < n * 1.5) {\n return Math.floor(ms / n) + ' ' + name\n }\n return Math.ceil(ms / n) + ' ' + name + 's'\n}\n","// shim for using process in browser\nvar process = module.exports = {};\n\n// cached from whatever global is present so that test runners that stub it\n// don't break things. But we need to wrap it in a try catch in case it is\n// wrapped in strict mode code which doesn't define any globals. It's inside a\n// function because try/catches deoptimize in certain engines.\n\nvar cachedSetTimeout;\nvar cachedClearTimeout;\n\nfunction defaultSetTimout() {\n throw new Error('setTimeout has not been defined');\n}\nfunction defaultClearTimeout () {\n throw new Error('clearTimeout has not been defined');\n}\n(function () {\n try {\n if (typeof setTimeout === 'function') {\n cachedSetTimeout = setTimeout;\n } else {\n cachedSetTimeout = defaultSetTimout;\n }\n } catch (e) {\n cachedSetTimeout = defaultSetTimout;\n }\n try {\n if (typeof clearTimeout === 'function') {\n cachedClearTimeout = clearTimeout;\n } else {\n cachedClearTimeout = defaultClearTimeout;\n }\n } catch (e) {\n cachedClearTimeout = defaultClearTimeout;\n }\n} ())\nfunction runTimeout(fun) {\n if (cachedSetTimeout === setTimeout) {\n //normal enviroments in sane situations\n return setTimeout(fun, 0);\n }\n // if setTimeout wasn't available but was latter defined\n if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {\n cachedSetTimeout = setTimeout;\n return setTimeout(fun, 0);\n }\n try {\n // when when somebody has screwed with setTimeout but no I.E. maddness\n return cachedSetTimeout(fun, 0);\n } catch(e){\n try {\n // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally\n return cachedSetTimeout.call(null, fun, 0);\n } catch(e){\n // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error\n return cachedSetTimeout.call(this, fun, 0);\n }\n }\n\n\n}\nfunction runClearTimeout(marker) {\n if (cachedClearTimeout === clearTimeout) {\n //normal enviroments in sane situations\n return clearTimeout(marker);\n }\n // if clearTimeout wasn't available but was latter defined\n if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {\n cachedClearTimeout = clearTimeout;\n return clearTimeout(marker);\n }\n try {\n // when when somebody has screwed with setTimeout but no I.E. maddness\n return cachedClearTimeout(marker);\n } catch (e){\n try {\n // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally\n return cachedClearTimeout.call(null, marker);\n } catch (e){\n // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error.\n // Some versions of I.E. have different rules for clearTimeout vs setTimeout\n return cachedClearTimeout.call(this, marker);\n }\n }\n\n\n\n}\nvar queue = [];\nvar draining = false;\nvar currentQueue;\nvar queueIndex = -1;\n\nfunction cleanUpNextTick() {\n if (!draining || !currentQueue) {\n return;\n }\n draining = false;\n if (currentQueue.length) {\n queue = currentQueue.concat(queue);\n } else {\n queueIndex = -1;\n }\n if (queue.length) {\n drainQueue();\n }\n}\n\nfunction drainQueue() {\n if (draining) {\n return;\n }\n var timeout = runTimeout(cleanUpNextTick);\n draining = true;\n\n var len = queue.length;\n while(len) {\n currentQueue = queue;\n queue = [];\n while (++queueIndex < len) {\n if (currentQueue) {\n currentQueue[queueIndex].run();\n }\n }\n queueIndex = -1;\n len = queue.length;\n }\n currentQueue = null;\n draining = false;\n runClearTimeout(timeout);\n}\n\nprocess.nextTick = function (fun) {\n var args = new Array(arguments.length - 1);\n if (arguments.length > 1) {\n for (var i = 1; i < arguments.length; i++) {\n args[i - 1] = arguments[i];\n }\n }\n queue.push(new Item(fun, args));\n if (queue.length === 1 && !draining) {\n runTimeout(drainQueue);\n }\n};\n\n// v8 likes predictible objects\nfunction Item(fun, array) {\n this.fun = fun;\n this.array = array;\n}\nItem.prototype.run = function () {\n this.fun.apply(null, this.array);\n};\nprocess.title = 'browser';\nprocess.browser = true;\nprocess.env = {};\nprocess.argv = [];\nprocess.version = ''; // empty string to avoid regexp issues\nprocess.versions = {};\n\nfunction noop() {}\n\nprocess.on = noop;\nprocess.addListener = noop;\nprocess.once = noop;\nprocess.off = noop;\nprocess.removeListener = noop;\nprocess.removeAllListeners = noop;\nprocess.emit = noop;\n\nprocess.binding = function (name) {\n throw new Error('process.binding is not supported');\n};\n\nprocess.cwd = function () { return '/' };\nprocess.chdir = function (dir) {\n throw new Error('process.chdir is not supported');\n};\nprocess.umask = function() { return 0; };\n","/*! https://mths.be/utf8js v2.1.2 by @mathias */\n;(function(root) {\n\n\t// Detect free variables `exports`\n\tvar freeExports = typeof exports == 'object' && exports;\n\n\t// Detect free variable `module`\n\tvar freeModule = typeof module == 'object' && module &&\n\t\tmodule.exports == freeExports && module;\n\n\t// Detect free variable `global`, from Node.js or Browserified code,\n\t// and use it as `root`\n\tvar freeGlobal = typeof global == 'object' && global;\n\tif (freeGlobal.global === freeGlobal || freeGlobal.window === freeGlobal) {\n\t\troot = freeGlobal;\n\t}\n\n\t/*--------------------------------------------------------------------------*/\n\n\tvar stringFromCharCode = String.fromCharCode;\n\n\t// Taken from https://mths.be/punycode\n\tfunction ucs2decode(string) {\n\t\tvar output = [];\n\t\tvar counter = 0;\n\t\tvar length = string.length;\n\t\tvar value;\n\t\tvar extra;\n\t\twhile (counter < length) {\n\t\t\tvalue = string.charCodeAt(counter++);\n\t\t\tif (value >= 0xD800 && value <= 0xDBFF && counter < length) {\n\t\t\t\t// high surrogate, and there is a next character\n\t\t\t\textra = string.charCodeAt(counter++);\n\t\t\t\tif ((extra & 0xFC00) == 0xDC00) { // low surrogate\n\t\t\t\t\toutput.push(((value & 0x3FF) << 10) + (extra & 0x3FF) + 0x10000);\n\t\t\t\t} else {\n\t\t\t\t\t// unmatched surrogate; only append this code unit, in case the next\n\t\t\t\t\t// code unit is the high surrogate of a surrogate pair\n\t\t\t\t\toutput.push(value);\n\t\t\t\t\tcounter--;\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\toutput.push(value);\n\t\t\t}\n\t\t}\n\t\treturn output;\n\t}\n\n\t// Taken from https://mths.be/punycode\n\tfunction ucs2encode(array) {\n\t\tvar length = array.length;\n\t\tvar index = -1;\n\t\tvar value;\n\t\tvar output = '';\n\t\twhile (++index < length) {\n\t\t\tvalue = array[index];\n\t\t\tif (value > 0xFFFF) {\n\t\t\t\tvalue -= 0x10000;\n\t\t\t\toutput += stringFromCharCode(value >>> 10 & 0x3FF | 0xD800);\n\t\t\t\tvalue = 0xDC00 | value & 0x3FF;\n\t\t\t}\n\t\t\toutput += stringFromCharCode(value);\n\t\t}\n\t\treturn output;\n\t}\n\n\tfunction checkScalarValue(codePoint) {\n\t\tif (codePoint >= 0xD800 && codePoint <= 0xDFFF) {\n\t\t\tthrow Error(\n\t\t\t\t'Lone surrogate U+' + codePoint.toString(16).toUpperCase() +\n\t\t\t\t' is not a scalar value'\n\t\t\t);\n\t\t}\n\t}\n\t/*--------------------------------------------------------------------------*/\n\n\tfunction createByte(codePoint, shift) {\n\t\treturn stringFromCharCode(((codePoint >> shift) & 0x3F) | 0x80);\n\t}\n\n\tfunction encodeCodePoint(codePoint) {\n\t\tif ((codePoint & 0xFFFFFF80) == 0) { // 1-byte sequence\n\t\t\treturn stringFromCharCode(codePoint);\n\t\t}\n\t\tvar symbol = '';\n\t\tif ((codePoint & 0xFFFFF800) == 0) { // 2-byte sequence\n\t\t\tsymbol = stringFromCharCode(((codePoint >> 6) & 0x1F) | 0xC0);\n\t\t}\n\t\telse if ((codePoint & 0xFFFF0000) == 0) { // 3-byte sequence\n\t\t\tcheckScalarValue(codePoint);\n\t\t\tsymbol = stringFromCharCode(((codePoint >> 12) & 0x0F) | 0xE0);\n\t\t\tsymbol += createByte(codePoint, 6);\n\t\t}\n\t\telse if ((codePoint & 0xFFE00000) == 0) { // 4-byte sequence\n\t\t\tsymbol = stringFromCharCode(((codePoint >> 18) & 0x07) | 0xF0);\n\t\t\tsymbol += createByte(codePoint, 12);\n\t\t\tsymbol += createByte(codePoint, 6);\n\t\t}\n\t\tsymbol += stringFromCharCode((codePoint & 0x3F) | 0x80);\n\t\treturn symbol;\n\t}\n\n\tfunction utf8encode(string) {\n\t\tvar codePoints = ucs2decode(string);\n\t\tvar length = codePoints.length;\n\t\tvar index = -1;\n\t\tvar codePoint;\n\t\tvar byteString = '';\n\t\twhile (++index < length) {\n\t\t\tcodePoint = codePoints[index];\n\t\t\tbyteString += encodeCodePoint(codePoint);\n\t\t}\n\t\treturn byteString;\n\t}\n\n\t/*--------------------------------------------------------------------------*/\n\n\tfunction readContinuationByte() {\n\t\tif (byteIndex >= byteCount) {\n\t\t\tthrow Error('Invalid byte index');\n\t\t}\n\n\t\tvar continuationByte = byteArray[byteIndex] & 0xFF;\n\t\tbyteIndex++;\n\n\t\tif ((continuationByte & 0xC0) == 0x80) {\n\t\t\treturn continuationByte & 0x3F;\n\t\t}\n\n\t\t// If we end up here, it’s not a continuation byte\n\t\tthrow Error('Invalid continuation byte');\n\t}\n\n\tfunction decodeSymbol() {\n\t\tvar byte1;\n\t\tvar byte2;\n\t\tvar byte3;\n\t\tvar byte4;\n\t\tvar codePoint;\n\n\t\tif (byteIndex > byteCount) {\n\t\t\tthrow Error('Invalid byte index');\n\t\t}\n\n\t\tif (byteIndex == byteCount) {\n\t\t\treturn false;\n\t\t}\n\n\t\t// Read first byte\n\t\tbyte1 = byteArray[byteIndex] & 0xFF;\n\t\tbyteIndex++;\n\n\t\t// 1-byte sequence (no continuation bytes)\n\t\tif ((byte1 & 0x80) == 0) {\n\t\t\treturn byte1;\n\t\t}\n\n\t\t// 2-byte sequence\n\t\tif ((byte1 & 0xE0) == 0xC0) {\n\t\t\tbyte2 = readContinuationByte();\n\t\t\tcodePoint = ((byte1 & 0x1F) << 6) | byte2;\n\t\t\tif (codePoint >= 0x80) {\n\t\t\t\treturn codePoint;\n\t\t\t} else {\n\t\t\t\tthrow Error('Invalid continuation byte');\n\t\t\t}\n\t\t}\n\n\t\t// 3-byte sequence (may include unpaired surrogates)\n\t\tif ((byte1 & 0xF0) == 0xE0) {\n\t\t\tbyte2 = readContinuationByte();\n\t\t\tbyte3 = readContinuationByte();\n\t\t\tcodePoint = ((byte1 & 0x0F) << 12) | (byte2 << 6) | byte3;\n\t\t\tif (codePoint >= 0x0800) {\n\t\t\t\tcheckScalarValue(codePoint);\n\t\t\t\treturn codePoint;\n\t\t\t} else {\n\t\t\t\tthrow Error('Invalid continuation byte');\n\t\t\t}\n\t\t}\n\n\t\t// 4-byte sequence\n\t\tif ((byte1 & 0xF8) == 0xF0) {\n\t\t\tbyte2 = readContinuationByte();\n\t\t\tbyte3 = readContinuationByte();\n\t\t\tbyte4 = readContinuationByte();\n\t\t\tcodePoint = ((byte1 & 0x07) << 0x12) | (byte2 << 0x0C) |\n\t\t\t\t(byte3 << 0x06) | byte4;\n\t\t\tif (codePoint >= 0x010000 && codePoint <= 0x10FFFF) {\n\t\t\t\treturn codePoint;\n\t\t\t}\n\t\t}\n\n\t\tthrow Error('Invalid UTF-8 detected');\n\t}\n\n\tvar byteArray;\n\tvar byteCount;\n\tvar byteIndex;\n\tfunction utf8decode(byteString) {\n\t\tbyteArray = ucs2decode(byteString);\n\t\tbyteCount = byteArray.length;\n\t\tbyteIndex = 0;\n\t\tvar codePoints = [];\n\t\tvar tmp;\n\t\twhile ((tmp = decodeSymbol()) !== false) {\n\t\t\tcodePoints.push(tmp);\n\t\t}\n\t\treturn ucs2encode(codePoints);\n\t}\n\n\t/*--------------------------------------------------------------------------*/\n\n\tvar utf8 = {\n\t\t'version': '2.1.2',\n\t\t'encode': utf8encode,\n\t\t'decode': utf8decode\n\t};\n\n\t// Some AMD build optimizers, like r.js, check for specific condition patterns\n\t// like the following:\n\tif (\n\t\ttypeof define == 'function' &&\n\t\ttypeof define.amd == 'object' &&\n\t\tdefine.amd\n\t) {\n\t\tdefine(function() {\n\t\t\treturn utf8;\n\t\t});\n\t}\telse if (freeExports && !freeExports.nodeType) {\n\t\tif (freeModule) { // in Node.js or RingoJS v0.8.0+\n\t\t\tfreeModule.exports = utf8;\n\t\t} else { // in Narwhal or RingoJS v0.7.0-\n\t\t\tvar object = {};\n\t\t\tvar hasOwnProperty = object.hasOwnProperty;\n\t\t\tfor (var key in utf8) {\n\t\t\t\thasOwnProperty.call(utf8, key) && (freeExports[key] = utf8[key]);\n\t\t\t}\n\t\t}\n\t} else { // in Rhino or a web browser\n\t\troot.utf8 = utf8;\n\t}\n\n}(this));\n"]} \ No newline at end of file diff --git a/dist/GitHub.js b/dist/GitHub.js new file mode 100644 index 00000000..df427752 --- /dev/null +++ b/dist/GitHub.js @@ -0,0 +1,3531 @@ +(function(f){if(typeof exports==="object"&&typeof module!=="undefined"){module.exports=f()}else if(typeof define==="function"&&define.amd){define([],f)}else{var g;if(typeof window!=="undefined"){g=window}else if(typeof global!=="undefined"){g=global}else if(typeof self!=="undefined"){g=self}else{g=this}g.GitHub = f()}})(function(){var define,module,exports;return (function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o 1 && arguments[1] !== undefined ? arguments[1] : 'https://api.github.com'; + + _classCallCheck(this, GitHub); + + this.__apiBase = apiBase; + this.__auth = auth || {}; + } + + /** + * Create a new Gist wrapper + * @param {number} [id] - the id for the gist, leave undefined when creating a new gist + * @return {Gist} + */ + + + _createClass(GitHub, [{ + key: 'getGist', + value: function getGist(id) { + return new _Gist2.default(id, this.__auth, this.__apiBase); + } + + /** + * Create a new User wrapper + * @param {string} [user] - the name of the user to get information about + * leave undefined for the authenticated user + * @return {User} + */ + + }, { + key: 'getUser', + value: function getUser(user) { + return new _User2.default(user, this.__auth, this.__apiBase); + } + + /** + * Create a new Organization wrapper + * @param {string} organization - the name of the organization + * @return {Organization} + */ + + }, { + key: 'getOrganization', + value: function getOrganization(organization) { + return new _Organization2.default(organization, this.__auth, this.__apiBase); + } + + /** + * create a new Team wrapper + * @param {string} teamId - the name of the team + * @return {team} + */ + + }, { + key: 'getTeam', + value: function getTeam(teamId) { + return new _Team2.default(teamId, this.__auth, this.__apiBase); + } + + /** + * Create a new Repository wrapper + * @param {string} user - the user who owns the respository + * @param {string} repo - the name of the repository + * @return {Repository} + */ + + }, { + key: 'getRepo', + value: function getRepo(user, repo) { + return new _Repository2.default(this._getFullName(user, repo), this.__auth, this.__apiBase); + } + + /** + * Create a new Issue wrapper + * @param {string} user - the user who owns the respository + * @param {string} repo - the name of the repository + * @return {Issue} + */ + + }, { + key: 'getIssues', + value: function getIssues(user, repo) { + return new _Issue2.default(this._getFullName(user, repo), this.__auth, this.__apiBase); + } + + /** + * Create a new Search wrapper + * @param {string} query - the query to search for + * @return {Search} + */ + + }, { + key: 'search', + value: function search(query) { + return new _Search2.default(query, this.__auth, this.__apiBase); + } + + /** + * Create a new RateLimit wrapper + * @return {RateLimit} + */ + + }, { + key: 'getRateLimit', + value: function getRateLimit() { + return new _RateLimit2.default(this.__auth, this.__apiBase); + } + + /** + * Create a new Markdown wrapper + * @return {Markdown} + */ + + }, { + key: 'getMarkdown', + value: function getMarkdown() { + return new _Markdown2.default(this.__auth, this.__apiBase); + } + + /** + * Create a new Project wrapper + * @param {string} id - the id of the project + * @return {Markdown} + */ + + }, { + key: 'getProject', + value: function getProject(id) { + return new _Project2.default(id, this.__auth, this.__apiBase); + } + + /** + * Computes the full repository name + * @param {string} user - the username (or the full name) + * @param {string} repo - the repository name, must not be passed if `user` is the full name + * @return {string} the repository's full name + */ + + }, { + key: '_getFullName', + value: function _getFullName(user, repo) { + var fullname = user; + + if (repo) { + fullname = user + '/' + repo; + } + + return fullname; + } + }]); + + return GitHub; +}(); + +module.exports = GitHub; + +},{"./Gist":1,"./Issue":3,"./Markdown":4,"./Organization":5,"./Project":6,"./RateLimit":7,"./Repository":8,"./Search":10,"./Team":11,"./User":12}],3:[function(require,module,exports){ +'use strict'; + +var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); + +var _Requestable2 = require('./Requestable'); + +var _Requestable3 = _interopRequireDefault(_Requestable2); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } + +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } /** + * @file + * @copyright 2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc. + * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}. + * Github.js is freely distributable. + */ + +/** + * Issue wraps the functionality to get issues for repositories + */ +var Issue = function (_Requestable) { + _inherits(Issue, _Requestable); + + /** + * Create a new Issue + * @param {string} repository - the full name of the repository (`:user/:repo`) to get issues for + * @param {Requestable.auth} [auth] - information required to authenticate to Github + * @param {string} [apiBase=https://api.github.com] - the base Github API URL + */ + function Issue(repository, auth, apiBase) { + _classCallCheck(this, Issue); + + var _this = _possibleConstructorReturn(this, (Issue.__proto__ || Object.getPrototypeOf(Issue)).call(this, auth, apiBase)); + + _this.__repository = repository; + return _this; + } + + /** + * Create a new issue + * @see https://developer.github.com/v3/issues/#create-an-issue + * @param {Object} issueData - the issue to create + * @param {Requestable.callback} [cb] - will receive the created issue + * @return {Promise} - the promise for the http request + */ + + + _createClass(Issue, [{ + key: 'createIssue', + value: function createIssue(issueData, cb) { + return this._request('POST', '/repos/' + this.__repository + '/issues', issueData, cb); + } + + /** + * List the issues for the repository + * @see https://developer.github.com/v3/issues/#list-issues-for-a-repository + * @param {Object} options - filtering options + * @param {Requestable.callback} [cb] - will receive the array of issues + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'listIssues', + value: function listIssues(options, cb) { + return this._requestAllPages('/repos/' + this.__repository + '/issues', options, cb); + } + + /** + * List the events for an issue + * @see https://developer.github.com/v3/issues/events/#list-events-for-an-issue + * @param {number} issue - the issue to get events for + * @param {Requestable.callback} [cb] - will receive the list of events + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'listIssueEvents', + value: function listIssueEvents(issue, cb) { + return this._request('GET', '/repos/' + this.__repository + '/issues/' + issue + '/events', null, cb); + } + + /** + * List comments on an issue + * @see https://developer.github.com/v3/issues/comments/#list-comments-on-an-issue + * @param {number} issue - the id of the issue to get comments from + * @param {Requestable.callback} [cb] - will receive the comments + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'listIssueComments', + value: function listIssueComments(issue, cb) { + return this._request('GET', '/repos/' + this.__repository + '/issues/' + issue + '/comments', null, cb); + } + + /** + * Get a single comment on an issue + * @see https://developer.github.com/v3/issues/comments/#get-a-single-comment + * @param {number} id - the comment id to get + * @param {Requestable.callback} [cb] - will receive the comment + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'getIssueComment', + value: function getIssueComment(id, cb) { + return this._request('GET', '/repos/' + this.__repository + '/issues/comments/' + id, null, cb); + } + + /** + * Comment on an issue + * @see https://developer.github.com/v3/issues/comments/#create-a-comment + * @param {number} issue - the id of the issue to comment on + * @param {string} comment - the comment to add + * @param {Requestable.callback} [cb] - will receive the created comment + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'createIssueComment', + value: function createIssueComment(issue, comment, cb) { + return this._request('POST', '/repos/' + this.__repository + '/issues/' + issue + '/comments', { body: comment }, cb); + } + + /** + * Edit a comment on an issue + * @see https://developer.github.com/v3/issues/comments/#edit-a-comment + * @param {number} id - the comment id to edit + * @param {string} comment - the comment to edit + * @param {Requestable.callback} [cb] - will receive the edited comment + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'editIssueComment', + value: function editIssueComment(id, comment, cb) { + return this._request('PATCH', '/repos/' + this.__repository + '/issues/comments/' + id, { body: comment }, cb); + } + + /** + * Delete a comment on an issue + * @see https://developer.github.com/v3/issues/comments/#delete-a-comment + * @param {number} id - the comment id to delete + * @param {Requestable.callback} [cb] - will receive true if the request is successful + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'deleteIssueComment', + value: function deleteIssueComment(id, cb) { + return this._request('DELETE', '/repos/' + this.__repository + '/issues/comments/' + id, null, cb); + } + + /** + * Edit an issue + * @see https://developer.github.com/v3/issues/#edit-an-issue + * @param {number} issue - the issue number to edit + * @param {Object} issueData - the new issue data + * @param {Requestable.callback} [cb] - will receive the modified issue + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'editIssue', + value: function editIssue(issue, issueData, cb) { + return this._request('PATCH', '/repos/' + this.__repository + '/issues/' + issue, issueData, cb); + } + + /** + * Get a particular issue + * @see https://developer.github.com/v3/issues/#get-a-single-issue + * @param {number} issue - the issue number to fetch + * @param {Requestable.callback} [cb] - will receive the issue + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'getIssue', + value: function getIssue(issue, cb) { + return this._request('GET', '/repos/' + this.__repository + '/issues/' + issue, null, cb); + } + + /** + * List the milestones for the repository + * @see https://developer.github.com/v3/issues/milestones/#list-milestones-for-a-repository + * @param {Object} options - filtering options + * @param {Requestable.callback} [cb] - will receive the array of milestones + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'listMilestones', + value: function listMilestones(options, cb) { + return this._request('GET', '/repos/' + this.__repository + '/milestones', options, cb); + } + + /** + * Get a milestone + * @see https://developer.github.com/v3/issues/milestones/#get-a-single-milestone + * @param {string} milestone - the id of the milestone to fetch + * @param {Requestable.callback} [cb] - will receive the milestone + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'getMilestone', + value: function getMilestone(milestone, cb) { + return this._request('GET', '/repos/' + this.__repository + '/milestones/' + milestone, null, cb); + } + + /** + * Create a new milestone + * @see https://developer.github.com/v3/issues/milestones/#create-a-milestone + * @param {Object} milestoneData - the milestone definition + * @param {Requestable.callback} [cb] - will receive the milestone + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'createMilestone', + value: function createMilestone(milestoneData, cb) { + return this._request('POST', '/repos/' + this.__repository + '/milestones', milestoneData, cb); + } + + /** + * Edit a milestone + * @see https://developer.github.com/v3/issues/milestones/#update-a-milestone + * @param {string} milestone - the id of the milestone to edit + * @param {Object} milestoneData - the updates to make to the milestone + * @param {Requestable.callback} [cb] - will receive the updated milestone + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'editMilestone', + value: function editMilestone(milestone, milestoneData, cb) { + return this._request('PATCH', '/repos/' + this.__repository + '/milestones/' + milestone, milestoneData, cb); + } + + /** + * Delete a milestone (this is distinct from closing a milestone) + * @see https://developer.github.com/v3/issues/milestones/#delete-a-milestone + * @param {string} milestone - the id of the milestone to delete + * @param {Requestable.callback} [cb] - will receive the status + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'deleteMilestone', + value: function deleteMilestone(milestone, cb) { + return this._request('DELETE', '/repos/' + this.__repository + '/milestones/' + milestone, null, cb); + } + + /** + * Create a new label + * @see https://developer.github.com/v3/issues/labels/#create-a-label + * @param {Object} labelData - the label definition + * @param {Requestable.callback} [cb] - will receive the object representing the label + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'createLabel', + value: function createLabel(labelData, cb) { + return this._request('POST', '/repos/' + this.__repository + '/labels', labelData, cb); + } + + /** + * List the labels for the repository + * @see https://developer.github.com/v3/issues/labels/#list-all-labels-for-this-repository + * @param {Object} options - filtering options + * @param {Requestable.callback} [cb] - will receive the array of labels + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'listLabels', + value: function listLabels(options, cb) { + return this._request('GET', '/repos/' + this.__repository + '/labels', options, cb); + } + + /** + * Get a label + * @see https://developer.github.com/v3/issues/labels/#get-a-single-label + * @param {string} label - the name of the label to fetch + * @param {Requestable.callback} [cb] - will receive the label + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'getLabel', + value: function getLabel(label, cb) { + return this._request('GET', '/repos/' + this.__repository + '/labels/' + label, null, cb); + } + + /** + * Edit a label + * @see https://developer.github.com/v3/issues/labels/#update-a-label + * @param {string} label - the name of the label to edit + * @param {Object} labelData - the updates to make to the label + * @param {Requestable.callback} [cb] - will receive the updated label + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'editLabel', + value: function editLabel(label, labelData, cb) { + return this._request('PATCH', '/repos/' + this.__repository + '/labels/' + label, labelData, cb); + } + + /** + * Delete a label + * @see https://developer.github.com/v3/issues/labels/#delete-a-label + * @param {string} label - the name of the label to delete + * @param {Requestable.callback} [cb] - will receive the status + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'deleteLabel', + value: function deleteLabel(label, cb) { + return this._request('DELETE', '/repos/' + this.__repository + '/labels/' + label, null, cb); + } + }]); + + return Issue; +}(_Requestable3.default); + +module.exports = Issue; + +},{"./Requestable":9}],4:[function(require,module,exports){ +'use strict'; + +var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); + +var _Requestable2 = require('./Requestable'); + +var _Requestable3 = _interopRequireDefault(_Requestable2); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } + +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } /** + * @file + * @copyright 2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc. + * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}. + * Github.js is freely distributable. + */ + +/** + * Renders html from Markdown text + */ +var Markdown = function (_Requestable) { + _inherits(Markdown, _Requestable); + + /** + * construct a Markdown + * @param {Requestable.auth} auth - the credentials to authenticate to GitHub + * @param {string} [apiBase] - the base Github API URL + * @return {Promise} - the promise for the http request + */ + function Markdown(auth, apiBase) { + _classCallCheck(this, Markdown); + + return _possibleConstructorReturn(this, (Markdown.__proto__ || Object.getPrototypeOf(Markdown)).call(this, auth, apiBase)); + } + + /** + * Render html from Markdown text. + * @see https://developer.github.com/v3/markdown/#render-an-arbitrary-markdown-document + * @param {Object} options - conversion options + * @param {string} [options.text] - the markdown text to convert + * @param {string} [options.mode=markdown] - can be either `markdown` or `gfm` + * @param {string} [options.context] - repository name if mode is gfm + * @param {Requestable.callback} [cb] - will receive the converted html + * @return {Promise} - the promise for the http request + */ + + + _createClass(Markdown, [{ + key: 'render', + value: function render(options, cb) { + return this._request('POST', '/markdown', options, cb); + } + }]); + + return Markdown; +}(_Requestable3.default); + +module.exports = Markdown; + +},{"./Requestable":9}],5:[function(require,module,exports){ +'use strict'; + +var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); + +var _Requestable2 = require('./Requestable'); + +var _Requestable3 = _interopRequireDefault(_Requestable2); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } + +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } /** + * @file + * @copyright 2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc. + * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}. + * Github.js is freely distributable. + */ + +/** + * Organization encapsulates the functionality to create repositories in organizations + */ +var Organization = function (_Requestable) { + _inherits(Organization, _Requestable); + + /** + * Create a new Organization + * @param {string} organization - the name of the organization + * @param {Requestable.auth} [auth] - information required to authenticate to Github + * @param {string} [apiBase=https://api.github.com] - the base Github API URL + */ + function Organization(organization, auth, apiBase) { + _classCallCheck(this, Organization); + + var _this = _possibleConstructorReturn(this, (Organization.__proto__ || Object.getPrototypeOf(Organization)).call(this, auth, apiBase)); + + _this.__name = organization; + return _this; + } + + /** + * Create a repository in an organization + * @see https://developer.github.com/v3/repos/#create + * @param {Object} options - the repository definition + * @param {Requestable.callback} [cb] - will receive the created repository + * @return {Promise} - the promise for the http request + */ + + + _createClass(Organization, [{ + key: 'createRepo', + value: function createRepo(options, cb) { + return this._request('POST', '/orgs/' + this.__name + '/repos', options, cb); + } + + /** + * List the repositories in an organization + * @see https://developer.github.com/v3/repos/#list-organization-repositories + * @param {Requestable.callback} [cb] - will receive the list of repositories + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'getRepos', + value: function getRepos(cb) { + var requestOptions = this._getOptionsWithDefaults({ direction: 'desc' }); + + return this._requestAllPages('/orgs/' + this.__name + '/repos', requestOptions, cb); + } + + /** + * Query if the user is a member or not + * @param {string} username - the user in question + * @param {Requestable.callback} [cb] - will receive true if the user is a member + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'isMember', + value: function isMember(username, cb) { + return this._request204or404('/orgs/' + this.__name + '/members/' + username, null, cb); + } + + /** + * List the users who are members of the company + * @see https://developer.github.com/v3/orgs/members/#members-list + * @param {object} options - filtering options + * @param {string} [options.filter=all] - can be either `2fa_disabled` or `all` + * @param {string} [options.role=all] - can be one of: `all`, `admin`, or `member` + * @param {Requestable.callback} [cb] - will receive the list of users + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'listMembers', + value: function listMembers(options, cb) { + return this._request('GET', '/orgs/' + this.__name + '/members', options, cb); + } + + /** + * List the Teams in the Organization + * @see https://developer.github.com/v3/orgs/teams/#list-teams + * @param {Requestable.callback} [cb] - will receive the list of teams + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'getTeams', + value: function getTeams(cb) { + return this._requestAllPages('/orgs/' + this.__name + '/teams', undefined, cb); + } + + /** + * Create a team + * @see https://developer.github.com/v3/orgs/teams/#create-team + * @param {object} options - Team creation parameters + * @param {string} options.name - The name of the team + * @param {string} [options.description] - Team description + * @param {string} [options.repo_names] - Repos to add the team to + * @param {string} [options.privacy=secret] - The level of privacy the team should have. Can be either one + * of: `secret`, or `closed` + * @param {Requestable.callback} [cb] - will receive the created team + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'createTeam', + value: function createTeam(options, cb) { + return this._request('POST', '/orgs/' + this.__name + '/teams', options, cb); + } + + /** + * Get information about all projects + * @see https://developer.github.com/v3/projects/#list-organization-projects + * @param {Requestable.callback} [cb] - will receive the list of projects + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'listProjects', + value: function listProjects(cb) { + return this._requestAllPages('/orgs/' + this.__name + '/projects', { AcceptHeader: 'inertia-preview' }, cb); + } + + /** + * Create a new project + * @see https://developer.github.com/v3/repos/projects/#create-a-project + * @param {Object} options - the description of the project + * @param {Requestable.callback} cb - will receive the newly created project + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'createProject', + value: function createProject(options, cb) { + options = options || {}; + options.AcceptHeader = 'inertia-preview'; + return this._request('POST', '/orgs/' + this.__name + '/projects', options, cb); + } + }]); + + return Organization; +}(_Requestable3.default); + +module.exports = Organization; + +},{"./Requestable":9}],6:[function(require,module,exports){ +'use strict'; + +var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); + +var _Requestable2 = require('./Requestable'); + +var _Requestable3 = _interopRequireDefault(_Requestable2); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +function _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } } + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } + +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } /** + * @file + * @copyright 2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc. + * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}. + * Github.js is freely distributable. + */ + +/** + * Project encapsulates the functionality to create, query, and modify cards and columns. + */ +var Project = function (_Requestable) { + _inherits(Project, _Requestable); + + /** + * Create a Project. + * @param {string} id - the id of the project + * @param {Requestable.auth} [auth] - information required to authenticate to Github + * @param {string} [apiBase=https://api.github.com] - the base Github API URL + */ + function Project(id, auth, apiBase) { + _classCallCheck(this, Project); + + var _this = _possibleConstructorReturn(this, (Project.__proto__ || Object.getPrototypeOf(Project)).call(this, auth, apiBase, 'inertia-preview')); + + _this.__id = id; + return _this; + } + + /** + * Get information about a project + * @see https://developer.github.com/v3/projects/#get-a-project + * @param {Requestable.callback} cb - will receive the project information + * @return {Promise} - the promise for the http request + */ + + + _createClass(Project, [{ + key: 'getProject', + value: function getProject(cb) { + return this._request('GET', '/projects/' + this.__id, null, cb); + } + + /** + * Edit a project + * @see https://developer.github.com/v3/projects/#update-a-project + * @param {Object} options - the description of the project + * @param {Requestable.callback} cb - will receive the modified project + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'updateProject', + value: function updateProject(options, cb) { + return this._request('PATCH', '/projects/' + this.__id, options, cb); + } + + /** + * Delete a project + * @see https://developer.github.com/v3/projects/#delete-a-project + * @param {Requestable.callback} cb - will receive true if the operation is successful + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'deleteProject', + value: function deleteProject(cb) { + return this._request('DELETE', '/projects/' + this.__id, null, cb); + } + + /** + * Get information about all columns of a project + * @see https://developer.github.com/v3/projects/columns/#list-project-columns + * @param {Requestable.callback} [cb] - will receive the list of columns + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'listProjectColumns', + value: function listProjectColumns(cb) { + return this._requestAllPages('/projects/' + this.__id + '/columns', null, cb); + } + + /** + * Get information about a column + * @see https://developer.github.com/v3/projects/columns/#get-a-project-column + * @param {string} colId - the id of the column + * @param {Requestable.callback} cb - will receive the column information + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'getProjectColumn', + value: function getProjectColumn(colId, cb) { + return this._request('GET', '/projects/columns/' + colId, null, cb); + } + + /** + * Create a new column + * @see https://developer.github.com/v3/projects/columns/#create-a-project-column + * @param {Object} options - the description of the column + * @param {Requestable.callback} cb - will receive the newly created column + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'createProjectColumn', + value: function createProjectColumn(options, cb) { + return this._request('POST', '/projects/' + this.__id + '/columns', options, cb); + } + + /** + * Edit a column + * @see https://developer.github.com/v3/projects/columns/#update-a-project-column + * @param {string} colId - the column id + * @param {Object} options - the description of the column + * @param {Requestable.callback} cb - will receive the modified column + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'updateProjectColumn', + value: function updateProjectColumn(colId, options, cb) { + return this._request('PATCH', '/projects/columns/' + colId, options, cb); + } + + /** + * Delete a column + * @see https://developer.github.com/v3/projects/columns/#delete-a-project-column + * @param {string} colId - the column to be deleted + * @param {Requestable.callback} cb - will receive true if the operation is successful + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'deleteProjectColumn', + value: function deleteProjectColumn(colId, cb) { + return this._request('DELETE', '/projects/columns/' + colId, null, cb); + } + + /** + * Move a column + * @see https://developer.github.com/v3/projects/columns/#move-a-project-column + * @param {string} colId - the column to be moved + * @param {string} position - can be one of first, last, or after:, + * where is the id value of a column in the same project. + * @param {Requestable.callback} cb - will receive true if the operation is successful + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'moveProjectColumn', + value: function moveProjectColumn(colId, position, cb) { + return this._request('POST', '/projects/columns/' + colId + '/moves', { position: position }, cb); + } + + /** + * Get information about all cards of a project + * @see https://developer.github.com/v3/projects/cards/#list-project-cards + * @param {Requestable.callback} [cb] - will receive the list of cards + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'listProjectCards', + value: function listProjectCards(cb) { + var _this2 = this; + + return this.listProjectColumns().then(function (_ref) { + var data = _ref.data; + + return Promise.all(data.map(function (column) { + return _this2._requestAllPages('/projects/columns/' + column.id + '/cards', null); + })); + }).then(function (cardsInColumns) { + var cards = cardsInColumns.reduce(function (prev, _ref2) { + var data = _ref2.data; + + prev.push.apply(prev, _toConsumableArray(data)); + return prev; + }, []); + if (cb) { + cb(null, cards); + } + return cards; + }).catch(function (err) { + if (cb) { + cb(err); + return; + } + throw err; + }); + } + + /** + * Get information about all cards of a column + * @see https://developer.github.com/v3/projects/cards/#list-project-cards + * @param {string} colId - the id of the column + * @param {Requestable.callback} [cb] - will receive the list of cards + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'listColumnCards', + value: function listColumnCards(colId, cb) { + return this._requestAllPages('/projects/columns/' + colId + '/cards', null, cb); + } + + /** + * Get information about a card + * @see https://developer.github.com/v3/projects/cards/#get-a-project-card + * @param {string} cardId - the id of the card + * @param {Requestable.callback} cb - will receive the card information + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'getProjectCard', + value: function getProjectCard(cardId, cb) { + return this._request('GET', '/projects/columns/cards/' + cardId, null, cb); + } + + /** + * Create a new card + * @see https://developer.github.com/v3/projects/cards/#create-a-project-card + * @param {string} colId - the column id + * @param {Object} options - the description of the card + * @param {Requestable.callback} cb - will receive the newly created card + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'createProjectCard', + value: function createProjectCard(colId, options, cb) { + return this._request('POST', '/projects/columns/' + colId + '/cards', options, cb); + } + + /** + * Edit a card + * @see https://developer.github.com/v3/projects/cards/#update-a-project-card + * @param {string} cardId - the card id + * @param {Object} options - the description of the card + * @param {Requestable.callback} cb - will receive the modified card + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'updateProjectCard', + value: function updateProjectCard(cardId, options, cb) { + return this._request('PATCH', '/projects/columns/cards/' + cardId, options, cb); + } + + /** + * Delete a card + * @see https://developer.github.com/v3/projects/cards/#delete-a-project-card + * @param {string} cardId - the card to be deleted + * @param {Requestable.callback} cb - will receive true if the operation is successful + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'deleteProjectCard', + value: function deleteProjectCard(cardId, cb) { + return this._request('DELETE', '/projects/columns/cards/' + cardId, null, cb); + } + + /** + * Move a card + * @see https://developer.github.com/v3/projects/cards/#move-a-project-card + * @param {string} cardId - the card to be moved + * @param {string} position - can be one of top, bottom, or after:, + * where is the id value of a card in the same project. + * @param {string} colId - the id value of a column in the same project. + * @param {Requestable.callback} cb - will receive true if the operation is successful + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'moveProjectCard', + value: function moveProjectCard(cardId, position, colId, cb) { + return this._request('POST', '/projects/columns/cards/' + cardId + '/moves', { position: position, column_id: colId }, // eslint-disable-line camelcase + cb); + } + }]); + + return Project; +}(_Requestable3.default); + +module.exports = Project; + +},{"./Requestable":9}],7:[function(require,module,exports){ +'use strict'; + +var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); + +var _Requestable2 = require('./Requestable'); + +var _Requestable3 = _interopRequireDefault(_Requestable2); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } + +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } /** + * @file + * @copyright 2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc. + * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}. + * Github.js is freely distributable. + */ + +/** + * RateLimit allows users to query their rate-limit status + */ +var RateLimit = function (_Requestable) { + _inherits(RateLimit, _Requestable); + + /** + * construct a RateLimit + * @param {Requestable.auth} auth - the credentials to authenticate to GitHub + * @param {string} [apiBase] - the base Github API URL + * @return {Promise} - the promise for the http request + */ + function RateLimit(auth, apiBase) { + _classCallCheck(this, RateLimit); + + return _possibleConstructorReturn(this, (RateLimit.__proto__ || Object.getPrototypeOf(RateLimit)).call(this, auth, apiBase)); + } + + /** + * Query the current rate limit + * @see https://developer.github.com/v3/rate_limit/ + * @param {Requestable.callback} [cb] - will receive the rate-limit data + * @return {Promise} - the promise for the http request + */ + + + _createClass(RateLimit, [{ + key: 'getRateLimit', + value: function getRateLimit(cb) { + return this._request('GET', '/rate_limit', null, cb); + } + }]); + + return RateLimit; +}(_Requestable3.default); + +module.exports = RateLimit; + +},{"./Requestable":9}],8:[function(require,module,exports){ +(function (Buffer){ +'use strict'; + +var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; + +var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); + +var _Requestable2 = require('./Requestable'); + +var _Requestable3 = _interopRequireDefault(_Requestable2); + +var _utf = require('utf8'); + +var _utf2 = _interopRequireDefault(_utf); + +var _jsBase = require('js-base64'); + +var _debug = require('debug'); + +var _debug2 = _interopRequireDefault(_debug); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } + +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } /** + * @file + * @copyright 2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc. + * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}. + * Github.js is freely distributable. + */ + +var log = (0, _debug2.default)('github:repository'); + +/** + * Respository encapsulates the functionality to create, query, and modify files. + */ + +var Repository = function (_Requestable) { + _inherits(Repository, _Requestable); + + /** + * Create a Repository. + * @param {string} fullname - the full name of the repository + * @param {Requestable.auth} [auth] - information required to authenticate to Github + * @param {string} [apiBase=https://api.github.com] - the base Github API URL + */ + function Repository(fullname, auth, apiBase) { + _classCallCheck(this, Repository); + + var _this = _possibleConstructorReturn(this, (Repository.__proto__ || Object.getPrototypeOf(Repository)).call(this, auth, apiBase)); + + _this.__fullname = fullname; + _this.__currentTree = { + branch: null, + sha: null + }; + return _this; + } + + /** + * Get a reference + * @see https://developer.github.com/v3/git/refs/#get-a-reference + * @param {string} ref - the reference to get + * @param {Requestable.callback} [cb] - will receive the reference's refSpec or a list of refSpecs that match `ref` + * @return {Promise} - the promise for the http request + */ + + + _createClass(Repository, [{ + key: 'getRef', + value: function getRef(ref, cb) { + return this._request('GET', '/repos/' + this.__fullname + '/git/refs/' + ref, null, cb); + } + + /** + * Create a reference + * @see https://developer.github.com/v3/git/refs/#create-a-reference + * @param {Object} options - the object describing the ref + * @param {Requestable.callback} [cb] - will receive the ref + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'createRef', + value: function createRef(options, cb) { + return this._request('POST', '/repos/' + this.__fullname + '/git/refs', options, cb); + } + + /** + * Delete a reference + * @see https://developer.github.com/v3/git/refs/#delete-a-reference + * @param {string} ref - the name of the ref to delte + * @param {Requestable.callback} [cb] - will receive true if the request is successful + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'deleteRef', + value: function deleteRef(ref, cb) { + return this._request('DELETE', '/repos/' + this.__fullname + '/git/refs/' + ref, null, cb); + } + + /** + * Delete a repository + * @see https://developer.github.com/v3/repos/#delete-a-repository + * @param {Requestable.callback} [cb] - will receive true if the request is successful + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'deleteRepo', + value: function deleteRepo(cb) { + return this._request('DELETE', '/repos/' + this.__fullname, null, cb); + } + + /** + * List the tags on a repository + * @see https://developer.github.com/v3/repos/#list-tags + * @param {Requestable.callback} [cb] - will receive the tag data + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'listTags', + value: function listTags(cb) { + return this._request('GET', '/repos/' + this.__fullname + '/tags', null, cb); + } + + /** + * List the open pull requests on the repository + * @see https://developer.github.com/v3/pulls/#list-pull-requests + * @param {Object} options - options to filter the search + * @param {Requestable.callback} [cb] - will receive the list of PRs + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'listPullRequests', + value: function listPullRequests(options, cb) { + options = options || {}; + return this._request('GET', '/repos/' + this.__fullname + '/pulls', options, cb); + } + + /** + * Get information about a specific pull request + * @see https://developer.github.com/v3/pulls/#get-a-single-pull-request + * @param {number} number - the PR you wish to fetch + * @param {Requestable.callback} [cb] - will receive the PR from the API + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'getPullRequest', + value: function getPullRequest(number, cb) { + return this._request('GET', '/repos/' + this.__fullname + '/pulls/' + number, null, cb); + } + + /** + * List the files of a specific pull request + * @see https://developer.github.com/v3/pulls/#list-pull-requests-files + * @param {number|string} number - the PR you wish to fetch + * @param {Requestable.callback} [cb] - will receive the list of files from the API + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'listPullRequestFiles', + value: function listPullRequestFiles(number, cb) { + return this._request('GET', '/repos/' + this.__fullname + '/pulls/' + number + '/files', null, cb); + } + + /** + * Compare two branches/commits/repositories + * @see https://developer.github.com/v3/repos/commits/#compare-two-commits + * @param {string} base - the base commit + * @param {string} head - the head commit + * @param {Requestable.callback} cb - will receive the comparison + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'compareBranches', + value: function compareBranches(base, head, cb) { + return this._request('GET', '/repos/' + this.__fullname + '/compare/' + base + '...' + head, null, cb); + } + + /** + * List all the branches for the repository + * @see https://developer.github.com/v3/repos/#list-branches + * @param {Requestable.callback} cb - will receive the list of branches + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'listBranches', + value: function listBranches(cb) { + return this._request('GET', '/repos/' + this.__fullname + '/branches', null, cb); + } + + /** + * Get a raw blob from the repository + * @see https://developer.github.com/v3/git/blobs/#get-a-blob + * @param {string} sha - the sha of the blob to fetch + * @param {Requestable.callback} cb - will receive the blob from the API + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'getBlob', + value: function getBlob(sha, cb) { + return this._request('GET', '/repos/' + this.__fullname + '/git/blobs/' + sha, null, cb, 'raw'); + } + + /** + * Get a single branch + * @see https://developer.github.com/v3/repos/branches/#get-branch + * @param {string} branch - the name of the branch to fetch + * @param {Requestable.callback} cb - will receive the branch from the API + * @returns {Promise} - the promise for the http request + */ + + }, { + key: 'getBranch', + value: function getBranch(branch, cb) { + return this._request('GET', '/repos/' + this.__fullname + '/branches/' + branch, null, cb); + } + + /** + * Get a commit from the repository + * @see https://developer.github.com/v3/repos/commits/#get-a-single-commit + * @param {string} sha - the sha for the commit to fetch + * @param {Requestable.callback} cb - will receive the commit data + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'getCommit', + value: function getCommit(sha, cb) { + return this._request('GET', '/repos/' + this.__fullname + '/git/commits/' + sha, null, cb); + } + + /** + * List the commits on a repository, optionally filtering by path, author or time range + * @see https://developer.github.com/v3/repos/commits/#list-commits-on-a-repository + * @param {Object} [options] - the filtering options for commits + * @param {string} [options.sha] - the SHA or branch to start from + * @param {string} [options.path] - the path to search on + * @param {string} [options.author] - the commit author + * @param {(Date|string)} [options.since] - only commits after this date will be returned + * @param {(Date|string)} [options.until] - only commits before this date will be returned + * @param {Requestable.callback} cb - will receive the list of commits found matching the criteria + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'listCommits', + value: function listCommits(options, cb) { + options = options || {}; + + options.since = this._dateToISO(options.since); + options.until = this._dateToISO(options.until); + + return this._request('GET', '/repos/' + this.__fullname + '/commits', options, cb); + } + + /** + * Gets a single commit information for a repository + * @see https://developer.github.com/v3/repos/commits/#get-a-single-commit + * @param {string} ref - the reference for the commit-ish + * @param {Requestable.callback} cb - will receive the commit information + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'getSingleCommit', + value: function getSingleCommit(ref, cb) { + ref = ref || ''; + return this._request('GET', '/repos/' + this.__fullname + '/commits/' + ref, null, cb); + } + + /** + * Get tha sha for a particular object in the repository. This is a convenience function + * @see https://developer.github.com/v3/repos/contents/#get-contents + * @param {string} [branch] - the branch to look in, or the repository's default branch if omitted + * @param {string} path - the path of the file or directory + * @param {Requestable.callback} cb - will receive a description of the requested object, including a `SHA` property + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'getSha', + value: function getSha(branch, path, cb) { + branch = branch ? '?ref=' + branch : ''; + return this._request('GET', '/repos/' + this.__fullname + '/contents/' + path + branch, null, cb); + } + + /** + * List the commit statuses for a particular sha, branch, or tag + * @see https://developer.github.com/v3/repos/statuses/#list-statuses-for-a-specific-ref + * @param {string} sha - the sha, branch, or tag to get statuses for + * @param {Requestable.callback} cb - will receive the list of statuses + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'listStatuses', + value: function listStatuses(sha, cb) { + return this._request('GET', '/repos/' + this.__fullname + '/commits/' + sha + '/statuses', null, cb); + } + + /** + * Get a description of a git tree + * @see https://developer.github.com/v3/git/trees/#get-a-tree + * @param {string} treeSHA - the SHA of the tree to fetch + * @param {Requestable.callback} cb - will receive the callback data + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'getTree', + value: function getTree(treeSHA, cb) { + return this._request('GET', '/repos/' + this.__fullname + '/git/trees/' + treeSHA, null, cb); + } + + /** + * Create a blob + * @see https://developer.github.com/v3/git/blobs/#create-a-blob + * @param {(string|Buffer|Blob)} content - the content to add to the repository + * @param {Requestable.callback} cb - will receive the details of the created blob + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'createBlob', + value: function createBlob(content, cb) { + var postBody = this._getContentObject(content); + + log('sending content', postBody); + return this._request('POST', '/repos/' + this.__fullname + '/git/blobs', postBody, cb); + } + + /** + * Get the object that represents the provided content + * @param {string|Buffer|Blob} content - the content to send to the server + * @return {Object} the representation of `content` for the GitHub API + */ + + }, { + key: '_getContentObject', + value: function _getContentObject(content) { + if (typeof content === 'string') { + log('contet is a string'); + return { + content: _utf2.default.encode(content), + encoding: 'utf-8' + }; + } else if (typeof Buffer !== 'undefined' && content instanceof Buffer) { + log('We appear to be in Node'); + return { + content: content.toString('base64'), + encoding: 'base64' + }; + } else if (typeof Blob !== 'undefined' && content instanceof Blob) { + log('We appear to be in the browser'); + return { + content: _jsBase.Base64.encode(content), + encoding: 'base64' + }; + } else { + // eslint-disable-line + log('Not sure what this content is: ' + (typeof content === 'undefined' ? 'undefined' : _typeof(content)) + ', ' + JSON.stringify(content)); + throw new Error('Unknown content passed to postBlob. Must be string or Buffer (node) or Blob (web)'); + } + } + + /** + * Update a tree in Git + * @see https://developer.github.com/v3/git/trees/#create-a-tree + * @param {string} baseTreeSHA - the SHA of the tree to update + * @param {string} path - the path for the new file + * @param {string} blobSHA - the SHA for the blob to put at `path` + * @param {Requestable.callback} cb - will receive the new tree that is created + * @return {Promise} - the promise for the http request + * @deprecated use {@link Repository#createTree} instead + */ + + }, { + key: 'updateTree', + value: function updateTree(baseTreeSHA, path, blobSHA, cb) { + var newTree = { + base_tree: baseTreeSHA, // eslint-disable-line + tree: [{ + path: path, + sha: blobSHA, + mode: '100644', + type: 'blob' + }] + }; + + return this._request('POST', '/repos/' + this.__fullname + '/git/trees', newTree, cb); + } + + /** + * Create a new tree in git + * @see https://developer.github.com/v3/git/trees/#create-a-tree + * @param {Object} tree - the tree to create + * @param {string} baseSHA - the root sha of the tree + * @param {Requestable.callback} cb - will receive the new tree that is created + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'createTree', + value: function createTree(tree, baseSHA, cb) { + return this._request('POST', '/repos/' + this.__fullname + '/git/trees', { + tree: tree, + base_tree: baseSHA }, cb); + } + + /** + * Add a commit to the repository + * @see https://developer.github.com/v3/git/commits/#create-a-commit + * @param {string} parent - the SHA of the parent commit + * @param {string} tree - the SHA of the tree for this commit + * @param {string} message - the commit message + * @param {Requestable.callback} cb - will receive the commit that is created + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'commit', + value: function commit(parent, tree, message, cb) { + var _this2 = this; + + var data = { + message: message, + tree: tree, + parents: [parent] + }; + + return this._request('POST', '/repos/' + this.__fullname + '/git/commits', data, cb).then(function (response) { + _this2.__currentTree.sha = response.data.sha; // Update latest commit + return response; + }); + } + + /** + * Update a ref + * @see https://developer.github.com/v3/git/refs/#update-a-reference + * @param {string} ref - the ref to update + * @param {string} commitSHA - the SHA to point the reference to + * @param {boolean} force - indicates whether to force or ensure a fast-forward update + * @param {Requestable.callback} cb - will receive the updated ref back + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'updateHead', + value: function updateHead(ref, commitSHA, force, cb) { + return this._request('PATCH', '/repos/' + this.__fullname + '/git/refs/' + ref, { + sha: commitSHA, + force: force + }, cb); + } + + /** + * Update commit status + * @see https://developer.github.com/v3/repos/statuses/ + * @param {string} commitSHA - the SHA of the commit that should be updated + * @param {object} options - Commit status parameters + * @param {string} options.state - The state of the status. Can be one of: pending, success, error, or failure. + * @param {string} [options.target_url] - The target URL to associate with this status. + * @param {string} [options.description] - A short description of the status. + * @param {string} [options.context] - A string label to differentiate this status among CI systems. + * @param {Requestable.callback} cb - will receive the updated commit back + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'updateStatus', + value: function updateStatus(commitSHA, options, cb) { + return this._request('POST', '/repos/' + this.__fullname + '/statuses/' + commitSHA, options, cb); + } + + /** + * Update repository information + * @see https://developer.github.com/v3/repos/#edit + * @param {object} options - New parameters that will be set to the repository + * @param {string} options.name - Name of the repository + * @param {string} [options.description] - A short description of the repository + * @param {string} [options.homepage] - A URL with more information about the repository + * @param {boolean} [options.private] - Either true to make the repository private, or false to make it public. + * @param {boolean} [options.has_issues] - Either true to enable issues for this repository, false to disable them. + * @param {boolean} [options.has_wiki] - Either true to enable the wiki for this repository, false to disable it. + * @param {boolean} [options.has_downloads] - Either true to enable downloads, false to disable them. + * @param {string} [options.default_branch] - Updates the default branch for this repository. + * @param {Requestable.callback} cb - will receive the updated repository back + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'updateRepository', + value: function updateRepository(options, cb) { + return this._request('PATCH', '/repos/' + this.__fullname, options, cb); + } + + /** + * Get information about the repository + * @see https://developer.github.com/v3/repos/#get + * @param {Requestable.callback} cb - will receive the information about the repository + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'getDetails', + value: function getDetails(cb) { + return this._request('GET', '/repos/' + this.__fullname, null, cb); + } + + /** + * List the contributors to the repository + * @see https://developer.github.com/v3/repos/#list-contributors + * @param {Requestable.callback} cb - will receive the list of contributors + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'getContributors', + value: function getContributors(cb) { + return this._request('GET', '/repos/' + this.__fullname + '/contributors', null, cb); + } + + /** + * List the contributor stats to the repository + * @see https://developer.github.com/v3/repos/#list-contributors + * @param {Requestable.callback} cb - will receive the list of contributors + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'getContributorStats', + value: function getContributorStats(cb) { + return this._request('GET', '/repos/' + this.__fullname + '/stats/contributors', null, cb); + } + + /** + * List the users who are collaborators on the repository. The currently authenticated user must have + * push access to use this method + * @see https://developer.github.com/v3/repos/collaborators/#list-collaborators + * @param {Requestable.callback} cb - will receive the list of collaborators + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'getCollaborators', + value: function getCollaborators(cb) { + return this._request('GET', '/repos/' + this.__fullname + '/collaborators', null, cb); + } + + /** + * Check if a user is a collaborator on the repository + * @see https://developer.github.com/v3/repos/collaborators/#check-if-a-user-is-a-collaborator + * @param {string} username - the user to check + * @param {Requestable.callback} cb - will receive true if the user is a collaborator and false if they are not + * @return {Promise} - the promise for the http request {Boolean} [description] + */ + + }, { + key: 'isCollaborator', + value: function isCollaborator(username, cb) { + return this._request('GET', '/repos/' + this.__fullname + '/collaborators/' + username, null, cb); + } + + /** + * Get the contents of a repository + * @see https://developer.github.com/v3/repos/contents/#get-contents + * @param {string} ref - the ref to check + * @param {string} path - the path containing the content to fetch + * @param {boolean} raw - `true` if the results should be returned raw instead of GitHub's normalized format + * @param {Requestable.callback} cb - will receive the fetched data + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'getContents', + value: function getContents(ref, path, raw, cb) { + path = path ? '' + encodeURI(path) : ''; + return this._request('GET', '/repos/' + this.__fullname + '/contents/' + path, { + ref: ref + }, cb, raw); + } + + /** + * Get the README of a repository + * @see https://developer.github.com/v3/repos/contents/#get-the-readme + * @param {string} ref - the ref to check + * @param {boolean} raw - `true` if the results should be returned raw instead of GitHub's normalized format + * @param {Requestable.callback} cb - will receive the fetched data + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'getReadme', + value: function getReadme(ref, raw, cb) { + return this._request('GET', '/repos/' + this.__fullname + '/readme', { + ref: ref + }, cb, raw); + } + + /** + * Fork a repository + * @see https://developer.github.com/v3/repos/forks/#create-a-fork + * @param {Requestable.callback} cb - will receive the information about the newly created fork + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'fork', + value: function fork(cb) { + return this._request('POST', '/repos/' + this.__fullname + '/forks', null, cb); + } + + /** + * List a repository's forks + * @see https://developer.github.com/v3/repos/forks/#list-forks + * @param {Requestable.callback} cb - will receive the list of repositories forked from this one + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'listForks', + value: function listForks(cb) { + return this._request('GET', '/repos/' + this.__fullname + '/forks', null, cb); + } + + /** + * Create a new branch from an existing branch. + * @param {string} [oldBranch=master] - the name of the existing branch + * @param {string} newBranch - the name of the new branch + * @param {Requestable.callback} cb - will receive the commit data for the head of the new branch + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'createBranch', + value: function createBranch(oldBranch, newBranch, cb) { + var _this3 = this; + + if (typeof newBranch === 'function') { + cb = newBranch; + newBranch = oldBranch; + oldBranch = 'master'; + } + + return this.getRef('heads/' + oldBranch).then(function (response) { + var sha = response.data.object.sha; + return _this3.createRef({ + sha: sha, + ref: 'refs/heads/' + newBranch + }, cb); + }); + } + + /** + * Create a new pull request + * @see https://developer.github.com/v3/pulls/#create-a-pull-request + * @param {Object} options - the pull request description + * @param {Requestable.callback} cb - will receive the new pull request + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'createPullRequest', + value: function createPullRequest(options, cb) { + return this._request('POST', '/repos/' + this.__fullname + '/pulls', options, cb); + } + + /** + * Update a pull request + * @see https://developer.github.com/v3/pulls/#update-a-pull-request + * @param {number|string} number - the number of the pull request to update + * @param {Object} options - the pull request description + * @param {Requestable.callback} [cb] - will receive the pull request information + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'updatePullRequest', + value: function updatePullRequest(number, options, cb) { + return this._request('PATCH', '/repos/' + this.__fullname + '/pulls/' + number, options, cb); + } + + /** + * List the hooks for the repository + * @see https://developer.github.com/v3/repos/hooks/#list-hooks + * @param {Requestable.callback} cb - will receive the list of hooks + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'listHooks', + value: function listHooks(cb) { + return this._request('GET', '/repos/' + this.__fullname + '/hooks', null, cb); + } + + /** + * Get a hook for the repository + * @see https://developer.github.com/v3/repos/hooks/#get-single-hook + * @param {number} id - the id of the webook + * @param {Requestable.callback} cb - will receive the details of the webook + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'getHook', + value: function getHook(id, cb) { + return this._request('GET', '/repos/' + this.__fullname + '/hooks/' + id, null, cb); + } + + /** + * Add a new hook to the repository + * @see https://developer.github.com/v3/repos/hooks/#create-a-hook + * @param {Object} options - the configuration describing the new hook + * @param {Requestable.callback} cb - will receive the new webhook + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'createHook', + value: function createHook(options, cb) { + return this._request('POST', '/repos/' + this.__fullname + '/hooks', options, cb); + } + + /** + * Edit an existing webhook + * @see https://developer.github.com/v3/repos/hooks/#edit-a-hook + * @param {number} id - the id of the webhook + * @param {Object} options - the new description of the webhook + * @param {Requestable.callback} cb - will receive the updated webhook + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'updateHook', + value: function updateHook(id, options, cb) { + return this._request('PATCH', '/repos/' + this.__fullname + '/hooks/' + id, options, cb); + } + + /** + * Delete a webhook + * @see https://developer.github.com/v3/repos/hooks/#delete-a-hook + * @param {number} id - the id of the webhook to be deleted + * @param {Requestable.callback} cb - will receive true if the call is successful + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'deleteHook', + value: function deleteHook(id, cb) { + return this._request('DELETE', '/repos/' + this.__fullname + '/hooks/' + id, null, cb); + } + + /** + * List the deploy keys for the repository + * @see https://developer.github.com/v3/repos/keys/#list-deploy-keys + * @param {Requestable.callback} cb - will receive the list of deploy keys + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'listKeys', + value: function listKeys(cb) { + return this._request('GET', '/repos/' + this.__fullname + '/keys', null, cb); + } + + /** + * Get a deploy key for the repository + * @see https://developer.github.com/v3/repos/keys/#get-a-deploy-key + * @param {number} id - the id of the deploy key + * @param {Requestable.callback} cb - will receive the details of the deploy key + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'getKey', + value: function getKey(id, cb) { + return this._request('GET', '/repos/' + this.__fullname + '/keys/' + id, null, cb); + } + + /** + * Add a new deploy key to the repository + * @see https://developer.github.com/v3/repos/keys/#add-a-new-deploy-key + * @param {Object} options - the configuration describing the new deploy key + * @param {Requestable.callback} cb - will receive the new deploy key + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'createKey', + value: function createKey(options, cb) { + return this._request('POST', '/repos/' + this.__fullname + '/keys', options, cb); + } + + /** + * Delete a deploy key + * @see https://developer.github.com/v3/repos/keys/#remove-a-deploy-key + * @param {number} id - the id of the deploy key to be deleted + * @param {Requestable.callback} cb - will receive true if the call is successful + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'deleteKey', + value: function deleteKey(id, cb) { + return this._request('DELETE', '/repos/' + this.__fullname + '/keys/' + id, null, cb); + } + + /** + * Delete a file from a branch + * @see https://developer.github.com/v3/repos/contents/#delete-a-file + * @param {string} branch - the branch to delete from, or the default branch if not specified + * @param {string} path - the path of the file to remove + * @param {Requestable.callback} cb - will receive the commit in which the delete occurred + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'deleteFile', + value: function deleteFile(branch, path, cb) { + var _this4 = this; + + return this.getSha(branch, path).then(function (response) { + var deleteCommit = { + message: 'Delete the file at \'' + path + '\'', + sha: response.data.sha, + branch: branch + }; + return _this4._request('DELETE', '/repos/' + _this4.__fullname + '/contents/' + path, deleteCommit, cb); + }); + } + + /** + * Change all references in a repo from oldPath to new_path + * @param {string} branch - the branch to carry out the reference change, or the default branch if not specified + * @param {string} oldPath - original path + * @param {string} newPath - new reference path + * @param {Requestable.callback} cb - will receive the commit in which the move occurred + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'move', + value: function move(branch, oldPath, newPath, cb) { + var _this5 = this; + + var oldSha = void 0; + return this.getRef('heads/' + branch).then(function (_ref) { + var object = _ref.data.object; + return _this5.getTree(object.sha + '?recursive=true'); + }).then(function (_ref2) { + var _ref2$data = _ref2.data, + tree = _ref2$data.tree, + sha = _ref2$data.sha; + + oldSha = sha; + var newTree = tree.map(function (ref) { + if (ref.path === oldPath) { + ref.path = newPath; + } + if (ref.type === 'tree') { + delete ref.sha; + } + return ref; + }); + return _this5.createTree(newTree); + }).then(function (_ref3) { + var tree = _ref3.data; + return _this5.commit(oldSha, tree.sha, 'Renamed \'' + oldPath + '\' to \'' + newPath + '\''); + }).then(function (_ref4) { + var commit = _ref4.data; + return _this5.updateHead('heads/' + branch, commit.sha, true, cb); + }); + } + + /** + * Write a file to the repository + * @see https://developer.github.com/v3/repos/contents/#update-a-file + * @param {string} branch - the name of the branch + * @param {string} path - the path for the file + * @param {string} content - the contents of the file + * @param {string} message - the commit message + * @param {Object} [options] - commit options + * @param {Object} [options.author] - the author of the commit + * @param {Object} [options.commiter] - the committer + * @param {boolean} [options.encode] - true if the content should be base64 encoded + * @param {Requestable.callback} cb - will receive the new commit + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'writeFile', + value: function writeFile(branch, path, content, message, options, cb) { + var _this6 = this; + + if (typeof options === 'function') { + cb = options; + options = {}; + } + var filePath = path ? encodeURI(path) : ''; + var shouldEncode = options.encode !== false; + var commit = { + branch: branch, + message: message, + author: options.author, + committer: options.committer, + content: shouldEncode ? _jsBase.Base64.encode(content) : content + }; + + return this.getSha(branch, filePath).then(function (response) { + commit.sha = response.data.sha; + return _this6._request('PUT', '/repos/' + _this6.__fullname + '/contents/' + filePath, commit, cb); + }, function () { + return _this6._request('PUT', '/repos/' + _this6.__fullname + '/contents/' + filePath, commit, cb); + }); + } + + /** + * Check if a repository is starred by you + * @see https://developer.github.com/v3/activity/starring/#check-if-you-are-starring-a-repository + * @param {Requestable.callback} cb - will receive true if the repository is starred and false if the repository + * is not starred + * @return {Promise} - the promise for the http request {Boolean} [description] + */ + + }, { + key: 'isStarred', + value: function isStarred(cb) { + return this._request204or404('/user/starred/' + this.__fullname, null, cb); + } + + /** + * Star a repository + * @see https://developer.github.com/v3/activity/starring/#star-a-repository + * @param {Requestable.callback} cb - will receive true if the repository is starred + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'star', + value: function star(cb) { + return this._request('PUT', '/user/starred/' + this.__fullname, null, cb); + } + + /** + * Unstar a repository + * @see https://developer.github.com/v3/activity/starring/#unstar-a-repository + * @param {Requestable.callback} cb - will receive true if the repository is unstarred + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'unstar', + value: function unstar(cb) { + return this._request('DELETE', '/user/starred/' + this.__fullname, null, cb); + } + + /** + * Create a new release + * @see https://developer.github.com/v3/repos/releases/#create-a-release + * @param {Object} options - the description of the release + * @param {Requestable.callback} cb - will receive the newly created release + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'createRelease', + value: function createRelease(options, cb) { + return this._request('POST', '/repos/' + this.__fullname + '/releases', options, cb); + } + + /** + * Edit a release + * @see https://developer.github.com/v3/repos/releases/#edit-a-release + * @param {string} id - the id of the release + * @param {Object} options - the description of the release + * @param {Requestable.callback} cb - will receive the modified release + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'updateRelease', + value: function updateRelease(id, options, cb) { + return this._request('PATCH', '/repos/' + this.__fullname + '/releases/' + id, options, cb); + } + + /** + * Get information about all releases + * @see https://developer.github.com/v3/repos/releases/#list-releases-for-a-repository + * @param {Requestable.callback} cb - will receive the release information + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'listReleases', + value: function listReleases(cb) { + return this._request('GET', '/repos/' + this.__fullname + '/releases', null, cb); + } + + /** + * Get information about a release + * @see https://developer.github.com/v3/repos/releases/#get-a-single-release + * @param {string} id - the id of the release + * @param {Requestable.callback} cb - will receive the release information + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'getRelease', + value: function getRelease(id, cb) { + return this._request('GET', '/repos/' + this.__fullname + '/releases/' + id, null, cb); + } + + /** + * Delete a release + * @see https://developer.github.com/v3/repos/releases/#delete-a-release + * @param {string} id - the release to be deleted + * @param {Requestable.callback} cb - will receive true if the operation is successful + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'deleteRelease', + value: function deleteRelease(id, cb) { + return this._request('DELETE', '/repos/' + this.__fullname + '/releases/' + id, null, cb); + } + + /** + * Merge a pull request + * @see https://developer.github.com/v3/pulls/#merge-a-pull-request-merge-button + * @param {number|string} number - the number of the pull request to merge + * @param {Object} options - the merge options for the pull request + * @param {Requestable.callback} [cb] - will receive the merge information if the operation is successful + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'mergePullRequest', + value: function mergePullRequest(number, options, cb) { + return this._request('PUT', '/repos/' + this.__fullname + '/pulls/' + number + '/merge', options, cb); + } + + /** + * Get information about all projects + * @see https://developer.github.com/v3/projects/#list-repository-projects + * @param {Requestable.callback} [cb] - will receive the list of projects + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'listProjects', + value: function listProjects(cb) { + return this._requestAllPages('/repos/' + this.__fullname + '/projects', { AcceptHeader: 'inertia-preview' }, cb); + } + + /** + * Create a new project + * @see https://developer.github.com/v3/projects/#create-a-repository-project + * @param {Object} options - the description of the project + * @param {Requestable.callback} cb - will receive the newly created project + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'createProject', + value: function createProject(options, cb) { + options = options || {}; + options.AcceptHeader = 'inertia-preview'; + return this._request('POST', '/repos/' + this.__fullname + '/projects', options, cb); + } + }]); + + return Repository; +}(_Requestable3.default); + +module.exports = Repository; + +}).call(this,require("buffer").Buffer) + +},{"./Requestable":9,"buffer":undefined,"debug":undefined,"js-base64":undefined,"utf8":undefined}],9:[function(require,module,exports){ +'use strict'; + +var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; + +var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); + +var _axios = require('axios'); + +var _axios2 = _interopRequireDefault(_axios); + +var _debug = require('debug'); + +var _debug2 = _interopRequireDefault(_debug); + +var _jsBase = require('js-base64'); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +function _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } } + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } + +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } /** + * @file + * @copyright 2016 Yahoo Inc. + * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}. + * Github.js is freely distributable. + */ + +var log = (0, _debug2.default)('github:request'); + +/** + * The error structure returned when a network call fails + */ + +var ResponseError = function (_Error) { + _inherits(ResponseError, _Error); + + /** + * Construct a new ResponseError + * @param {string} message - an message to return instead of the the default error message + * @param {string} path - the requested path + * @param {Object} response - the object returned by Axios + */ + function ResponseError(message, path, response) { + _classCallCheck(this, ResponseError); + + var _this = _possibleConstructorReturn(this, (ResponseError.__proto__ || Object.getPrototypeOf(ResponseError)).call(this, message)); + + _this.path = path; + _this.request = response.config; + _this.response = (response || {}).response || response; + _this.status = response.status; + return _this; + } + + return ResponseError; +}(Error); + +/** + * Requestable wraps the logic for making http requests to the API + */ + + +var Requestable = function () { + /** + * Either a username and password or an oauth token for Github + * @typedef {Object} Requestable.auth + * @prop {string} [username] - the Github username + * @prop {string} [password] - the user's password + * @prop {token} [token] - an OAuth token + */ + /** + * Initialize the http internals. + * @param {Requestable.auth} [auth] - the credentials to authenticate to Github. If auth is + * not provided request will be made unauthenticated + * @param {string} [apiBase=https://api.github.com] - the base Github API URL + * @param {string} [AcceptHeader=v3] - the accept header for the requests + */ + function Requestable(auth, apiBase, AcceptHeader) { + _classCallCheck(this, Requestable); + + this.__apiBase = apiBase || 'https://api.github.com'; + this.__auth = { + token: auth.token, + username: auth.username, + password: auth.password + }; + this.__AcceptHeader = AcceptHeader || 'v3'; + + if (auth.token) { + this.__authorizationHeader = 'token ' + auth.token; + } else if (auth.username && auth.password) { + this.__authorizationHeader = 'Basic ' + _jsBase.Base64.encode(auth.username + ':' + auth.password); + } + } + + /** + * Compute the URL to use to make a request. + * @private + * @param {string} path - either a URL relative to the API base or an absolute URL + * @return {string} - the URL to use + */ + + + _createClass(Requestable, [{ + key: '__getURL', + value: function __getURL(path) { + var url = path; + + if (path.indexOf('//') === -1) { + url = this.__apiBase + path; + } + + var newCacheBuster = 'timestamp=' + new Date().getTime(); + return url.replace(/(timestamp=\d+)/, newCacheBuster); + } + + /** + * Compute the headers required for an API request. + * @private + * @param {boolean} raw - if the request should be treated as JSON or as a raw request + * @param {string} AcceptHeader - the accept header for the request + * @return {Object} - the headers to use in the request + */ + + }, { + key: '__getRequestHeaders', + value: function __getRequestHeaders(raw, AcceptHeader) { + var headers = { + 'Content-Type': 'application/json;charset=UTF-8', + 'Accept': 'application/vnd.github.' + (AcceptHeader || this.__AcceptHeader) + }; + + if (raw) { + headers.Accept += '.raw'; + } + headers.Accept += '+json'; + + if (this.__authorizationHeader) { + headers.Authorization = this.__authorizationHeader; + } + + return headers; + } + + /** + * Sets the default options for API requests + * @protected + * @param {Object} [requestOptions={}] - the current options for the request + * @return {Object} - the options to pass to the request + */ + + }, { + key: '_getOptionsWithDefaults', + value: function _getOptionsWithDefaults() { + var requestOptions = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {}; + + if (!(requestOptions.visibility || requestOptions.affiliation)) { + requestOptions.type = requestOptions.type || 'all'; + } + requestOptions.sort = requestOptions.sort || 'updated'; + requestOptions.per_page = requestOptions.per_page || '100'; // eslint-disable-line + + return requestOptions; + } + + /** + * if a `Date` is passed to this function it will be converted to an ISO string + * @param {*} date - the object to attempt to cooerce into an ISO date string + * @return {string} - the ISO representation of `date` or whatever was passed in if it was not a date + */ + + }, { + key: '_dateToISO', + value: function _dateToISO(date) { + if (date && date instanceof Date) { + date = date.toISOString(); + } + + return date; + } + + /** + * A function that receives the result of the API request. + * @callback Requestable.callback + * @param {Requestable.Error} error - the error returned by the API or `null` + * @param {(Object|true)} result - the data returned by the API or `true` if the API returns `204 No Content` + * @param {Object} request - the raw {@linkcode https://github.com/mzabriskie/axios#response-schema Response} + */ + /** + * Make a request. + * @param {string} method - the method for the request (GET, PUT, POST, DELETE) + * @param {string} path - the path for the request + * @param {*} [data] - the data to send to the server. For HTTP methods that don't have a body the data + * will be sent as query parameters + * @param {Requestable.callback} [cb] - the callback for the request + * @param {boolean} [raw=false] - if the request should be sent as raw. If this is a falsy value then the + * request will be made as JSON + * @return {Promise} - the Promise for the http request + */ + + }, { + key: '_request', + value: function _request(method, path, data, cb, raw) { + var url = this.__getURL(path); + + var AcceptHeader = (data || {}).AcceptHeader; + if (AcceptHeader) { + delete data.AcceptHeader; + } + var headers = this.__getRequestHeaders(raw, AcceptHeader); + + var queryParams = {}; + + var shouldUseDataAsParams = data && (typeof data === 'undefined' ? 'undefined' : _typeof(data)) === 'object' && methodHasNoBody(method); + if (shouldUseDataAsParams) { + queryParams = data; + data = undefined; + } + + var config = { + url: url, + method: method, + headers: headers, + params: queryParams, + data: data, + responseType: raw ? 'text' : 'json' + }; + + log(config.method + ' to ' + config.url); + var requestPromise = (0, _axios2.default)(config).catch(callbackErrorOrThrow(cb, path)); + + if (cb) { + requestPromise.then(function (response) { + if (response.data && Object.keys(response.data).length > 0) { + // When data has results + cb(null, response.data, response); + } else if (config.method !== 'GET' && Object.keys(response.data).length < 1) { + // True when successful submit a request and receive a empty object + cb(null, response.status < 300, response); + } else { + cb(null, response.data, response); + } + }); + } + + return requestPromise; + } + + /** + * Make a request to an endpoint the returns 204 when true and 404 when false + * @param {string} path - the path to request + * @param {Object} data - any query parameters for the request + * @param {Requestable.callback} cb - the callback that will receive `true` or `false` + * @param {method} [method=GET] - HTTP Method to use + * @return {Promise} - the promise for the http request + */ + + }, { + key: '_request204or404', + value: function _request204or404(path, data, cb) { + var method = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 'GET'; + + return this._request(method, path, data).then(function success(response) { + if (cb) { + cb(null, true, response); + } + return true; + }, function failure(response) { + if (response.response.status === 404) { + if (cb) { + cb(null, false, response); + } + return false; + } + + if (cb) { + cb(response); + } + throw response; + }); + } + + /** + * Make a request and fetch all the available data. Github will paginate responses so for queries + * that might span multiple pages this method is preferred to {@link Requestable#request} + * @param {string} path - the path to request + * @param {Object} options - the query parameters to include + * @param {Requestable.callback} [cb] - the function to receive the data. The returned data will always be an array. + * @param {Object[]} results - the partial results. This argument is intended for interal use only. + * @return {Promise} - a promise which will resolve when all pages have been fetched + * @deprecated This will be folded into {@link Requestable#_request} in the 2.0 release. + */ + + }, { + key: '_requestAllPages', + value: function _requestAllPages(path, options, cb, results) { + var _this2 = this; + + results = results || []; + + return this._request('GET', path, options).then(function (response) { + var _results; + + var thisGroup = void 0; + if (response.data instanceof Array) { + thisGroup = response.data; + } else if (response.data.items instanceof Array) { + thisGroup = response.data.items; + } else { + var message = 'cannot figure out how to append ' + response.data + ' to the result set'; + throw new ResponseError(message, path, response); + } + (_results = results).push.apply(_results, _toConsumableArray(thisGroup)); + + var nextUrl = getNextPage(response.headers.link); + if (nextUrl && typeof options.page !== 'number') { + log('getting next page: ' + nextUrl); + return _this2._requestAllPages(nextUrl, options, cb, results); + } + + if (cb) { + cb(null, results, response); + } + + response.data = results; + return response; + }).catch(callbackErrorOrThrow(cb, path)); + } + }]); + + return Requestable; +}(); + +module.exports = Requestable; + +// ////////////////////////// // +// Private helper functions // +// ////////////////////////// // +var METHODS_WITH_NO_BODY = ['GET', 'HEAD', 'DELETE']; +function methodHasNoBody(method) { + return METHODS_WITH_NO_BODY.indexOf(method) !== -1; +} + +function getNextPage() { + var linksHeader = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : ''; + + var links = linksHeader.split(/\s*,\s*/); // splits and strips the urls + return links.reduce(function (nextUrl, link) { + if (link.search(/rel="next"/) !== -1) { + return (link.match(/<(.*)>/) || [])[1]; + } + + return nextUrl; + }, undefined); +} + +function callbackErrorOrThrow(cb, path) { + return function handler(object) { + var error = void 0; + if (object.hasOwnProperty('config')) { + var _object$response = object.response, + status = _object$response.status, + statusText = _object$response.statusText, + _object$config = object.config, + method = _object$config.method, + url = _object$config.url; + + var message = status + ' error making request ' + method + ' ' + url + ': "' + statusText + '"'; + error = new ResponseError(message, path, object); + log(message + ' ' + JSON.stringify(object.data)); + } else { + error = object; + } + if (cb) { + log('going to error callback'); + cb(error); + } else { + log('throwing error'); + throw error; + } + }; +} + +},{"axios":undefined,"debug":undefined,"js-base64":undefined}],10:[function(require,module,exports){ +'use strict'; + +var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); + +var _Requestable2 = require('./Requestable'); + +var _Requestable3 = _interopRequireDefault(_Requestable2); + +var _debug = require('debug'); + +var _debug2 = _interopRequireDefault(_debug); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } + +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } /** + * @file + * @copyright 2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc. + * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}. + * Github.js is freely distributable. + */ + +var log = (0, _debug2.default)('github:search'); + +/** + * Wrap the Search API + */ + +var Search = function (_Requestable) { + _inherits(Search, _Requestable); + + /** + * Create a Search + * @param {Object} defaults - defaults for the search + * @param {Requestable.auth} [auth] - information required to authenticate to Github + * @param {string} [apiBase=https://api.github.com] - the base Github API URL + */ + function Search(defaults, auth, apiBase) { + _classCallCheck(this, Search); + + var _this = _possibleConstructorReturn(this, (Search.__proto__ || Object.getPrototypeOf(Search)).call(this, auth, apiBase)); + + _this.__defaults = _this._getOptionsWithDefaults(defaults); + return _this; + } + + /** + * Available search options + * @see https://developer.github.com/v3/search/#parameters + * @typedef {Object} Search.Params + * @param {string} q - the query to make + * @param {string} sort - the sort field, one of `stars`, `forks`, or `updated`. + * Default is [best match](https://developer.github.com/v3/search/#ranking-search-results) + * @param {string} order - the ordering, either `asc` or `desc` + */ + /** + * Perform a search on the GitHub API + * @private + * @param {string} path - the scope of the search + * @param {Search.Params} [withOptions] - additional parameters for the search + * @param {Requestable.callback} [cb] - will receive the results of the search + * @return {Promise} - the promise for the http request + */ + + + _createClass(Search, [{ + key: '_search', + value: function _search(path) { + var _this2 = this; + + var withOptions = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; + var cb = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : undefined; + + var requestOptions = {}; + Object.keys(this.__defaults).forEach(function (prop) { + requestOptions[prop] = _this2.__defaults[prop]; + }); + Object.keys(withOptions).forEach(function (prop) { + requestOptions[prop] = withOptions[prop]; + }); + + log('searching ' + path + ' with options:', requestOptions); + return this._requestAllPages('/search/' + path, requestOptions, cb); + } + + /** + * Search for repositories + * @see https://developer.github.com/v3/search/#search-repositories + * @param {Search.Params} [options] - additional parameters for the search + * @param {Requestable.callback} [cb] - will receive the results of the search + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'forRepositories', + value: function forRepositories(options, cb) { + return this._search('repositories', options, cb); + } + + /** + * Search for code + * @see https://developer.github.com/v3/search/#search-code + * @param {Search.Params} [options] - additional parameters for the search + * @param {Requestable.callback} [cb] - will receive the results of the search + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'forCode', + value: function forCode(options, cb) { + return this._search('code', options, cb); + } + + /** + * Search for issues + * @see https://developer.github.com/v3/search/#search-issues + * @param {Search.Params} [options] - additional parameters for the search + * @param {Requestable.callback} [cb] - will receive the results of the search + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'forIssues', + value: function forIssues(options, cb) { + return this._search('issues', options, cb); + } + + /** + * Search for users + * @see https://developer.github.com/v3/search/#search-users + * @param {Search.Params} [options] - additional parameters for the search + * @param {Requestable.callback} [cb] - will receive the results of the search + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'forUsers', + value: function forUsers(options, cb) { + return this._search('users', options, cb); + } + }]); + + return Search; +}(_Requestable3.default); + +module.exports = Search; + +},{"./Requestable":9,"debug":undefined}],11:[function(require,module,exports){ +'use strict'; + +var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); + +var _Requestable2 = require('./Requestable'); + +var _Requestable3 = _interopRequireDefault(_Requestable2); + +var _debug = require('debug'); + +var _debug2 = _interopRequireDefault(_debug); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } + +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } /** + * @file + * @copyright 2016 Matt Smith (Development Seed) + * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}. + * Github.js is freely distributable. + */ + +var log = (0, _debug2.default)('github:team'); + +/** + * A Team allows scoping of API requests to a particular Github Organization Team. + */ + +var Team = function (_Requestable) { + _inherits(Team, _Requestable); + + /** + * Create a Team. + * @param {string} [teamId] - the id for the team + * @param {Requestable.auth} [auth] - information required to authenticate to Github + * @param {string} [apiBase=https://api.github.com] - the base Github API URL + */ + function Team(teamId, auth, apiBase) { + _classCallCheck(this, Team); + + var _this = _possibleConstructorReturn(this, (Team.__proto__ || Object.getPrototypeOf(Team)).call(this, auth, apiBase)); + + _this.__teamId = teamId; + return _this; + } + + /** + * Get Team information + * @see https://developer.github.com/v3/orgs/teams/#get-team + * @param {Requestable.callback} [cb] - will receive the team + * @return {Promise} - the promise for the http request + */ + + + _createClass(Team, [{ + key: 'getTeam', + value: function getTeam(cb) { + log('Fetching Team ' + this.__teamId); + return this._request('Get', '/teams/' + this.__teamId, undefined, cb); + } + + /** + * List the Team's repositories + * @see https://developer.github.com/v3/orgs/teams/#list-team-repos + * @param {Requestable.callback} [cb] - will receive the list of repositories + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'listRepos', + value: function listRepos(cb) { + log('Fetching repositories for Team ' + this.__teamId); + return this._requestAllPages('/teams/' + this.__teamId + '/repos', undefined, cb); + } + + /** + * Edit Team information + * @see https://developer.github.com/v3/orgs/teams/#edit-team + * @param {object} options - Parameters for team edit + * @param {string} options.name - The name of the team + * @param {string} [options.description] - Team description + * @param {string} [options.repo_names] - Repos to add the team to + * @param {string} [options.privacy=secret] - The level of privacy the team should have. Can be either one + * of: `secret`, or `closed` + * @param {Requestable.callback} [cb] - will receive the updated team + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'editTeam', + value: function editTeam(options, cb) { + log('Editing Team ' + this.__teamId); + return this._request('PATCH', '/teams/' + this.__teamId, options, cb); + } + + /** + * List the users who are members of the Team + * @see https://developer.github.com/v3/orgs/teams/#list-team-members + * @param {object} options - Parameters for listing team users + * @param {string} [options.role=all] - can be one of: `all`, `maintainer`, or `member` + * @param {Requestable.callback} [cb] - will receive the list of users + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'listMembers', + value: function listMembers(options, cb) { + log('Getting members of Team ' + this.__teamId); + return this._requestAllPages('/teams/' + this.__teamId + '/members', options, cb); + } + + /** + * Get Team membership status for a user + * @see https://developer.github.com/v3/orgs/teams/#get-team-membership + * @param {string} username - can be one of: `all`, `maintainer`, or `member` + * @param {Requestable.callback} [cb] - will receive the membership status of a user + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'getMembership', + value: function getMembership(username, cb) { + log('Getting membership of user ' + username + ' in Team ' + this.__teamId); + return this._request('GET', '/teams/' + this.__teamId + '/memberships/' + username, undefined, cb); + } + + /** + * Add a member to the Team + * @see https://developer.github.com/v3/orgs/teams/#add-team-membership + * @param {string} username - can be one of: `all`, `maintainer`, or `member` + * @param {object} options - Parameters for adding a team member + * @param {string} [options.role=member] - The role that this user should have in the team. Can be one + * of: `member`, or `maintainer` + * @param {Requestable.callback} [cb] - will receive the membership status of added user + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'addMembership', + value: function addMembership(username, options, cb) { + log('Adding user ' + username + ' to Team ' + this.__teamId); + return this._request('PUT', '/teams/' + this.__teamId + '/memberships/' + username, options, cb); + } + + /** + * Get repo management status for team + * @see https://developer.github.com/v3/orgs/teams/#remove-team-membership + * @param {string} owner - Organization name + * @param {string} repo - Repo name + * @param {Requestable.callback} [cb] - will receive the membership status of added user + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'isManagedRepo', + value: function isManagedRepo(owner, repo, cb) { + log('Getting repo management by Team ' + this.__teamId + ' for repo ' + owner + '/' + repo); + return this._request204or404('/teams/' + this.__teamId + '/repos/' + owner + '/' + repo, undefined, cb); + } + + /** + * Add or Update repo management status for team + * @see https://developer.github.com/v3/orgs/teams/#add-or-update-team-repository + * @param {string} owner - Organization name + * @param {string} repo - Repo name + * @param {object} options - Parameters for adding or updating repo management for the team + * @param {string} [options.permission] - The permission to grant the team on this repository. Can be one + * of: `pull`, `push`, or `admin` + * @param {Requestable.callback} [cb] - will receive the membership status of added user + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'manageRepo', + value: function manageRepo(owner, repo, options, cb) { + log('Adding or Updating repo management by Team ' + this.__teamId + ' for repo ' + owner + '/' + repo); + return this._request204or404('/teams/' + this.__teamId + '/repos/' + owner + '/' + repo, options, cb, 'PUT'); + } + + /** + * Remove repo management status for team + * @see https://developer.github.com/v3/orgs/teams/#remove-team-repository + * @param {string} owner - Organization name + * @param {string} repo - Repo name + * @param {Requestable.callback} [cb] - will receive the membership status of added user + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'unmanageRepo', + value: function unmanageRepo(owner, repo, cb) { + log('Remove repo management by Team ' + this.__teamId + ' for repo ' + owner + '/' + repo); + return this._request204or404('/teams/' + this.__teamId + '/repos/' + owner + '/' + repo, undefined, cb, 'DELETE'); + } + + /** + * Delete Team + * @see https://developer.github.com/v3/orgs/teams/#delete-team + * @param {Requestable.callback} [cb] - will receive the list of repositories + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'deleteTeam', + value: function deleteTeam(cb) { + log('Deleting Team ' + this.__teamId); + return this._request204or404('/teams/' + this.__teamId, undefined, cb, 'DELETE'); + } + }]); + + return Team; +}(_Requestable3.default); + +module.exports = Team; + +},{"./Requestable":9,"debug":undefined}],12:[function(require,module,exports){ +'use strict'; + +var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); + +var _Requestable2 = require('./Requestable'); + +var _Requestable3 = _interopRequireDefault(_Requestable2); + +var _debug = require('debug'); + +var _debug2 = _interopRequireDefault(_debug); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } + +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } /** + * @file + * @copyright 2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc. + * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}. + * Github.js is freely distributable. + */ + +var log = (0, _debug2.default)('github:user'); + +/** + * A User allows scoping of API requests to a particular Github user. + */ + +var User = function (_Requestable) { + _inherits(User, _Requestable); + + /** + * Create a User. + * @param {string} [username] - the user to use for user-scoped queries + * @param {Requestable.auth} [auth] - information required to authenticate to Github + * @param {string} [apiBase=https://api.github.com] - the base Github API URL + */ + function User(username, auth, apiBase) { + _classCallCheck(this, User); + + var _this = _possibleConstructorReturn(this, (User.__proto__ || Object.getPrototypeOf(User)).call(this, auth, apiBase)); + + _this.__user = username; + return _this; + } + + /** + * Get the url for the request. (dependent on if we're requesting for the authenticated user or not) + * @private + * @param {string} endpoint - the endpoint being requested + * @return {string} - the resolved endpoint + */ + + + _createClass(User, [{ + key: '__getScopedUrl', + value: function __getScopedUrl(endpoint) { + if (this.__user) { + return endpoint ? '/users/' + this.__user + '/' + endpoint : '/users/' + this.__user; + } else { + // eslint-disable-line + switch (endpoint) { + case '': + return '/user'; + + case 'notifications': + case 'gists': + return '/' + endpoint; + + default: + return '/user/' + endpoint; + } + } + } + + /** + * List the user's repositories + * @see https://developer.github.com/v3/repos/#list-user-repositories + * @param {Object} [options={}] - any options to refine the search + * @param {Requestable.callback} [cb] - will receive the list of repositories + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'listRepos', + value: function listRepos(options, cb) { + if (typeof options === 'function') { + cb = options; + options = {}; + } + + options = this._getOptionsWithDefaults(options); + + log('Fetching repositories with options: ' + JSON.stringify(options)); + return this._requestAllPages(this.__getScopedUrl('repos'), options, cb); + } + + /** + * List the orgs that the user belongs to + * @see https://developer.github.com/v3/orgs/#list-user-organizations + * @param {Requestable.callback} [cb] - will receive the list of organizations + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'listOrgs', + value: function listOrgs(cb) { + return this._request('GET', this.__getScopedUrl('orgs'), null, cb); + } + + /** + * List the user's gists + * @see https://developer.github.com/v3/gists/#list-a-users-gists + * @param {Requestable.callback} [cb] - will receive the list of gists + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'listGists', + value: function listGists(cb) { + return this._request('GET', this.__getScopedUrl('gists'), null, cb); + } + + /** + * List the user's starred gists + * @see https://developer.github.com/v3/gists/#list-starred-gists + * @param {Requestable.callback} [cb] - will receive the list of gists + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'listStarredGists', + value: function listStarredGists(cb) { + return this._request('GET', this.__getScopedUrl('gists/starred'), null, cb); + } + + /** + * List the user's gists + * @see https://developer.github.com/v3/gists/#list-a-users-gists + * @param {Requestable.callback} [cb] - will receive the list of gists + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'listStarredGists', + value: function listStarredGists(cb) { + return this._request('GET', this.__getScopedUrl('gists'), null, cb); + } + + /** + * List the user's notifications + * @see https://developer.github.com/v3/activity/notifications/#list-your-notifications + * @param {Object} [options={}] - any options to refine the search + * @param {Requestable.callback} [cb] - will receive the list of repositories + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'listNotifications', + value: function listNotifications(options, cb) { + options = options || {}; + if (typeof options === 'function') { + cb = options; + options = {}; + } + + options.since = this._dateToISO(options.since); + options.before = this._dateToISO(options.before); + + return this._request('GET', this.__getScopedUrl('notifications'), options, cb); + } + + /** + * Show the user's profile + * @see https://developer.github.com/v3/users/#get-a-single-user + * @param {Requestable.callback} [cb] - will receive the user's information + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'getProfile', + value: function getProfile(cb) { + return this._request('GET', this.__getScopedUrl(''), null, cb); + } + + /** + * Gets the list of starred repositories for the user + * @see https://developer.github.com/v3/activity/starring/#list-repositories-being-starred + * @param {Requestable.callback} [cb] - will receive the list of starred repositories + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'listStarredRepos', + value: function listStarredRepos(cb) { + var requestOptions = this._getOptionsWithDefaults(); + return this._requestAllPages(this.__getScopedUrl('starred'), requestOptions, cb); + } + + /** + * List email addresses for a user + * @see https://developer.github.com/v3/users/emails/#list-email-addresses-for-a-user + * @param {Requestable.callback} [cb] - will receive the list of emails + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'getEmails', + value: function getEmails(cb) { + return this._request('GET', '/user/emails', null, cb); + } + + /** + * Have the authenticated user follow this user + * @see https://developer.github.com/v3/users/followers/#follow-a-user + * @param {string} username - the user to follow + * @param {Requestable.callback} [cb] - will receive true if the request succeeds + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'follow', + value: function follow(username, cb) { + return this._request('PUT', '/user/following/' + this.__user, null, cb); + } + + /** + * Have the currently authenticated user unfollow this user + * @see https://developer.github.com/v3/users/followers/#follow-a-user + * @param {string} username - the user to unfollow + * @param {Requestable.callback} [cb] - receives true if the request succeeds + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'unfollow', + value: function unfollow(username, cb) { + return this._request('DELETE', '/user/following/' + this.__user, null, cb); + } + + /** + * Create a new repository for the currently authenticated user + * @see https://developer.github.com/v3/repos/#create + * @param {object} options - the repository definition + * @param {Requestable.callback} [cb] - will receive the API response + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'createRepo', + value: function createRepo(options, cb) { + return this._request('POST', '/user/repos', options, cb); + } + }]); + + return User; +}(_Requestable3.default); + +module.exports = User; + +},{"./Requestable":9,"debug":undefined}]},{},[2])(2) +}); + +//# sourceMappingURL=GitHub.js.map diff --git a/dist/GitHub.js.map b/dist/GitHub.js.map new file mode 100644 index 00000000..531325c9 --- /dev/null +++ b/dist/GitHub.js.map @@ -0,0 +1 @@ +{"version":3,"sources":["node_modules/browser-pack/_prelude.js","lib/Gist.js","lib/GitHub.js","lib/Issue.js","lib/Markdown.js","lib/Organization.js","lib/Project.js","lib/RateLimit.js","lib/Repository.js","lib/Requestable.js","lib/Search.js","lib/Team.js","lib/User.js"],"names":[],"mappings":"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","file":"GitHub.js","sourcesContent":["(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require==\"function\"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error(\"Cannot find module '\"+o+\"'\");throw f.code=\"MODULE_NOT_FOUND\",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require==\"function\"&&require;for(var o=0;o {\n this.__id = response.data.id;\n return response;\n });\n }\n\n /**\n * Delete a gist.\n * @see https://developer.github.com/v3/gists/#delete-a-gist\n * @param {Requestable.callback} [cb] - will receive true if the request succeeds\n * @return {Promise} - the Promise for the http request\n */\n delete(cb) {\n return this._request('DELETE', `/gists/${this.__id}`, null, cb);\n }\n\n /**\n * Fork a gist.\n * @see https://developer.github.com/v3/gists/#fork-a-gist\n * @param {Requestable.callback} [cb] - the function that will receive the gist\n * @return {Promise} - the Promise for the http request\n */\n fork(cb) {\n return this._request('POST', `/gists/${this.__id}/forks`, null, cb);\n }\n\n /**\n * Update a gist.\n * @see https://developer.github.com/v3/gists/#edit-a-gist\n * @param {Object} gist - the new data for the gist\n * @param {Requestable.callback} [cb] - the function that receives the API result\n * @return {Promise} - the Promise for the http request\n */\n update(gist, cb) {\n return this._request('PATCH', `/gists/${this.__id}`, gist, cb);\n }\n\n /**\n * Star a gist.\n * @see https://developer.github.com/v3/gists/#star-a-gist\n * @param {Requestable.callback} [cb] - will receive true if the request is successful\n * @return {Promise} - the Promise for the http request\n */\n star(cb) {\n return this._request('PUT', `/gists/${this.__id}/star`, null, cb);\n }\n\n /**\n * Unstar a gist.\n * @see https://developer.github.com/v3/gists/#unstar-a-gist\n * @param {Requestable.callback} [cb] - will receive true if the request is successful\n * @return {Promise} - the Promise for the http request\n */\n unstar(cb) {\n return this._request('DELETE', `/gists/${this.__id}/star`, null, cb);\n }\n\n /**\n * Check if a gist is starred by the user.\n * @see https://developer.github.com/v3/gists/#check-if-a-gist-is-starred\n * @param {Requestable.callback} [cb] - will receive true if the gist is starred and false if the gist is not starred\n * @return {Promise} - the Promise for the http request\n */\n isStarred(cb) {\n return this._request204or404(`/gists/${this.__id}/star`, null, cb);\n }\n\n /**\n * List the gist's commits\n * @see https://developer.github.com/v3/gists/#list-gist-commits\n * @param {Requestable.callback} [cb] - will receive the array of commits\n * @return {Promise} - the Promise for the http request\n */\n listCommits(cb) {\n return this._requestAllPages(`/gists/${this.__id}/commits`, null, cb);\n }\n\n /**\n * Fetch one of the gist's revision.\n * @see https://developer.github.com/v3/gists/#get-a-specific-revision-of-a-gist\n * @param {string} revision - the id of the revision\n * @param {Requestable.callback} [cb] - will receive the revision\n * @return {Promise} - the Promise for the http request\n */\n getRevision(revision, cb) {\n return this._request('GET', `/gists/${this.__id}/${revision}`, null, cb);\n }\n\n /**\n * List the gist's comments\n * @see https://developer.github.com/v3/gists/comments/#list-comments-on-a-gist\n * @param {Requestable.callback} [cb] - will receive the array of comments\n * @return {Promise} - the promise for the http request\n */\n listComments(cb) {\n return this._requestAllPages(`/gists/${this.__id}/comments`, null, cb);\n }\n\n /**\n * Fetch one of the gist's comments\n * @see https://developer.github.com/v3/gists/comments/#get-a-single-comment\n * @param {number} comment - the id of the comment\n * @param {Requestable.callback} [cb] - will receive the comment\n * @return {Promise} - the Promise for the http request\n */\n getComment(comment, cb) {\n return this._request('GET', `/gists/${this.__id}/comments/${comment}`, null, cb);\n }\n\n /**\n * Comment on a gist\n * @see https://developer.github.com/v3/gists/comments/#create-a-comment\n * @param {string} comment - the comment to add\n * @param {Requestable.callback} [cb] - the function that receives the API result\n * @return {Promise} - the Promise for the http request\n */\n createComment(comment, cb) {\n return this._request('POST', `/gists/${this.__id}/comments`, {body: comment}, cb);\n }\n\n /**\n * Edit a comment on the gist\n * @see https://developer.github.com/v3/gists/comments/#edit-a-comment\n * @param {number} comment - the id of the comment\n * @param {string} body - the new comment\n * @param {Requestable.callback} [cb] - will receive the modified comment\n * @return {Promise} - the promise for the http request\n */\n editComment(comment, body, cb) {\n return this._request('PATCH', `/gists/${this.__id}/comments/${comment}`, {body: body}, cb);\n }\n\n /**\n * Delete a comment on the gist.\n * @see https://developer.github.com/v3/gists/comments/#delete-a-comment\n * @param {number} comment - the id of the comment\n * @param {Requestable.callback} [cb] - will receive true if the request succeeds\n * @return {Promise} - the Promise for the http request\n */\n deleteComment(comment, cb) {\n return this._request('DELETE', `/gists/${this.__id}/comments/${comment}`, null, cb);\n }\n}\n\nmodule.exports = Gist;\n","/**\n * @file\n * @copyright 2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n * Github.js is freely distributable.\n */\n/* eslint valid-jsdoc: [\"error\", {\"requireReturnDescription\": false}] */\n\nimport Gist from './Gist';\nimport User from './User';\nimport Issue from './Issue';\nimport Search from './Search';\nimport RateLimit from './RateLimit';\nimport Repository from './Repository';\nimport Organization from './Organization';\nimport Team from './Team';\nimport Markdown from './Markdown';\nimport Project from './Project';\n\n/**\n * GitHub encapsulates the functionality to create various API wrapper objects.\n */\nclass GitHub {\n /**\n * Create a new GitHub.\n * @param {Requestable.auth} [auth] - the credentials to authenticate to Github. If auth is\n * not provided requests will be made unauthenticated\n * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n */\n constructor(auth, apiBase = 'https://api.github.com') {\n this.__apiBase = apiBase;\n this.__auth = auth || {};\n }\n\n /**\n * Create a new Gist wrapper\n * @param {number} [id] - the id for the gist, leave undefined when creating a new gist\n * @return {Gist}\n */\n getGist(id) {\n return new Gist(id, this.__auth, this.__apiBase);\n }\n\n /**\n * Create a new User wrapper\n * @param {string} [user] - the name of the user to get information about\n * leave undefined for the authenticated user\n * @return {User}\n */\n getUser(user) {\n return new User(user, this.__auth, this.__apiBase);\n }\n\n /**\n * Create a new Organization wrapper\n * @param {string} organization - the name of the organization\n * @return {Organization}\n */\n getOrganization(organization) {\n return new Organization(organization, this.__auth, this.__apiBase);\n }\n\n /**\n * create a new Team wrapper\n * @param {string} teamId - the name of the team\n * @return {team}\n */\n getTeam(teamId) {\n return new Team(teamId, this.__auth, this.__apiBase);\n }\n\n /**\n * Create a new Repository wrapper\n * @param {string} user - the user who owns the respository\n * @param {string} repo - the name of the repository\n * @return {Repository}\n */\n getRepo(user, repo) {\n return new Repository(this._getFullName(user, repo), this.__auth, this.__apiBase);\n }\n\n /**\n * Create a new Issue wrapper\n * @param {string} user - the user who owns the respository\n * @param {string} repo - the name of the repository\n * @return {Issue}\n */\n getIssues(user, repo) {\n return new Issue(this._getFullName(user, repo), this.__auth, this.__apiBase);\n }\n\n /**\n * Create a new Search wrapper\n * @param {string} query - the query to search for\n * @return {Search}\n */\n search(query) {\n return new Search(query, this.__auth, this.__apiBase);\n }\n\n /**\n * Create a new RateLimit wrapper\n * @return {RateLimit}\n */\n getRateLimit() {\n return new RateLimit(this.__auth, this.__apiBase);\n }\n\n /**\n * Create a new Markdown wrapper\n * @return {Markdown}\n */\n getMarkdown() {\n return new Markdown(this.__auth, this.__apiBase);\n }\n\n /**\n * Create a new Project wrapper\n * @param {string} id - the id of the project\n * @return {Markdown}\n */\n getProject(id) {\n return new Project(id, this.__auth, this.__apiBase);\n }\n\n /**\n * Computes the full repository name\n * @param {string} user - the username (or the full name)\n * @param {string} repo - the repository name, must not be passed if `user` is the full name\n * @return {string} the repository's full name\n */\n _getFullName(user, repo) {\n let fullname = user;\n\n if (repo) {\n fullname = `${user}/${repo}`;\n }\n\n return fullname;\n }\n}\n\nmodule.exports = GitHub;\n","/**\n * @file\n * @copyright 2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n * Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\n\n/**\n * Issue wraps the functionality to get issues for repositories\n */\nclass Issue extends Requestable {\n /**\n * Create a new Issue\n * @param {string} repository - the full name of the repository (`:user/:repo`) to get issues for\n * @param {Requestable.auth} [auth] - information required to authenticate to Github\n * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n */\n constructor(repository, auth, apiBase) {\n super(auth, apiBase);\n this.__repository = repository;\n }\n\n /**\n * Create a new issue\n * @see https://developer.github.com/v3/issues/#create-an-issue\n * @param {Object} issueData - the issue to create\n * @param {Requestable.callback} [cb] - will receive the created issue\n * @return {Promise} - the promise for the http request\n */\n createIssue(issueData, cb) {\n return this._request('POST', `/repos/${this.__repository}/issues`, issueData, cb);\n }\n\n /**\n * List the issues for the repository\n * @see https://developer.github.com/v3/issues/#list-issues-for-a-repository\n * @param {Object} options - filtering options\n * @param {Requestable.callback} [cb] - will receive the array of issues\n * @return {Promise} - the promise for the http request\n */\n listIssues(options, cb) {\n return this._requestAllPages(`/repos/${this.__repository}/issues`, options, cb);\n }\n\n /**\n * List the events for an issue\n * @see https://developer.github.com/v3/issues/events/#list-events-for-an-issue\n * @param {number} issue - the issue to get events for\n * @param {Requestable.callback} [cb] - will receive the list of events\n * @return {Promise} - the promise for the http request\n */\n listIssueEvents(issue, cb) {\n return this._request('GET', `/repos/${this.__repository}/issues/${issue}/events`, null, cb);\n }\n\n /**\n * List comments on an issue\n * @see https://developer.github.com/v3/issues/comments/#list-comments-on-an-issue\n * @param {number} issue - the id of the issue to get comments from\n * @param {Requestable.callback} [cb] - will receive the comments\n * @return {Promise} - the promise for the http request\n */\n listIssueComments(issue, cb) {\n return this._request('GET', `/repos/${this.__repository}/issues/${issue}/comments`, null, cb);\n }\n\n /**\n * Get a single comment on an issue\n * @see https://developer.github.com/v3/issues/comments/#get-a-single-comment\n * @param {number} id - the comment id to get\n * @param {Requestable.callback} [cb] - will receive the comment\n * @return {Promise} - the promise for the http request\n */\n getIssueComment(id, cb) {\n return this._request('GET', `/repos/${this.__repository}/issues/comments/${id}`, null, cb);\n }\n\n /**\n * Comment on an issue\n * @see https://developer.github.com/v3/issues/comments/#create-a-comment\n * @param {number} issue - the id of the issue to comment on\n * @param {string} comment - the comment to add\n * @param {Requestable.callback} [cb] - will receive the created comment\n * @return {Promise} - the promise for the http request\n */\n createIssueComment(issue, comment, cb) {\n return this._request('POST', `/repos/${this.__repository}/issues/${issue}/comments`, {body: comment}, cb);\n }\n\n /**\n * Edit a comment on an issue\n * @see https://developer.github.com/v3/issues/comments/#edit-a-comment\n * @param {number} id - the comment id to edit\n * @param {string} comment - the comment to edit\n * @param {Requestable.callback} [cb] - will receive the edited comment\n * @return {Promise} - the promise for the http request\n */\n editIssueComment(id, comment, cb) {\n return this._request('PATCH', `/repos/${this.__repository}/issues/comments/${id}`, {body: comment}, cb);\n }\n\n /**\n * Delete a comment on an issue\n * @see https://developer.github.com/v3/issues/comments/#delete-a-comment\n * @param {number} id - the comment id to delete\n * @param {Requestable.callback} [cb] - will receive true if the request is successful\n * @return {Promise} - the promise for the http request\n */\n deleteIssueComment(id, cb) {\n return this._request('DELETE', `/repos/${this.__repository}/issues/comments/${id}`, null, cb);\n }\n\n /**\n * Edit an issue\n * @see https://developer.github.com/v3/issues/#edit-an-issue\n * @param {number} issue - the issue number to edit\n * @param {Object} issueData - the new issue data\n * @param {Requestable.callback} [cb] - will receive the modified issue\n * @return {Promise} - the promise for the http request\n */\n editIssue(issue, issueData, cb) {\n return this._request('PATCH', `/repos/${this.__repository}/issues/${issue}`, issueData, cb);\n }\n\n /**\n * Get a particular issue\n * @see https://developer.github.com/v3/issues/#get-a-single-issue\n * @param {number} issue - the issue number to fetch\n * @param {Requestable.callback} [cb] - will receive the issue\n * @return {Promise} - the promise for the http request\n */\n getIssue(issue, cb) {\n return this._request('GET', `/repos/${this.__repository}/issues/${issue}`, null, cb);\n }\n\n /**\n * List the milestones for the repository\n * @see https://developer.github.com/v3/issues/milestones/#list-milestones-for-a-repository\n * @param {Object} options - filtering options\n * @param {Requestable.callback} [cb] - will receive the array of milestones\n * @return {Promise} - the promise for the http request\n */\n listMilestones(options, cb) {\n return this._request('GET', `/repos/${this.__repository}/milestones`, options, cb);\n }\n\n /**\n * Get a milestone\n * @see https://developer.github.com/v3/issues/milestones/#get-a-single-milestone\n * @param {string} milestone - the id of the milestone to fetch\n * @param {Requestable.callback} [cb] - will receive the milestone\n * @return {Promise} - the promise for the http request\n */\n getMilestone(milestone, cb) {\n return this._request('GET', `/repos/${this.__repository}/milestones/${milestone}`, null, cb);\n }\n\n /**\n * Create a new milestone\n * @see https://developer.github.com/v3/issues/milestones/#create-a-milestone\n * @param {Object} milestoneData - the milestone definition\n * @param {Requestable.callback} [cb] - will receive the milestone\n * @return {Promise} - the promise for the http request\n */\n createMilestone(milestoneData, cb) {\n return this._request('POST', `/repos/${this.__repository}/milestones`, milestoneData, cb);\n }\n\n /**\n * Edit a milestone\n * @see https://developer.github.com/v3/issues/milestones/#update-a-milestone\n * @param {string} milestone - the id of the milestone to edit\n * @param {Object} milestoneData - the updates to make to the milestone\n * @param {Requestable.callback} [cb] - will receive the updated milestone\n * @return {Promise} - the promise for the http request\n */\n editMilestone(milestone, milestoneData, cb) {\n return this._request('PATCH', `/repos/${this.__repository}/milestones/${milestone}`, milestoneData, cb);\n }\n\n /**\n * Delete a milestone (this is distinct from closing a milestone)\n * @see https://developer.github.com/v3/issues/milestones/#delete-a-milestone\n * @param {string} milestone - the id of the milestone to delete\n * @param {Requestable.callback} [cb] - will receive the status\n * @return {Promise} - the promise for the http request\n */\n deleteMilestone(milestone, cb) {\n return this._request('DELETE', `/repos/${this.__repository}/milestones/${milestone}`, null, cb);\n }\n\n /**\n * Create a new label\n * @see https://developer.github.com/v3/issues/labels/#create-a-label\n * @param {Object} labelData - the label definition\n * @param {Requestable.callback} [cb] - will receive the object representing the label\n * @return {Promise} - the promise for the http request\n */\n createLabel(labelData, cb) {\n return this._request('POST', `/repos/${this.__repository}/labels`, labelData, cb);\n }\n\n /**\n * List the labels for the repository\n * @see https://developer.github.com/v3/issues/labels/#list-all-labels-for-this-repository\n * @param {Object} options - filtering options\n * @param {Requestable.callback} [cb] - will receive the array of labels\n * @return {Promise} - the promise for the http request\n */\n listLabels(options, cb) {\n return this._request('GET', `/repos/${this.__repository}/labels`, options, cb);\n }\n\n /**\n * Get a label\n * @see https://developer.github.com/v3/issues/labels/#get-a-single-label\n * @param {string} label - the name of the label to fetch\n * @param {Requestable.callback} [cb] - will receive the label\n * @return {Promise} - the promise for the http request\n */\n getLabel(label, cb) {\n return this._request('GET', `/repos/${this.__repository}/labels/${label}`, null, cb);\n }\n\n /**\n * Edit a label\n * @see https://developer.github.com/v3/issues/labels/#update-a-label\n * @param {string} label - the name of the label to edit\n * @param {Object} labelData - the updates to make to the label\n * @param {Requestable.callback} [cb] - will receive the updated label\n * @return {Promise} - the promise for the http request\n */\n editLabel(label, labelData, cb) {\n return this._request('PATCH', `/repos/${this.__repository}/labels/${label}`, labelData, cb);\n }\n\n /**\n * Delete a label\n * @see https://developer.github.com/v3/issues/labels/#delete-a-label\n * @param {string} label - the name of the label to delete\n * @param {Requestable.callback} [cb] - will receive the status\n * @return {Promise} - the promise for the http request\n */\n deleteLabel(label, cb) {\n return this._request('DELETE', `/repos/${this.__repository}/labels/${label}`, null, cb);\n }\n}\n\nmodule.exports = Issue;\n","/**\n * @file\n * @copyright 2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n * Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\n\n/**\n * Renders html from Markdown text\n */\nclass Markdown extends Requestable {\n /**\n * construct a Markdown\n * @param {Requestable.auth} auth - the credentials to authenticate to GitHub\n * @param {string} [apiBase] - the base Github API URL\n * @return {Promise} - the promise for the http request\n */\n constructor(auth, apiBase) {\n super(auth, apiBase);\n }\n\n /**\n * Render html from Markdown text.\n * @see https://developer.github.com/v3/markdown/#render-an-arbitrary-markdown-document\n * @param {Object} options - conversion options\n * @param {string} [options.text] - the markdown text to convert\n * @param {string} [options.mode=markdown] - can be either `markdown` or `gfm`\n * @param {string} [options.context] - repository name if mode is gfm\n * @param {Requestable.callback} [cb] - will receive the converted html\n * @return {Promise} - the promise for the http request\n */\n render(options, cb) {\n return this._request('POST', '/markdown', options, cb);\n }\n}\n\nmodule.exports = Markdown;\n","/**\n * @file\n * @copyright 2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n * Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\n\n/**\n * Organization encapsulates the functionality to create repositories in organizations\n */\nclass Organization extends Requestable {\n /**\n * Create a new Organization\n * @param {string} organization - the name of the organization\n * @param {Requestable.auth} [auth] - information required to authenticate to Github\n * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n */\n constructor(organization, auth, apiBase) {\n super(auth, apiBase);\n this.__name = organization;\n }\n\n /**\n * Create a repository in an organization\n * @see https://developer.github.com/v3/repos/#create\n * @param {Object} options - the repository definition\n * @param {Requestable.callback} [cb] - will receive the created repository\n * @return {Promise} - the promise for the http request\n */\n createRepo(options, cb) {\n return this._request('POST', `/orgs/${this.__name}/repos`, options, cb);\n }\n\n /**\n * List the repositories in an organization\n * @see https://developer.github.com/v3/repos/#list-organization-repositories\n * @param {Requestable.callback} [cb] - will receive the list of repositories\n * @return {Promise} - the promise for the http request\n */\n getRepos(cb) {\n let requestOptions = this._getOptionsWithDefaults({direction: 'desc'});\n\n return this._requestAllPages(`/orgs/${this.__name}/repos`, requestOptions, cb);\n }\n\n /**\n * Query if the user is a member or not\n * @param {string} username - the user in question\n * @param {Requestable.callback} [cb] - will receive true if the user is a member\n * @return {Promise} - the promise for the http request\n */\n isMember(username, cb) {\n return this._request204or404(`/orgs/${this.__name}/members/${username}`, null, cb);\n }\n\n /**\n * List the users who are members of the company\n * @see https://developer.github.com/v3/orgs/members/#members-list\n * @param {object} options - filtering options\n * @param {string} [options.filter=all] - can be either `2fa_disabled` or `all`\n * @param {string} [options.role=all] - can be one of: `all`, `admin`, or `member`\n * @param {Requestable.callback} [cb] - will receive the list of users\n * @return {Promise} - the promise for the http request\n */\n listMembers(options, cb) {\n return this._request('GET', `/orgs/${this.__name}/members`, options, cb);\n }\n\n /**\n * List the Teams in the Organization\n * @see https://developer.github.com/v3/orgs/teams/#list-teams\n * @param {Requestable.callback} [cb] - will receive the list of teams\n * @return {Promise} - the promise for the http request\n */\n getTeams(cb) {\n return this._requestAllPages(`/orgs/${this.__name}/teams`, undefined, cb);\n }\n\n /**\n * Create a team\n * @see https://developer.github.com/v3/orgs/teams/#create-team\n * @param {object} options - Team creation parameters\n * @param {string} options.name - The name of the team\n * @param {string} [options.description] - Team description\n * @param {string} [options.repo_names] - Repos to add the team to\n * @param {string} [options.privacy=secret] - The level of privacy the team should have. Can be either one\n * of: `secret`, or `closed`\n * @param {Requestable.callback} [cb] - will receive the created team\n * @return {Promise} - the promise for the http request\n */\n createTeam(options, cb) {\n return this._request('POST', `/orgs/${this.__name}/teams`, options, cb);\n }\n\n /**\n * Get information about all projects\n * @see https://developer.github.com/v3/projects/#list-organization-projects\n * @param {Requestable.callback} [cb] - will receive the list of projects\n * @return {Promise} - the promise for the http request\n */\n listProjects(cb) {\n return this._requestAllPages(`/orgs/${this.__name}/projects`, {AcceptHeader: 'inertia-preview'}, cb);\n }\n\n /**\n * Create a new project\n * @see https://developer.github.com/v3/repos/projects/#create-a-project\n * @param {Object} options - the description of the project\n * @param {Requestable.callback} cb - will receive the newly created project\n * @return {Promise} - the promise for the http request\n */\n createProject(options, cb) {\n options = options || {};\n options.AcceptHeader = 'inertia-preview';\n return this._request('POST', `/orgs/${this.__name}/projects`, options, cb);\n }\n}\n\nmodule.exports = Organization;\n","/**\n * @file\n * @copyright 2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n * Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\n\n/**\n * Project encapsulates the functionality to create, query, and modify cards and columns.\n */\nclass Project extends Requestable {\n /**\n * Create a Project.\n * @param {string} id - the id of the project\n * @param {Requestable.auth} [auth] - information required to authenticate to Github\n * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n */\n constructor(id, auth, apiBase) {\n super(auth, apiBase, 'inertia-preview');\n this.__id = id;\n }\n\n /**\n * Get information about a project\n * @see https://developer.github.com/v3/projects/#get-a-project\n * @param {Requestable.callback} cb - will receive the project information\n * @return {Promise} - the promise for the http request\n */\n getProject(cb) {\n return this._request('GET', `/projects/${this.__id}`, null, cb);\n }\n\n /**\n * Edit a project\n * @see https://developer.github.com/v3/projects/#update-a-project\n * @param {Object} options - the description of the project\n * @param {Requestable.callback} cb - will receive the modified project\n * @return {Promise} - the promise for the http request\n */\n updateProject(options, cb) {\n return this._request('PATCH', `/projects/${this.__id}`, options, cb);\n }\n\n /**\n * Delete a project\n * @see https://developer.github.com/v3/projects/#delete-a-project\n * @param {Requestable.callback} cb - will receive true if the operation is successful\n * @return {Promise} - the promise for the http request\n */\n deleteProject(cb) {\n return this._request('DELETE', `/projects/${this.__id}`, null, cb);\n }\n\n /**\n * Get information about all columns of a project\n * @see https://developer.github.com/v3/projects/columns/#list-project-columns\n * @param {Requestable.callback} [cb] - will receive the list of columns\n * @return {Promise} - the promise for the http request\n */\n listProjectColumns(cb) {\n return this._requestAllPages(`/projects/${this.__id}/columns`, null, cb);\n }\n\n /**\n * Get information about a column\n * @see https://developer.github.com/v3/projects/columns/#get-a-project-column\n * @param {string} colId - the id of the column\n * @param {Requestable.callback} cb - will receive the column information\n * @return {Promise} - the promise for the http request\n */\n getProjectColumn(colId, cb) {\n return this._request('GET', `/projects/columns/${colId}`, null, cb);\n }\n\n /**\n * Create a new column\n * @see https://developer.github.com/v3/projects/columns/#create-a-project-column\n * @param {Object} options - the description of the column\n * @param {Requestable.callback} cb - will receive the newly created column\n * @return {Promise} - the promise for the http request\n */\n createProjectColumn(options, cb) {\n return this._request('POST', `/projects/${this.__id}/columns`, options, cb);\n }\n\n /**\n * Edit a column\n * @see https://developer.github.com/v3/projects/columns/#update-a-project-column\n * @param {string} colId - the column id\n * @param {Object} options - the description of the column\n * @param {Requestable.callback} cb - will receive the modified column\n * @return {Promise} - the promise for the http request\n */\n updateProjectColumn(colId, options, cb) {\n return this._request('PATCH', `/projects/columns/${colId}`, options, cb);\n }\n\n /**\n * Delete a column\n * @see https://developer.github.com/v3/projects/columns/#delete-a-project-column\n * @param {string} colId - the column to be deleted\n * @param {Requestable.callback} cb - will receive true if the operation is successful\n * @return {Promise} - the promise for the http request\n */\n deleteProjectColumn(colId, cb) {\n return this._request('DELETE', `/projects/columns/${colId}`, null, cb);\n }\n\n /**\n * Move a column\n * @see https://developer.github.com/v3/projects/columns/#move-a-project-column\n * @param {string} colId - the column to be moved\n * @param {string} position - can be one of first, last, or after:,\n * where is the id value of a column in the same project.\n * @param {Requestable.callback} cb - will receive true if the operation is successful\n * @return {Promise} - the promise for the http request\n */\n moveProjectColumn(colId, position, cb) {\n return this._request(\n 'POST',\n `/projects/columns/${colId}/moves`,\n {position: position},\n cb\n );\n }\n\n /**\n * Get information about all cards of a project\n * @see https://developer.github.com/v3/projects/cards/#list-project-cards\n * @param {Requestable.callback} [cb] - will receive the list of cards\n * @return {Promise} - the promise for the http request\n */\n listProjectCards(cb) {\n return this.listProjectColumns()\n .then(({data}) => {\n return Promise.all(data.map((column) => {\n return this._requestAllPages(`/projects/columns/${column.id}/cards`, null);\n }));\n }).then((cardsInColumns) => {\n const cards = cardsInColumns.reduce((prev, {data}) => {\n prev.push(...data);\n return prev;\n }, []);\n if (cb) {\n cb(null, cards);\n }\n return cards;\n }).catch((err) => {\n if (cb) {\n cb(err);\n return;\n }\n throw err;\n });\n }\n\n /**\n * Get information about all cards of a column\n * @see https://developer.github.com/v3/projects/cards/#list-project-cards\n * @param {string} colId - the id of the column\n * @param {Requestable.callback} [cb] - will receive the list of cards\n * @return {Promise} - the promise for the http request\n */\n listColumnCards(colId, cb) {\n return this._requestAllPages(`/projects/columns/${colId}/cards`, null, cb);\n }\n\n /**\n * Get information about a card\n * @see https://developer.github.com/v3/projects/cards/#get-a-project-card\n * @param {string} cardId - the id of the card\n * @param {Requestable.callback} cb - will receive the card information\n * @return {Promise} - the promise for the http request\n */\n getProjectCard(cardId, cb) {\n return this._request('GET', `/projects/columns/cards/${cardId}`, null, cb);\n }\n\n /**\n * Create a new card\n * @see https://developer.github.com/v3/projects/cards/#create-a-project-card\n * @param {string} colId - the column id\n * @param {Object} options - the description of the card\n * @param {Requestable.callback} cb - will receive the newly created card\n * @return {Promise} - the promise for the http request\n */\n createProjectCard(colId, options, cb) {\n return this._request('POST', `/projects/columns/${colId}/cards`, options, cb);\n }\n\n /**\n * Edit a card\n * @see https://developer.github.com/v3/projects/cards/#update-a-project-card\n * @param {string} cardId - the card id\n * @param {Object} options - the description of the card\n * @param {Requestable.callback} cb - will receive the modified card\n * @return {Promise} - the promise for the http request\n */\n updateProjectCard(cardId, options, cb) {\n return this._request('PATCH', `/projects/columns/cards/${cardId}`, options, cb);\n }\n\n /**\n * Delete a card\n * @see https://developer.github.com/v3/projects/cards/#delete-a-project-card\n * @param {string} cardId - the card to be deleted\n * @param {Requestable.callback} cb - will receive true if the operation is successful\n * @return {Promise} - the promise for the http request\n */\n deleteProjectCard(cardId, cb) {\n return this._request('DELETE', `/projects/columns/cards/${cardId}`, null, cb);\n }\n\n /**\n * Move a card\n * @see https://developer.github.com/v3/projects/cards/#move-a-project-card\n * @param {string} cardId - the card to be moved\n * @param {string} position - can be one of top, bottom, or after:,\n * where is the id value of a card in the same project.\n * @param {string} colId - the id value of a column in the same project.\n * @param {Requestable.callback} cb - will receive true if the operation is successful\n * @return {Promise} - the promise for the http request\n */\n moveProjectCard(cardId, position, colId, cb) {\n return this._request(\n 'POST',\n `/projects/columns/cards/${cardId}/moves`,\n {position: position, column_id: colId}, // eslint-disable-line camelcase\n cb\n );\n }\n}\n\nmodule.exports = Project;\n","/**\n * @file\n * @copyright 2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n * Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\n\n/**\n * RateLimit allows users to query their rate-limit status\n */\nclass RateLimit extends Requestable {\n /**\n * construct a RateLimit\n * @param {Requestable.auth} auth - the credentials to authenticate to GitHub\n * @param {string} [apiBase] - the base Github API URL\n * @return {Promise} - the promise for the http request\n */\n constructor(auth, apiBase) {\n super(auth, apiBase);\n }\n\n /**\n * Query the current rate limit\n * @see https://developer.github.com/v3/rate_limit/\n * @param {Requestable.callback} [cb] - will receive the rate-limit data\n * @return {Promise} - the promise for the http request\n */\n getRateLimit(cb) {\n return this._request('GET', '/rate_limit', null, cb);\n }\n}\n\nmodule.exports = RateLimit;\n","/**\n * @file\n * @copyright 2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n * Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\nimport Utf8 from 'utf8';\nimport {\n Base64,\n} from 'js-base64';\nimport debug from 'debug';\nconst log = debug('github:repository');\n\n/**\n * Respository encapsulates the functionality to create, query, and modify files.\n */\nclass Repository extends Requestable {\n /**\n * Create a Repository.\n * @param {string} fullname - the full name of the repository\n * @param {Requestable.auth} [auth] - information required to authenticate to Github\n * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n */\n constructor(fullname, auth, apiBase) {\n super(auth, apiBase);\n this.__fullname = fullname;\n this.__currentTree = {\n branch: null,\n sha: null,\n };\n }\n\n /**\n * Get a reference\n * @see https://developer.github.com/v3/git/refs/#get-a-reference\n * @param {string} ref - the reference to get\n * @param {Requestable.callback} [cb] - will receive the reference's refSpec or a list of refSpecs that match `ref`\n * @return {Promise} - the promise for the http request\n */\n getRef(ref, cb) {\n return this._request('GET', `/repos/${this.__fullname}/git/refs/${ref}`, null, cb);\n }\n\n /**\n * Create a reference\n * @see https://developer.github.com/v3/git/refs/#create-a-reference\n * @param {Object} options - the object describing the ref\n * @param {Requestable.callback} [cb] - will receive the ref\n * @return {Promise} - the promise for the http request\n */\n createRef(options, cb) {\n return this._request('POST', `/repos/${this.__fullname}/git/refs`, options, cb);\n }\n\n /**\n * Delete a reference\n * @see https://developer.github.com/v3/git/refs/#delete-a-reference\n * @param {string} ref - the name of the ref to delte\n * @param {Requestable.callback} [cb] - will receive true if the request is successful\n * @return {Promise} - the promise for the http request\n */\n deleteRef(ref, cb) {\n return this._request('DELETE', `/repos/${this.__fullname}/git/refs/${ref}`, null, cb);\n }\n\n /**\n * Delete a repository\n * @see https://developer.github.com/v3/repos/#delete-a-repository\n * @param {Requestable.callback} [cb] - will receive true if the request is successful\n * @return {Promise} - the promise for the http request\n */\n deleteRepo(cb) {\n return this._request('DELETE', `/repos/${this.__fullname}`, null, cb);\n }\n\n /**\n * List the tags on a repository\n * @see https://developer.github.com/v3/repos/#list-tags\n * @param {Requestable.callback} [cb] - will receive the tag data\n * @return {Promise} - the promise for the http request\n */\n listTags(cb) {\n return this._request('GET', `/repos/${this.__fullname}/tags`, null, cb);\n }\n\n /**\n * List the open pull requests on the repository\n * @see https://developer.github.com/v3/pulls/#list-pull-requests\n * @param {Object} options - options to filter the search\n * @param {Requestable.callback} [cb] - will receive the list of PRs\n * @return {Promise} - the promise for the http request\n */\n listPullRequests(options, cb) {\n options = options || {};\n return this._request('GET', `/repos/${this.__fullname}/pulls`, options, cb);\n }\n\n /**\n * Get information about a specific pull request\n * @see https://developer.github.com/v3/pulls/#get-a-single-pull-request\n * @param {number} number - the PR you wish to fetch\n * @param {Requestable.callback} [cb] - will receive the PR from the API\n * @return {Promise} - the promise for the http request\n */\n getPullRequest(number, cb) {\n return this._request('GET', `/repos/${this.__fullname}/pulls/${number}`, null, cb);\n }\n\n /**\n * List the files of a specific pull request\n * @see https://developer.github.com/v3/pulls/#list-pull-requests-files\n * @param {number|string} number - the PR you wish to fetch\n * @param {Requestable.callback} [cb] - will receive the list of files from the API\n * @return {Promise} - the promise for the http request\n */\n listPullRequestFiles(number, cb) {\n return this._request('GET', `/repos/${this.__fullname}/pulls/${number}/files`, null, cb);\n }\n\n /**\n * Compare two branches/commits/repositories\n * @see https://developer.github.com/v3/repos/commits/#compare-two-commits\n * @param {string} base - the base commit\n * @param {string} head - the head commit\n * @param {Requestable.callback} cb - will receive the comparison\n * @return {Promise} - the promise for the http request\n */\n compareBranches(base, head, cb) {\n return this._request('GET', `/repos/${this.__fullname}/compare/${base}...${head}`, null, cb);\n }\n\n /**\n * List all the branches for the repository\n * @see https://developer.github.com/v3/repos/#list-branches\n * @param {Requestable.callback} cb - will receive the list of branches\n * @return {Promise} - the promise for the http request\n */\n listBranches(cb) {\n return this._request('GET', `/repos/${this.__fullname}/branches`, null, cb);\n }\n\n /**\n * Get a raw blob from the repository\n * @see https://developer.github.com/v3/git/blobs/#get-a-blob\n * @param {string} sha - the sha of the blob to fetch\n * @param {Requestable.callback} cb - will receive the blob from the API\n * @return {Promise} - the promise for the http request\n */\n getBlob(sha, cb) {\n return this._request('GET', `/repos/${this.__fullname}/git/blobs/${sha}`, null, cb, 'raw');\n }\n\n /**\n * Get a single branch\n * @see https://developer.github.com/v3/repos/branches/#get-branch\n * @param {string} branch - the name of the branch to fetch\n * @param {Requestable.callback} cb - will receive the branch from the API\n * @returns {Promise} - the promise for the http request\n */\n getBranch(branch, cb) {\n return this._request('GET', `/repos/${this.__fullname}/branches/${branch}`, null, cb);\n }\n\n /**\n * Get a commit from the repository\n * @see https://developer.github.com/v3/repos/commits/#get-a-single-commit\n * @param {string} sha - the sha for the commit to fetch\n * @param {Requestable.callback} cb - will receive the commit data\n * @return {Promise} - the promise for the http request\n */\n getCommit(sha, cb) {\n return this._request('GET', `/repos/${this.__fullname}/git/commits/${sha}`, null, cb);\n }\n\n /**\n * List the commits on a repository, optionally filtering by path, author or time range\n * @see https://developer.github.com/v3/repos/commits/#list-commits-on-a-repository\n * @param {Object} [options] - the filtering options for commits\n * @param {string} [options.sha] - the SHA or branch to start from\n * @param {string} [options.path] - the path to search on\n * @param {string} [options.author] - the commit author\n * @param {(Date|string)} [options.since] - only commits after this date will be returned\n * @param {(Date|string)} [options.until] - only commits before this date will be returned\n * @param {Requestable.callback} cb - will receive the list of commits found matching the criteria\n * @return {Promise} - the promise for the http request\n */\n listCommits(options, cb) {\n options = options || {};\n\n options.since = this._dateToISO(options.since);\n options.until = this._dateToISO(options.until);\n\n return this._request('GET', `/repos/${this.__fullname}/commits`, options, cb);\n }\n\n /**\n * Gets a single commit information for a repository\n * @see https://developer.github.com/v3/repos/commits/#get-a-single-commit\n * @param {string} ref - the reference for the commit-ish\n * @param {Requestable.callback} cb - will receive the commit information\n * @return {Promise} - the promise for the http request\n */\n getSingleCommit(ref, cb) {\n ref = ref || '';\n return this._request('GET', `/repos/${this.__fullname}/commits/${ref}`, null, cb);\n }\n\n /**\n * Get tha sha for a particular object in the repository. This is a convenience function\n * @see https://developer.github.com/v3/repos/contents/#get-contents\n * @param {string} [branch] - the branch to look in, or the repository's default branch if omitted\n * @param {string} path - the path of the file or directory\n * @param {Requestable.callback} cb - will receive a description of the requested object, including a `SHA` property\n * @return {Promise} - the promise for the http request\n */\n getSha(branch, path, cb) {\n branch = branch ? `?ref=${branch}` : '';\n return this._request('GET', `/repos/${this.__fullname}/contents/${path}${branch}`, null, cb);\n }\n\n /**\n * List the commit statuses for a particular sha, branch, or tag\n * @see https://developer.github.com/v3/repos/statuses/#list-statuses-for-a-specific-ref\n * @param {string} sha - the sha, branch, or tag to get statuses for\n * @param {Requestable.callback} cb - will receive the list of statuses\n * @return {Promise} - the promise for the http request\n */\n listStatuses(sha, cb) {\n return this._request('GET', `/repos/${this.__fullname}/commits/${sha}/statuses`, null, cb);\n }\n\n /**\n * Get a description of a git tree\n * @see https://developer.github.com/v3/git/trees/#get-a-tree\n * @param {string} treeSHA - the SHA of the tree to fetch\n * @param {Requestable.callback} cb - will receive the callback data\n * @return {Promise} - the promise for the http request\n */\n getTree(treeSHA, cb) {\n return this._request('GET', `/repos/${this.__fullname}/git/trees/${treeSHA}`, null, cb);\n }\n\n /**\n * Create a blob\n * @see https://developer.github.com/v3/git/blobs/#create-a-blob\n * @param {(string|Buffer|Blob)} content - the content to add to the repository\n * @param {Requestable.callback} cb - will receive the details of the created blob\n * @return {Promise} - the promise for the http request\n */\n createBlob(content, cb) {\n let postBody = this._getContentObject(content);\n\n log('sending content', postBody);\n return this._request('POST', `/repos/${this.__fullname}/git/blobs`, postBody, cb);\n }\n\n /**\n * Get the object that represents the provided content\n * @param {string|Buffer|Blob} content - the content to send to the server\n * @return {Object} the representation of `content` for the GitHub API\n */\n _getContentObject(content) {\n if (typeof content === 'string') {\n log('contet is a string');\n return {\n content: Utf8.encode(content),\n encoding: 'utf-8',\n };\n\n } else if (typeof Buffer !== 'undefined' && content instanceof Buffer) {\n log('We appear to be in Node');\n return {\n content: content.toString('base64'),\n encoding: 'base64',\n };\n\n } else if (typeof Blob !== 'undefined' && content instanceof Blob) {\n log('We appear to be in the browser');\n return {\n content: Base64.encode(content),\n encoding: 'base64',\n };\n\n } else { // eslint-disable-line\n log(`Not sure what this content is: ${typeof content}, ${JSON.stringify(content)}`);\n throw new Error('Unknown content passed to postBlob. Must be string or Buffer (node) or Blob (web)');\n }\n }\n\n /**\n * Update a tree in Git\n * @see https://developer.github.com/v3/git/trees/#create-a-tree\n * @param {string} baseTreeSHA - the SHA of the tree to update\n * @param {string} path - the path for the new file\n * @param {string} blobSHA - the SHA for the blob to put at `path`\n * @param {Requestable.callback} cb - will receive the new tree that is created\n * @return {Promise} - the promise for the http request\n * @deprecated use {@link Repository#createTree} instead\n */\n updateTree(baseTreeSHA, path, blobSHA, cb) {\n let newTree = {\n base_tree: baseTreeSHA, // eslint-disable-line\n tree: [{\n path: path,\n sha: blobSHA,\n mode: '100644',\n type: 'blob',\n }],\n };\n\n return this._request('POST', `/repos/${this.__fullname}/git/trees`, newTree, cb);\n }\n\n /**\n * Create a new tree in git\n * @see https://developer.github.com/v3/git/trees/#create-a-tree\n * @param {Object} tree - the tree to create\n * @param {string} baseSHA - the root sha of the tree\n * @param {Requestable.callback} cb - will receive the new tree that is created\n * @return {Promise} - the promise for the http request\n */\n createTree(tree, baseSHA, cb) {\n return this._request('POST', `/repos/${this.__fullname}/git/trees`, {\n tree,\n base_tree: baseSHA, // eslint-disable-line camelcase\n }, cb);\n }\n\n /**\n * Add a commit to the repository\n * @see https://developer.github.com/v3/git/commits/#create-a-commit\n * @param {string} parent - the SHA of the parent commit\n * @param {string} tree - the SHA of the tree for this commit\n * @param {string} message - the commit message\n * @param {Requestable.callback} cb - will receive the commit that is created\n * @return {Promise} - the promise for the http request\n */\n commit(parent, tree, message, cb) {\n let data = {\n message,\n tree,\n parents: [parent],\n };\n\n return this._request('POST', `/repos/${this.__fullname}/git/commits`, data, cb)\n .then((response) => {\n this.__currentTree.sha = response.data.sha; // Update latest commit\n return response;\n });\n }\n\n /**\n * Update a ref\n * @see https://developer.github.com/v3/git/refs/#update-a-reference\n * @param {string} ref - the ref to update\n * @param {string} commitSHA - the SHA to point the reference to\n * @param {boolean} force - indicates whether to force or ensure a fast-forward update\n * @param {Requestable.callback} cb - will receive the updated ref back\n * @return {Promise} - the promise for the http request\n */\n updateHead(ref, commitSHA, force, cb) {\n return this._request('PATCH', `/repos/${this.__fullname}/git/refs/${ref}`, {\n sha: commitSHA,\n force: force,\n }, cb);\n }\n\n /**\n * Update commit status\n * @see https://developer.github.com/v3/repos/statuses/\n * @param {string} commitSHA - the SHA of the commit that should be updated\n * @param {object} options - Commit status parameters\n * @param {string} options.state - The state of the status. Can be one of: pending, success, error, or failure.\n * @param {string} [options.target_url] - The target URL to associate with this status.\n * @param {string} [options.description] - A short description of the status.\n * @param {string} [options.context] - A string label to differentiate this status among CI systems.\n * @param {Requestable.callback} cb - will receive the updated commit back\n * @return {Promise} - the promise for the http request\n */\n updateStatus(commitSHA, options, cb) {\n return this._request('POST', `/repos/${this.__fullname}/statuses/${commitSHA}`, options, cb);\n }\n\n /**\n * Update repository information\n * @see https://developer.github.com/v3/repos/#edit\n * @param {object} options - New parameters that will be set to the repository\n * @param {string} options.name - Name of the repository\n * @param {string} [options.description] - A short description of the repository\n * @param {string} [options.homepage] - A URL with more information about the repository\n * @param {boolean} [options.private] - Either true to make the repository private, or false to make it public.\n * @param {boolean} [options.has_issues] - Either true to enable issues for this repository, false to disable them.\n * @param {boolean} [options.has_wiki] - Either true to enable the wiki for this repository, false to disable it.\n * @param {boolean} [options.has_downloads] - Either true to enable downloads, false to disable them.\n * @param {string} [options.default_branch] - Updates the default branch for this repository.\n * @param {Requestable.callback} cb - will receive the updated repository back\n * @return {Promise} - the promise for the http request\n */\n updateRepository(options, cb) {\n return this._request('PATCH', `/repos/${this.__fullname}`, options, cb);\n }\n\n /**\n * Get information about the repository\n * @see https://developer.github.com/v3/repos/#get\n * @param {Requestable.callback} cb - will receive the information about the repository\n * @return {Promise} - the promise for the http request\n */\n getDetails(cb) {\n return this._request('GET', `/repos/${this.__fullname}`, null, cb);\n }\n\n /**\n * List the contributors to the repository\n * @see https://developer.github.com/v3/repos/#list-contributors\n * @param {Requestable.callback} cb - will receive the list of contributors\n * @return {Promise} - the promise for the http request\n */\n getContributors(cb) {\n return this._request('GET', `/repos/${this.__fullname}/contributors`, null, cb);\n }\n\n /**\n * List the contributor stats to the repository\n * @see https://developer.github.com/v3/repos/#list-contributors\n * @param {Requestable.callback} cb - will receive the list of contributors\n * @return {Promise} - the promise for the http request\n */\n getContributorStats(cb) {\n return this._request('GET', `/repos/${this.__fullname}/stats/contributors`, null, cb);\n }\n\n /**\n * List the users who are collaborators on the repository. The currently authenticated user must have\n * push access to use this method\n * @see https://developer.github.com/v3/repos/collaborators/#list-collaborators\n * @param {Requestable.callback} cb - will receive the list of collaborators\n * @return {Promise} - the promise for the http request\n */\n getCollaborators(cb) {\n return this._request('GET', `/repos/${this.__fullname}/collaborators`, null, cb);\n }\n\n /**\n * Check if a user is a collaborator on the repository\n * @see https://developer.github.com/v3/repos/collaborators/#check-if-a-user-is-a-collaborator\n * @param {string} username - the user to check\n * @param {Requestable.callback} cb - will receive true if the user is a collaborator and false if they are not\n * @return {Promise} - the promise for the http request {Boolean} [description]\n */\n isCollaborator(username, cb) {\n return this._request('GET', `/repos/${this.__fullname}/collaborators/${username}`, null, cb);\n }\n\n /**\n * Get the contents of a repository\n * @see https://developer.github.com/v3/repos/contents/#get-contents\n * @param {string} ref - the ref to check\n * @param {string} path - the path containing the content to fetch\n * @param {boolean} raw - `true` if the results should be returned raw instead of GitHub's normalized format\n * @param {Requestable.callback} cb - will receive the fetched data\n * @return {Promise} - the promise for the http request\n */\n getContents(ref, path, raw, cb) {\n path = path ? `${encodeURI(path)}` : '';\n return this._request('GET', `/repos/${this.__fullname}/contents/${path}`, {\n ref,\n }, cb, raw);\n }\n\n /**\n * Get the README of a repository\n * @see https://developer.github.com/v3/repos/contents/#get-the-readme\n * @param {string} ref - the ref to check\n * @param {boolean} raw - `true` if the results should be returned raw instead of GitHub's normalized format\n * @param {Requestable.callback} cb - will receive the fetched data\n * @return {Promise} - the promise for the http request\n */\n getReadme(ref, raw, cb) {\n return this._request('GET', `/repos/${this.__fullname}/readme`, {\n ref,\n }, cb, raw);\n }\n\n /**\n * Fork a repository\n * @see https://developer.github.com/v3/repos/forks/#create-a-fork\n * @param {Requestable.callback} cb - will receive the information about the newly created fork\n * @return {Promise} - the promise for the http request\n */\n fork(cb) {\n return this._request('POST', `/repos/${this.__fullname}/forks`, null, cb);\n }\n\n /**\n * List a repository's forks\n * @see https://developer.github.com/v3/repos/forks/#list-forks\n * @param {Requestable.callback} cb - will receive the list of repositories forked from this one\n * @return {Promise} - the promise for the http request\n */\n listForks(cb) {\n return this._request('GET', `/repos/${this.__fullname}/forks`, null, cb);\n }\n\n /**\n * Create a new branch from an existing branch.\n * @param {string} [oldBranch=master] - the name of the existing branch\n * @param {string} newBranch - the name of the new branch\n * @param {Requestable.callback} cb - will receive the commit data for the head of the new branch\n * @return {Promise} - the promise for the http request\n */\n createBranch(oldBranch, newBranch, cb) {\n if (typeof newBranch === 'function') {\n cb = newBranch;\n newBranch = oldBranch;\n oldBranch = 'master';\n }\n\n return this.getRef(`heads/${oldBranch}`)\n .then((response) => {\n let sha = response.data.object.sha;\n return this.createRef({\n sha,\n ref: `refs/heads/${newBranch}`,\n }, cb);\n });\n }\n\n /**\n * Create a new pull request\n * @see https://developer.github.com/v3/pulls/#create-a-pull-request\n * @param {Object} options - the pull request description\n * @param {Requestable.callback} cb - will receive the new pull request\n * @return {Promise} - the promise for the http request\n */\n createPullRequest(options, cb) {\n return this._request('POST', `/repos/${this.__fullname}/pulls`, options, cb);\n }\n\n /**\n * Update a pull request\n * @see https://developer.github.com/v3/pulls/#update-a-pull-request\n * @param {number|string} number - the number of the pull request to update\n * @param {Object} options - the pull request description\n * @param {Requestable.callback} [cb] - will receive the pull request information\n * @return {Promise} - the promise for the http request\n */\n updatePullRequest(number, options, cb) {\n return this._request('PATCH', `/repos/${this.__fullname}/pulls/${number}`, options, cb);\n }\n\n /**\n * List the hooks for the repository\n * @see https://developer.github.com/v3/repos/hooks/#list-hooks\n * @param {Requestable.callback} cb - will receive the list of hooks\n * @return {Promise} - the promise for the http request\n */\n listHooks(cb) {\n return this._request('GET', `/repos/${this.__fullname}/hooks`, null, cb);\n }\n\n /**\n * Get a hook for the repository\n * @see https://developer.github.com/v3/repos/hooks/#get-single-hook\n * @param {number} id - the id of the webook\n * @param {Requestable.callback} cb - will receive the details of the webook\n * @return {Promise} - the promise for the http request\n */\n getHook(id, cb) {\n return this._request('GET', `/repos/${this.__fullname}/hooks/${id}`, null, cb);\n }\n\n /**\n * Add a new hook to the repository\n * @see https://developer.github.com/v3/repos/hooks/#create-a-hook\n * @param {Object} options - the configuration describing the new hook\n * @param {Requestable.callback} cb - will receive the new webhook\n * @return {Promise} - the promise for the http request\n */\n createHook(options, cb) {\n return this._request('POST', `/repos/${this.__fullname}/hooks`, options, cb);\n }\n\n /**\n * Edit an existing webhook\n * @see https://developer.github.com/v3/repos/hooks/#edit-a-hook\n * @param {number} id - the id of the webhook\n * @param {Object} options - the new description of the webhook\n * @param {Requestable.callback} cb - will receive the updated webhook\n * @return {Promise} - the promise for the http request\n */\n updateHook(id, options, cb) {\n return this._request('PATCH', `/repos/${this.__fullname}/hooks/${id}`, options, cb);\n }\n\n /**\n * Delete a webhook\n * @see https://developer.github.com/v3/repos/hooks/#delete-a-hook\n * @param {number} id - the id of the webhook to be deleted\n * @param {Requestable.callback} cb - will receive true if the call is successful\n * @return {Promise} - the promise for the http request\n */\n deleteHook(id, cb) {\n return this._request('DELETE', `/repos/${this.__fullname}/hooks/${id}`, null, cb);\n }\n\n /**\n * List the deploy keys for the repository\n * @see https://developer.github.com/v3/repos/keys/#list-deploy-keys\n * @param {Requestable.callback} cb - will receive the list of deploy keys\n * @return {Promise} - the promise for the http request\n */\n listKeys(cb) {\n return this._request('GET', `/repos/${this.__fullname}/keys`, null, cb);\n }\n\n /**\n * Get a deploy key for the repository\n * @see https://developer.github.com/v3/repos/keys/#get-a-deploy-key\n * @param {number} id - the id of the deploy key\n * @param {Requestable.callback} cb - will receive the details of the deploy key\n * @return {Promise} - the promise for the http request\n */\n getKey(id, cb) {\n return this._request('GET', `/repos/${this.__fullname}/keys/${id}`, null, cb);\n }\n\n /**\n * Add a new deploy key to the repository\n * @see https://developer.github.com/v3/repos/keys/#add-a-new-deploy-key\n * @param {Object} options - the configuration describing the new deploy key\n * @param {Requestable.callback} cb - will receive the new deploy key\n * @return {Promise} - the promise for the http request\n */\n createKey(options, cb) {\n return this._request('POST', `/repos/${this.__fullname}/keys`, options, cb);\n }\n\n /**\n * Delete a deploy key\n * @see https://developer.github.com/v3/repos/keys/#remove-a-deploy-key\n * @param {number} id - the id of the deploy key to be deleted\n * @param {Requestable.callback} cb - will receive true if the call is successful\n * @return {Promise} - the promise for the http request\n */\n deleteKey(id, cb) {\n return this._request('DELETE', `/repos/${this.__fullname}/keys/${id}`, null, cb);\n }\n\n /**\n * Delete a file from a branch\n * @see https://developer.github.com/v3/repos/contents/#delete-a-file\n * @param {string} branch - the branch to delete from, or the default branch if not specified\n * @param {string} path - the path of the file to remove\n * @param {Requestable.callback} cb - will receive the commit in which the delete occurred\n * @return {Promise} - the promise for the http request\n */\n deleteFile(branch, path, cb) {\n return this.getSha(branch, path)\n .then((response) => {\n const deleteCommit = {\n message: `Delete the file at '${path}'`,\n sha: response.data.sha,\n branch,\n };\n return this._request('DELETE', `/repos/${this.__fullname}/contents/${path}`, deleteCommit, cb);\n });\n }\n\n /**\n * Change all references in a repo from oldPath to new_path\n * @param {string} branch - the branch to carry out the reference change, or the default branch if not specified\n * @param {string} oldPath - original path\n * @param {string} newPath - new reference path\n * @param {Requestable.callback} cb - will receive the commit in which the move occurred\n * @return {Promise} - the promise for the http request\n */\n move(branch, oldPath, newPath, cb) {\n let oldSha;\n return this.getRef(`heads/${branch}`)\n .then(({data: {object}}) => this.getTree(`${object.sha}?recursive=true`))\n .then(({data: {tree, sha}}) => {\n oldSha = sha;\n let newTree = tree.map((ref) => {\n if (ref.path === oldPath) {\n ref.path = newPath;\n }\n if (ref.type === 'tree') {\n delete ref.sha;\n }\n return ref;\n });\n return this.createTree(newTree);\n })\n .then(({data: tree}) => this.commit(oldSha, tree.sha, `Renamed '${oldPath}' to '${newPath}'`))\n .then(({data: commit}) => this.updateHead(`heads/${branch}`, commit.sha, true, cb));\n }\n\n /**\n * Write a file to the repository\n * @see https://developer.github.com/v3/repos/contents/#update-a-file\n * @param {string} branch - the name of the branch\n * @param {string} path - the path for the file\n * @param {string} content - the contents of the file\n * @param {string} message - the commit message\n * @param {Object} [options] - commit options\n * @param {Object} [options.author] - the author of the commit\n * @param {Object} [options.commiter] - the committer\n * @param {boolean} [options.encode] - true if the content should be base64 encoded\n * @param {Requestable.callback} cb - will receive the new commit\n * @return {Promise} - the promise for the http request\n */\n writeFile(branch, path, content, message, options, cb) {\n if (typeof options === 'function') {\n cb = options;\n options = {};\n }\n let filePath = path ? encodeURI(path) : '';\n let shouldEncode = options.encode !== false;\n let commit = {\n branch,\n message,\n author: options.author,\n committer: options.committer,\n content: shouldEncode ? Base64.encode(content) : content,\n };\n\n return this.getSha(branch, filePath)\n .then((response) => {\n commit.sha = response.data.sha;\n return this._request('PUT', `/repos/${this.__fullname}/contents/${filePath}`, commit, cb);\n }, () => {\n return this._request('PUT', `/repos/${this.__fullname}/contents/${filePath}`, commit, cb);\n });\n }\n\n /**\n * Check if a repository is starred by you\n * @see https://developer.github.com/v3/activity/starring/#check-if-you-are-starring-a-repository\n * @param {Requestable.callback} cb - will receive true if the repository is starred and false if the repository\n * is not starred\n * @return {Promise} - the promise for the http request {Boolean} [description]\n */\n isStarred(cb) {\n return this._request204or404(`/user/starred/${this.__fullname}`, null, cb);\n }\n\n /**\n * Star a repository\n * @see https://developer.github.com/v3/activity/starring/#star-a-repository\n * @param {Requestable.callback} cb - will receive true if the repository is starred\n * @return {Promise} - the promise for the http request\n */\n star(cb) {\n return this._request('PUT', `/user/starred/${this.__fullname}`, null, cb);\n }\n\n /**\n * Unstar a repository\n * @see https://developer.github.com/v3/activity/starring/#unstar-a-repository\n * @param {Requestable.callback} cb - will receive true if the repository is unstarred\n * @return {Promise} - the promise for the http request\n */\n unstar(cb) {\n return this._request('DELETE', `/user/starred/${this.__fullname}`, null, cb);\n }\n\n /**\n * Create a new release\n * @see https://developer.github.com/v3/repos/releases/#create-a-release\n * @param {Object} options - the description of the release\n * @param {Requestable.callback} cb - will receive the newly created release\n * @return {Promise} - the promise for the http request\n */\n createRelease(options, cb) {\n return this._request('POST', `/repos/${this.__fullname}/releases`, options, cb);\n }\n\n /**\n * Edit a release\n * @see https://developer.github.com/v3/repos/releases/#edit-a-release\n * @param {string} id - the id of the release\n * @param {Object} options - the description of the release\n * @param {Requestable.callback} cb - will receive the modified release\n * @return {Promise} - the promise for the http request\n */\n updateRelease(id, options, cb) {\n return this._request('PATCH', `/repos/${this.__fullname}/releases/${id}`, options, cb);\n }\n\n /**\n * Get information about all releases\n * @see https://developer.github.com/v3/repos/releases/#list-releases-for-a-repository\n * @param {Requestable.callback} cb - will receive the release information\n * @return {Promise} - the promise for the http request\n */\n listReleases(cb) {\n return this._request('GET', `/repos/${this.__fullname}/releases`, null, cb);\n }\n\n /**\n * Get information about a release\n * @see https://developer.github.com/v3/repos/releases/#get-a-single-release\n * @param {string} id - the id of the release\n * @param {Requestable.callback} cb - will receive the release information\n * @return {Promise} - the promise for the http request\n */\n getRelease(id, cb) {\n return this._request('GET', `/repos/${this.__fullname}/releases/${id}`, null, cb);\n }\n\n /**\n * Delete a release\n * @see https://developer.github.com/v3/repos/releases/#delete-a-release\n * @param {string} id - the release to be deleted\n * @param {Requestable.callback} cb - will receive true if the operation is successful\n * @return {Promise} - the promise for the http request\n */\n deleteRelease(id, cb) {\n return this._request('DELETE', `/repos/${this.__fullname}/releases/${id}`, null, cb);\n }\n\n /**\n * Merge a pull request\n * @see https://developer.github.com/v3/pulls/#merge-a-pull-request-merge-button\n * @param {number|string} number - the number of the pull request to merge\n * @param {Object} options - the merge options for the pull request\n * @param {Requestable.callback} [cb] - will receive the merge information if the operation is successful\n * @return {Promise} - the promise for the http request\n */\n mergePullRequest(number, options, cb) {\n return this._request('PUT', `/repos/${this.__fullname}/pulls/${number}/merge`, options, cb);\n }\n\n /**\n * Get information about all projects\n * @see https://developer.github.com/v3/projects/#list-repository-projects\n * @param {Requestable.callback} [cb] - will receive the list of projects\n * @return {Promise} - the promise for the http request\n */\n listProjects(cb) {\n return this._requestAllPages(`/repos/${this.__fullname}/projects`, {AcceptHeader: 'inertia-preview'}, cb);\n }\n\n /**\n * Create a new project\n * @see https://developer.github.com/v3/projects/#create-a-repository-project\n * @param {Object} options - the description of the project\n * @param {Requestable.callback} cb - will receive the newly created project\n * @return {Promise} - the promise for the http request\n */\n createProject(options, cb) {\n options = options || {};\n options.AcceptHeader = 'inertia-preview';\n return this._request('POST', `/repos/${this.__fullname}/projects`, options, cb);\n }\n\n}\n\nmodule.exports = Repository;\n","/**\n * @file\n * @copyright 2016 Yahoo Inc.\n * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n * Github.js is freely distributable.\n */\n\nimport axios from 'axios';\nimport debug from 'debug';\nimport {Base64} from 'js-base64';\n\nconst log = debug('github:request');\n\n/**\n * The error structure returned when a network call fails\n */\nclass ResponseError extends Error {\n /**\n * Construct a new ResponseError\n * @param {string} message - an message to return instead of the the default error message\n * @param {string} path - the requested path\n * @param {Object} response - the object returned by Axios\n */\n constructor(message, path, response) {\n super(message);\n this.path = path;\n this.request = response.config;\n this.response = (response || {}).response || response;\n this.status = response.status;\n }\n}\n\n/**\n * Requestable wraps the logic for making http requests to the API\n */\nclass Requestable {\n /**\n * Either a username and password or an oauth token for Github\n * @typedef {Object} Requestable.auth\n * @prop {string} [username] - the Github username\n * @prop {string} [password] - the user's password\n * @prop {token} [token] - an OAuth token\n */\n /**\n * Initialize the http internals.\n * @param {Requestable.auth} [auth] - the credentials to authenticate to Github. If auth is\n * not provided request will be made unauthenticated\n * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n * @param {string} [AcceptHeader=v3] - the accept header for the requests\n */\n constructor(auth, apiBase, AcceptHeader) {\n this.__apiBase = apiBase || 'https://api.github.com';\n this.__auth = {\n token: auth.token,\n username: auth.username,\n password: auth.password,\n };\n this.__AcceptHeader = AcceptHeader || 'v3';\n\n if (auth.token) {\n this.__authorizationHeader = 'token ' + auth.token;\n } else if (auth.username && auth.password) {\n this.__authorizationHeader = 'Basic ' + Base64.encode(auth.username + ':' + auth.password);\n }\n }\n\n /**\n * Compute the URL to use to make a request.\n * @private\n * @param {string} path - either a URL relative to the API base or an absolute URL\n * @return {string} - the URL to use\n */\n __getURL(path) {\n let url = path;\n\n if (path.indexOf('//') === -1) {\n url = this.__apiBase + path;\n }\n\n let newCacheBuster = 'timestamp=' + new Date().getTime();\n return url.replace(/(timestamp=\\d+)/, newCacheBuster);\n }\n\n /**\n * Compute the headers required for an API request.\n * @private\n * @param {boolean} raw - if the request should be treated as JSON or as a raw request\n * @param {string} AcceptHeader - the accept header for the request\n * @return {Object} - the headers to use in the request\n */\n __getRequestHeaders(raw, AcceptHeader) {\n let headers = {\n 'Content-Type': 'application/json;charset=UTF-8',\n 'Accept': 'application/vnd.github.' + (AcceptHeader || this.__AcceptHeader),\n };\n\n if (raw) {\n headers.Accept += '.raw';\n }\n headers.Accept += '+json';\n\n if (this.__authorizationHeader) {\n headers.Authorization = this.__authorizationHeader;\n }\n\n return headers;\n }\n\n /**\n * Sets the default options for API requests\n * @protected\n * @param {Object} [requestOptions={}] - the current options for the request\n * @return {Object} - the options to pass to the request\n */\n _getOptionsWithDefaults(requestOptions = {}) {\n if (!(requestOptions.visibility || requestOptions.affiliation)) {\n requestOptions.type = requestOptions.type || 'all';\n }\n requestOptions.sort = requestOptions.sort || 'updated';\n requestOptions.per_page = requestOptions.per_page || '100'; // eslint-disable-line\n\n return requestOptions;\n }\n\n /**\n * if a `Date` is passed to this function it will be converted to an ISO string\n * @param {*} date - the object to attempt to cooerce into an ISO date string\n * @return {string} - the ISO representation of `date` or whatever was passed in if it was not a date\n */\n _dateToISO(date) {\n if (date && (date instanceof Date)) {\n date = date.toISOString();\n }\n\n return date;\n }\n\n /**\n * A function that receives the result of the API request.\n * @callback Requestable.callback\n * @param {Requestable.Error} error - the error returned by the API or `null`\n * @param {(Object|true)} result - the data returned by the API or `true` if the API returns `204 No Content`\n * @param {Object} request - the raw {@linkcode https://github.com/mzabriskie/axios#response-schema Response}\n */\n /**\n * Make a request.\n * @param {string} method - the method for the request (GET, PUT, POST, DELETE)\n * @param {string} path - the path for the request\n * @param {*} [data] - the data to send to the server. For HTTP methods that don't have a body the data\n * will be sent as query parameters\n * @param {Requestable.callback} [cb] - the callback for the request\n * @param {boolean} [raw=false] - if the request should be sent as raw. If this is a falsy value then the\n * request will be made as JSON\n * @return {Promise} - the Promise for the http request\n */\n _request(method, path, data, cb, raw) {\n const url = this.__getURL(path);\n\n const AcceptHeader = (data || {}).AcceptHeader;\n if (AcceptHeader) {\n delete data.AcceptHeader;\n }\n const headers = this.__getRequestHeaders(raw, AcceptHeader);\n\n let queryParams = {};\n\n const shouldUseDataAsParams = data && (typeof data === 'object') && methodHasNoBody(method);\n if (shouldUseDataAsParams) {\n queryParams = data;\n data = undefined;\n }\n\n const config = {\n url: url,\n method: method,\n headers: headers,\n params: queryParams,\n data: data,\n responseType: raw ? 'text' : 'json',\n };\n\n log(`${config.method} to ${config.url}`);\n const requestPromise = axios(config).catch(callbackErrorOrThrow(cb, path));\n\n if (cb) {\n requestPromise.then((response) => {\n if (response.data && Object.keys(response.data).length > 0) {\n // When data has results\n cb(null, response.data, response);\n } else if (config.method !== 'GET' && Object.keys(response.data).length < 1) {\n // True when successful submit a request and receive a empty object\n cb(null, (response.status < 300), response);\n } else {\n cb(null, response.data, response);\n }\n });\n }\n\n return requestPromise;\n }\n\n /**\n * Make a request to an endpoint the returns 204 when true and 404 when false\n * @param {string} path - the path to request\n * @param {Object} data - any query parameters for the request\n * @param {Requestable.callback} cb - the callback that will receive `true` or `false`\n * @param {method} [method=GET] - HTTP Method to use\n * @return {Promise} - the promise for the http request\n */\n _request204or404(path, data, cb, method = 'GET') {\n return this._request(method, path, data)\n .then(function success(response) {\n if (cb) {\n cb(null, true, response);\n }\n return true;\n }, function failure(response) {\n if (response.response.status === 404) {\n if (cb) {\n cb(null, false, response);\n }\n return false;\n }\n\n if (cb) {\n cb(response);\n }\n throw response;\n });\n }\n\n /**\n * Make a request and fetch all the available data. Github will paginate responses so for queries\n * that might span multiple pages this method is preferred to {@link Requestable#request}\n * @param {string} path - the path to request\n * @param {Object} options - the query parameters to include\n * @param {Requestable.callback} [cb] - the function to receive the data. The returned data will always be an array.\n * @param {Object[]} results - the partial results. This argument is intended for interal use only.\n * @return {Promise} - a promise which will resolve when all pages have been fetched\n * @deprecated This will be folded into {@link Requestable#_request} in the 2.0 release.\n */\n _requestAllPages(path, options, cb, results) {\n results = results || [];\n\n return this._request('GET', path, options)\n .then((response) => {\n let thisGroup;\n if (response.data instanceof Array) {\n thisGroup = response.data;\n } else if (response.data.items instanceof Array) {\n thisGroup = response.data.items;\n } else {\n let message = `cannot figure out how to append ${response.data} to the result set`;\n throw new ResponseError(message, path, response);\n }\n results.push(...thisGroup);\n\n const nextUrl = getNextPage(response.headers.link);\n if (nextUrl && typeof options.page !== 'number') {\n log(`getting next page: ${nextUrl}`);\n return this._requestAllPages(nextUrl, options, cb, results);\n }\n\n if (cb) {\n cb(null, results, response);\n }\n\n response.data = results;\n return response;\n }).catch(callbackErrorOrThrow(cb, path));\n }\n}\n\nmodule.exports = Requestable;\n\n// ////////////////////////// //\n// Private helper functions //\n// ////////////////////////// //\nconst METHODS_WITH_NO_BODY = ['GET', 'HEAD', 'DELETE'];\nfunction methodHasNoBody(method) {\n return METHODS_WITH_NO_BODY.indexOf(method) !== -1;\n}\n\nfunction getNextPage(linksHeader = '') {\n const links = linksHeader.split(/\\s*,\\s*/); // splits and strips the urls\n return links.reduce(function(nextUrl, link) {\n if (link.search(/rel=\"next\"/) !== -1) {\n return (link.match(/<(.*)>/) || [])[1];\n }\n\n return nextUrl;\n }, undefined);\n}\n\nfunction callbackErrorOrThrow(cb, path) {\n return function handler(object) {\n let error;\n if (object.hasOwnProperty('config')) {\n const {response: {status, statusText}, config: {method, url}} = object;\n let message = (`${status} error making request ${method} ${url}: \"${statusText}\"`);\n error = new ResponseError(message, path, object);\n log(`${message} ${JSON.stringify(object.data)}`);\n } else {\n error = object;\n }\n if (cb) {\n log('going to error callback');\n cb(error);\n } else {\n log('throwing error');\n throw error;\n }\n };\n}\n","/**\n * @file\n * @copyright 2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n * Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\nimport debug from 'debug';\nconst log = debug('github:search');\n\n/**\n * Wrap the Search API\n */\nclass Search extends Requestable {\n /**\n * Create a Search\n * @param {Object} defaults - defaults for the search\n * @param {Requestable.auth} [auth] - information required to authenticate to Github\n * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n */\n constructor(defaults, auth, apiBase) {\n super(auth, apiBase);\n this.__defaults = this._getOptionsWithDefaults(defaults);\n }\n\n /**\n * Available search options\n * @see https://developer.github.com/v3/search/#parameters\n * @typedef {Object} Search.Params\n * @param {string} q - the query to make\n * @param {string} sort - the sort field, one of `stars`, `forks`, or `updated`.\n * Default is [best match](https://developer.github.com/v3/search/#ranking-search-results)\n * @param {string} order - the ordering, either `asc` or `desc`\n */\n /**\n * Perform a search on the GitHub API\n * @private\n * @param {string} path - the scope of the search\n * @param {Search.Params} [withOptions] - additional parameters for the search\n * @param {Requestable.callback} [cb] - will receive the results of the search\n * @return {Promise} - the promise for the http request\n */\n _search(path, withOptions = {}, cb = undefined) {\n let requestOptions = {};\n Object.keys(this.__defaults).forEach((prop) => {\n requestOptions[prop] = this.__defaults[prop];\n });\n Object.keys(withOptions).forEach((prop) => {\n requestOptions[prop] = withOptions[prop];\n });\n\n log(`searching ${path} with options:`, requestOptions);\n return this._requestAllPages(`/search/${path}`, requestOptions, cb);\n }\n\n /**\n * Search for repositories\n * @see https://developer.github.com/v3/search/#search-repositories\n * @param {Search.Params} [options] - additional parameters for the search\n * @param {Requestable.callback} [cb] - will receive the results of the search\n * @return {Promise} - the promise for the http request\n */\n forRepositories(options, cb) {\n return this._search('repositories', options, cb);\n }\n\n /**\n * Search for code\n * @see https://developer.github.com/v3/search/#search-code\n * @param {Search.Params} [options] - additional parameters for the search\n * @param {Requestable.callback} [cb] - will receive the results of the search\n * @return {Promise} - the promise for the http request\n */\n forCode(options, cb) {\n return this._search('code', options, cb);\n }\n\n /**\n * Search for issues\n * @see https://developer.github.com/v3/search/#search-issues\n * @param {Search.Params} [options] - additional parameters for the search\n * @param {Requestable.callback} [cb] - will receive the results of the search\n * @return {Promise} - the promise for the http request\n */\n forIssues(options, cb) {\n return this._search('issues', options, cb);\n }\n\n /**\n * Search for users\n * @see https://developer.github.com/v3/search/#search-users\n * @param {Search.Params} [options] - additional parameters for the search\n * @param {Requestable.callback} [cb] - will receive the results of the search\n * @return {Promise} - the promise for the http request\n */\n forUsers(options, cb) {\n return this._search('users', options, cb);\n }\n}\n\nmodule.exports = Search;\n","/**\n * @file\n * @copyright 2016 Matt Smith (Development Seed)\n * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n * Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\nimport debug from 'debug';\nconst log = debug('github:team');\n\n/**\n * A Team allows scoping of API requests to a particular Github Organization Team.\n */\nclass Team extends Requestable {\n /**\n * Create a Team.\n * @param {string} [teamId] - the id for the team\n * @param {Requestable.auth} [auth] - information required to authenticate to Github\n * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n */\n constructor(teamId, auth, apiBase) {\n super(auth, apiBase);\n this.__teamId = teamId;\n }\n\n /**\n * Get Team information\n * @see https://developer.github.com/v3/orgs/teams/#get-team\n * @param {Requestable.callback} [cb] - will receive the team\n * @return {Promise} - the promise for the http request\n */\n getTeam(cb) {\n log(`Fetching Team ${this.__teamId}`);\n return this._request('Get', `/teams/${this.__teamId}`, undefined, cb);\n }\n\n /**\n * List the Team's repositories\n * @see https://developer.github.com/v3/orgs/teams/#list-team-repos\n * @param {Requestable.callback} [cb] - will receive the list of repositories\n * @return {Promise} - the promise for the http request\n */\n listRepos(cb) {\n log(`Fetching repositories for Team ${this.__teamId}`);\n return this._requestAllPages(`/teams/${this.__teamId}/repos`, undefined, cb);\n }\n\n /**\n * Edit Team information\n * @see https://developer.github.com/v3/orgs/teams/#edit-team\n * @param {object} options - Parameters for team edit\n * @param {string} options.name - The name of the team\n * @param {string} [options.description] - Team description\n * @param {string} [options.repo_names] - Repos to add the team to\n * @param {string} [options.privacy=secret] - The level of privacy the team should have. Can be either one\n * of: `secret`, or `closed`\n * @param {Requestable.callback} [cb] - will receive the updated team\n * @return {Promise} - the promise for the http request\n */\n editTeam(options, cb) {\n log(`Editing Team ${this.__teamId}`);\n return this._request('PATCH', `/teams/${this.__teamId}`, options, cb);\n }\n\n /**\n * List the users who are members of the Team\n * @see https://developer.github.com/v3/orgs/teams/#list-team-members\n * @param {object} options - Parameters for listing team users\n * @param {string} [options.role=all] - can be one of: `all`, `maintainer`, or `member`\n * @param {Requestable.callback} [cb] - will receive the list of users\n * @return {Promise} - the promise for the http request\n */\n listMembers(options, cb) {\n log(`Getting members of Team ${this.__teamId}`);\n return this._requestAllPages(`/teams/${this.__teamId}/members`, options, cb);\n }\n\n /**\n * Get Team membership status for a user\n * @see https://developer.github.com/v3/orgs/teams/#get-team-membership\n * @param {string} username - can be one of: `all`, `maintainer`, or `member`\n * @param {Requestable.callback} [cb] - will receive the membership status of a user\n * @return {Promise} - the promise for the http request\n */\n getMembership(username, cb) {\n log(`Getting membership of user ${username} in Team ${this.__teamId}`);\n return this._request('GET', `/teams/${this.__teamId}/memberships/${username}`, undefined, cb);\n }\n\n /**\n * Add a member to the Team\n * @see https://developer.github.com/v3/orgs/teams/#add-team-membership\n * @param {string} username - can be one of: `all`, `maintainer`, or `member`\n * @param {object} options - Parameters for adding a team member\n * @param {string} [options.role=member] - The role that this user should have in the team. Can be one\n * of: `member`, or `maintainer`\n * @param {Requestable.callback} [cb] - will receive the membership status of added user\n * @return {Promise} - the promise for the http request\n */\n addMembership(username, options, cb) {\n log(`Adding user ${username} to Team ${this.__teamId}`);\n return this._request('PUT', `/teams/${this.__teamId}/memberships/${username}`, options, cb);\n }\n\n /**\n * Get repo management status for team\n * @see https://developer.github.com/v3/orgs/teams/#remove-team-membership\n * @param {string} owner - Organization name\n * @param {string} repo - Repo name\n * @param {Requestable.callback} [cb] - will receive the membership status of added user\n * @return {Promise} - the promise for the http request\n */\n isManagedRepo(owner, repo, cb) {\n log(`Getting repo management by Team ${this.__teamId} for repo ${owner}/${repo}`);\n return this._request204or404(`/teams/${this.__teamId}/repos/${owner}/${repo}`, undefined, cb);\n }\n\n /**\n * Add or Update repo management status for team\n * @see https://developer.github.com/v3/orgs/teams/#add-or-update-team-repository\n * @param {string} owner - Organization name\n * @param {string} repo - Repo name\n * @param {object} options - Parameters for adding or updating repo management for the team\n * @param {string} [options.permission] - The permission to grant the team on this repository. Can be one\n * of: `pull`, `push`, or `admin`\n * @param {Requestable.callback} [cb] - will receive the membership status of added user\n * @return {Promise} - the promise for the http request\n */\n manageRepo(owner, repo, options, cb) {\n log(`Adding or Updating repo management by Team ${this.__teamId} for repo ${owner}/${repo}`);\n return this._request204or404(`/teams/${this.__teamId}/repos/${owner}/${repo}`, options, cb, 'PUT');\n }\n\n /**\n * Remove repo management status for team\n * @see https://developer.github.com/v3/orgs/teams/#remove-team-repository\n * @param {string} owner - Organization name\n * @param {string} repo - Repo name\n * @param {Requestable.callback} [cb] - will receive the membership status of added user\n * @return {Promise} - the promise for the http request\n */\n unmanageRepo(owner, repo, cb) {\n log(`Remove repo management by Team ${this.__teamId} for repo ${owner}/${repo}`);\n return this._request204or404(`/teams/${this.__teamId}/repos/${owner}/${repo}`, undefined, cb, 'DELETE');\n }\n\n /**\n * Delete Team\n * @see https://developer.github.com/v3/orgs/teams/#delete-team\n * @param {Requestable.callback} [cb] - will receive the list of repositories\n * @return {Promise} - the promise for the http request\n */\n deleteTeam(cb) {\n log(`Deleting Team ${this.__teamId}`);\n return this._request204or404(`/teams/${this.__teamId}`, undefined, cb, 'DELETE');\n }\n}\n\nmodule.exports = Team;\n","/**\n * @file\n * @copyright 2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n * Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\nimport debug from 'debug';\nconst log = debug('github:user');\n\n/**\n * A User allows scoping of API requests to a particular Github user.\n */\nclass User extends Requestable {\n /**\n * Create a User.\n * @param {string} [username] - the user to use for user-scoped queries\n * @param {Requestable.auth} [auth] - information required to authenticate to Github\n * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n */\n constructor(username, auth, apiBase) {\n super(auth, apiBase);\n this.__user = username;\n }\n\n /**\n * Get the url for the request. (dependent on if we're requesting for the authenticated user or not)\n * @private\n * @param {string} endpoint - the endpoint being requested\n * @return {string} - the resolved endpoint\n */\n __getScopedUrl(endpoint) {\n if (this.__user) {\n return endpoint ?\n `/users/${this.__user}/${endpoint}` :\n `/users/${this.__user}`\n ;\n\n } else { // eslint-disable-line\n switch (endpoint) {\n case '':\n return '/user';\n\n case 'notifications':\n case 'gists':\n return `/${endpoint}`;\n\n default:\n return `/user/${endpoint}`;\n }\n }\n }\n\n /**\n * List the user's repositories\n * @see https://developer.github.com/v3/repos/#list-user-repositories\n * @param {Object} [options={}] - any options to refine the search\n * @param {Requestable.callback} [cb] - will receive the list of repositories\n * @return {Promise} - the promise for the http request\n */\n listRepos(options, cb) {\n if (typeof options === 'function') {\n cb = options;\n options = {};\n }\n\n options = this._getOptionsWithDefaults(options);\n\n log(`Fetching repositories with options: ${JSON.stringify(options)}`);\n return this._requestAllPages(this.__getScopedUrl('repos'), options, cb);\n }\n\n /**\n * List the orgs that the user belongs to\n * @see https://developer.github.com/v3/orgs/#list-user-organizations\n * @param {Requestable.callback} [cb] - will receive the list of organizations\n * @return {Promise} - the promise for the http request\n */\n listOrgs(cb) {\n return this._request('GET', this.__getScopedUrl('orgs'), null, cb);\n }\n\n /**\n * List the user's gists\n * @see https://developer.github.com/v3/gists/#list-a-users-gists\n * @param {Requestable.callback} [cb] - will receive the list of gists\n * @return {Promise} - the promise for the http request\n */\n listGists(cb) {\n return this._request('GET', this.__getScopedUrl('gists'), null, cb);\n }\n\n /**\n * List the user's starred gists\n * @see https://developer.github.com/v3/gists/#list-starred-gists\n * @param {Requestable.callback} [cb] - will receive the list of gists\n * @return {Promise} - the promise for the http request\n */\n listStarredGists(cb) {\n return this._request('GET', this.__getScopedUrl('gists/starred'), null, cb);\n }\n\n /**\n * List the user's gists\n * @see https://developer.github.com/v3/gists/#list-a-users-gists\n * @param {Requestable.callback} [cb] - will receive the list of gists\n * @return {Promise} - the promise for the http request\n */\n listStarredGists(cb) {\n return this._request('GET', this.__getScopedUrl('gists'), null, cb);\n }\n\n /**\n * List the user's notifications\n * @see https://developer.github.com/v3/activity/notifications/#list-your-notifications\n * @param {Object} [options={}] - any options to refine the search\n * @param {Requestable.callback} [cb] - will receive the list of repositories\n * @return {Promise} - the promise for the http request\n */\n listNotifications(options, cb) {\n options = options || {};\n if (typeof options === 'function') {\n cb = options;\n options = {};\n }\n\n options.since = this._dateToISO(options.since);\n options.before = this._dateToISO(options.before);\n\n return this._request('GET', this.__getScopedUrl('notifications'), options, cb);\n }\n\n /**\n * Show the user's profile\n * @see https://developer.github.com/v3/users/#get-a-single-user\n * @param {Requestable.callback} [cb] - will receive the user's information\n * @return {Promise} - the promise for the http request\n */\n getProfile(cb) {\n return this._request('GET', this.__getScopedUrl(''), null, cb);\n }\n\n /**\n * Gets the list of starred repositories for the user\n * @see https://developer.github.com/v3/activity/starring/#list-repositories-being-starred\n * @param {Requestable.callback} [cb] - will receive the list of starred repositories\n * @return {Promise} - the promise for the http request\n */\n listStarredRepos(cb) {\n let requestOptions = this._getOptionsWithDefaults();\n return this._requestAllPages(this.__getScopedUrl('starred'), requestOptions, cb);\n }\n\n /**\n * List email addresses for a user\n * @see https://developer.github.com/v3/users/emails/#list-email-addresses-for-a-user\n * @param {Requestable.callback} [cb] - will receive the list of emails\n * @return {Promise} - the promise for the http request\n */\n getEmails(cb) {\n return this._request('GET', '/user/emails', null, cb);\n }\n\n /**\n * Have the authenticated user follow this user\n * @see https://developer.github.com/v3/users/followers/#follow-a-user\n * @param {string} username - the user to follow\n * @param {Requestable.callback} [cb] - will receive true if the request succeeds\n * @return {Promise} - the promise for the http request\n */\n follow(username, cb) {\n return this._request('PUT', `/user/following/${this.__user}`, null, cb);\n }\n\n /**\n * Have the currently authenticated user unfollow this user\n * @see https://developer.github.com/v3/users/followers/#follow-a-user\n * @param {string} username - the user to unfollow\n * @param {Requestable.callback} [cb] - receives true if the request succeeds\n * @return {Promise} - the promise for the http request\n */\n unfollow(username, cb) {\n return this._request('DELETE', `/user/following/${this.__user}`, null, cb);\n }\n\n /**\n * Create a new repository for the currently authenticated user\n * @see https://developer.github.com/v3/repos/#create\n * @param {object} options - the repository definition\n * @param {Requestable.callback} [cb] - will receive the API response\n * @return {Promise} - the promise for the http request\n */\n createRepo(options, cb) {\n return this._request('POST', '/user/repos', options, cb);\n }\n}\n\nmodule.exports = User;\n"],"preExistingComment":"//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["node_modules/browser-pack/_prelude.js","lib/Gist.js","lib/GitHub.js","lib/Issue.js","lib/Markdown.js","lib/Organization.js","lib/Project.js","lib/RateLimit.js","lib/Repository.js","lib/Requestable.js","lib/Search.js","lib/Team.js","lib/User.js"],"names":[],"mappings":"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","file":"generated.js","sourceRoot":"","sourcesContent":["(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require==\"function\"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error(\"Cannot find module '\"+o+\"'\");throw f.code=\"MODULE_NOT_FOUND\",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require==\"function\"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})","/**\n * @file\n * @copyright  2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license    Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n *             Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\n\n/**\n * A Gist can retrieve and modify gists.\n */\nclass Gist extends Requestable {\n   /**\n    * Create a Gist.\n    * @param {string} id - the id of the gist (not required when creating a gist)\n    * @param {Requestable.auth} [auth] - information required to authenticate to Github\n    * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n    */\n   constructor(id, auth, apiBase) {\n      super(auth, apiBase);\n      this.__id = id;\n   }\n\n   /**\n    * Fetch a gist.\n    * @see https://developer.github.com/v3/gists/#get-a-single-gist\n    * @param {Requestable.callback} [cb] - will receive the gist\n    * @return {Promise} - the Promise for the http request\n    */\n   read(cb) {\n      return this._request('GET', `/gists/${this.__id}`, null, cb);\n   }\n\n   /**\n    * Create a new gist.\n    * @see https://developer.github.com/v3/gists/#create-a-gist\n    * @param {Object} gist - the data for the new gist\n    * @param {Requestable.callback} [cb] - will receive the new gist upon creation\n    * @return {Promise} - the Promise for the http request\n    */\n   create(gist, cb) {\n      return this._request('POST', '/gists', gist, cb)\n         .then((response) => {\n            this.__id = response.data.id;\n            return response;\n         });\n   }\n\n   /**\n    * Delete a gist.\n    * @see https://developer.github.com/v3/gists/#delete-a-gist\n    * @param {Requestable.callback} [cb] - will receive true if the request succeeds\n    * @return {Promise} - the Promise for the http request\n    */\n   delete(cb) {\n      return this._request('DELETE', `/gists/${this.__id}`, null, cb);\n   }\n\n   /**\n    * Fork a gist.\n    * @see https://developer.github.com/v3/gists/#fork-a-gist\n    * @param {Requestable.callback} [cb] - the function that will receive the gist\n    * @return {Promise} - the Promise for the http request\n    */\n   fork(cb) {\n      return this._request('POST', `/gists/${this.__id}/forks`, null, cb);\n   }\n\n   /**\n    * Update a gist.\n    * @see https://developer.github.com/v3/gists/#edit-a-gist\n    * @param {Object} gist - the new data for the gist\n    * @param {Requestable.callback} [cb] - the function that receives the API result\n    * @return {Promise} - the Promise for the http request\n    */\n   update(gist, cb) {\n      return this._request('PATCH', `/gists/${this.__id}`, gist, cb);\n   }\n\n   /**\n    * Star a gist.\n    * @see https://developer.github.com/v3/gists/#star-a-gist\n    * @param {Requestable.callback} [cb] - will receive true if the request is successful\n    * @return {Promise} - the Promise for the http request\n    */\n   star(cb) {\n      return this._request('PUT', `/gists/${this.__id}/star`, null, cb);\n   }\n\n   /**\n    * Unstar a gist.\n    * @see https://developer.github.com/v3/gists/#unstar-a-gist\n    * @param {Requestable.callback} [cb] - will receive true if the request is successful\n    * @return {Promise} - the Promise for the http request\n    */\n   unstar(cb) {\n      return this._request('DELETE', `/gists/${this.__id}/star`, null, cb);\n   }\n\n   /**\n    * Check if a gist is starred by the user.\n    * @see https://developer.github.com/v3/gists/#check-if-a-gist-is-starred\n    * @param {Requestable.callback} [cb] - will receive true if the gist is starred and false if the gist is not starred\n    * @return {Promise} - the Promise for the http request\n    */\n   isStarred(cb) {\n      return this._request204or404(`/gists/${this.__id}/star`, null, cb);\n   }\n\n   /**\n    * List the gist's commits\n    * @see https://developer.github.com/v3/gists/#list-gist-commits\n    * @param {Requestable.callback} [cb] - will receive the array of commits\n    * @return {Promise} - the Promise for the http request\n    */\n   listCommits(cb) {\n      return this._requestAllPages(`/gists/${this.__id}/commits`, null, cb);\n   }\n\n   /**\n    * Fetch one of the gist's revision.\n    * @see https://developer.github.com/v3/gists/#get-a-specific-revision-of-a-gist\n    * @param {string} revision - the id of the revision\n    * @param {Requestable.callback} [cb] - will receive the revision\n    * @return {Promise} - the Promise for the http request\n    */\n   getRevision(revision, cb) {\n      return this._request('GET', `/gists/${this.__id}/${revision}`, null, cb);\n   }\n\n   /**\n    * List the gist's comments\n    * @see https://developer.github.com/v3/gists/comments/#list-comments-on-a-gist\n    * @param {Requestable.callback} [cb] - will receive the array of comments\n    * @return {Promise} - the promise for the http request\n    */\n   listComments(cb) {\n      return this._requestAllPages(`/gists/${this.__id}/comments`, null, cb);\n   }\n\n   /**\n    * Fetch one of the gist's comments\n    * @see https://developer.github.com/v3/gists/comments/#get-a-single-comment\n    * @param {number} comment - the id of the comment\n    * @param {Requestable.callback} [cb] - will receive the comment\n    * @return {Promise} - the Promise for the http request\n    */\n   getComment(comment, cb) {\n      return this._request('GET', `/gists/${this.__id}/comments/${comment}`, null, cb);\n   }\n\n   /**\n    * Comment on a gist\n    * @see https://developer.github.com/v3/gists/comments/#create-a-comment\n    * @param {string} comment - the comment to add\n    * @param {Requestable.callback} [cb] - the function that receives the API result\n    * @return {Promise} - the Promise for the http request\n    */\n   createComment(comment, cb) {\n      return this._request('POST', `/gists/${this.__id}/comments`, {body: comment}, cb);\n   }\n\n   /**\n    * Edit a comment on the gist\n    * @see https://developer.github.com/v3/gists/comments/#edit-a-comment\n    * @param {number} comment - the id of the comment\n    * @param {string} body - the new comment\n    * @param {Requestable.callback} [cb] - will receive the modified comment\n    * @return {Promise} - the promise for the http request\n    */\n   editComment(comment, body, cb) {\n      return this._request('PATCH', `/gists/${this.__id}/comments/${comment}`, {body: body}, cb);\n   }\n\n   /**\n    * Delete a comment on the gist.\n    * @see https://developer.github.com/v3/gists/comments/#delete-a-comment\n    * @param {number} comment - the id of the comment\n    * @param {Requestable.callback} [cb] - will receive true if the request succeeds\n    * @return {Promise} - the Promise for the http request\n    */\n   deleteComment(comment, cb) {\n      return this._request('DELETE', `/gists/${this.__id}/comments/${comment}`, null, cb);\n   }\n}\n\nmodule.exports = Gist;\n","/**\n * @file\n * @copyright  2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license    Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n *             Github.js is freely distributable.\n */\n/* eslint valid-jsdoc: [\"error\", {\"requireReturnDescription\": false}] */\n\nimport Gist from './Gist';\nimport User from './User';\nimport Issue from './Issue';\nimport Search from './Search';\nimport RateLimit from './RateLimit';\nimport Repository from './Repository';\nimport Organization from './Organization';\nimport Team from './Team';\nimport Markdown from './Markdown';\nimport Project from './Project';\n\n/**\n * GitHub encapsulates the functionality to create various API wrapper objects.\n */\nclass GitHub {\n   /**\n    * Create a new GitHub.\n    * @param {Requestable.auth} [auth] - the credentials to authenticate to Github. If auth is\n    *                                  not provided requests will be made unauthenticated\n    * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n    */\n   constructor(auth, apiBase = 'https://api.github.com') {\n      this.__apiBase = apiBase;\n      this.__auth = auth || {};\n   }\n\n   /**\n    * Create a new Gist wrapper\n    * @param {number} [id] - the id for the gist, leave undefined when creating a new gist\n    * @return {Gist}\n    */\n   getGist(id) {\n      return new Gist(id, this.__auth, this.__apiBase);\n   }\n\n   /**\n    * Create a new User wrapper\n    * @param {string} [user] - the name of the user to get information about\n    *                        leave undefined for the authenticated user\n    * @return {User}\n    */\n   getUser(user) {\n      return new User(user, this.__auth, this.__apiBase);\n   }\n\n   /**\n    * Create a new Organization wrapper\n    * @param {string} organization - the name of the organization\n    * @return {Organization}\n    */\n   getOrganization(organization) {\n      return new Organization(organization, this.__auth, this.__apiBase);\n   }\n\n   /**\n    * create a new Team wrapper\n    * @param {string} teamId - the name of the team\n    * @return {team}\n    */\n   getTeam(teamId) {\n      return new Team(teamId, this.__auth, this.__apiBase);\n   }\n\n   /**\n    * Create a new Repository wrapper\n    * @param {string} user - the user who owns the respository\n    * @param {string} repo - the name of the repository\n    * @return {Repository}\n    */\n   getRepo(user, repo) {\n      return new Repository(this._getFullName(user, repo), this.__auth, this.__apiBase);\n   }\n\n   /**\n    * Create a new Issue wrapper\n    * @param {string} user - the user who owns the respository\n    * @param {string} repo - the name of the repository\n    * @return {Issue}\n    */\n   getIssues(user, repo) {\n      return new Issue(this._getFullName(user, repo), this.__auth, this.__apiBase);\n   }\n\n   /**\n    * Create a new Search wrapper\n    * @param {string} query - the query to search for\n    * @return {Search}\n    */\n   search(query) {\n      return new Search(query, this.__auth, this.__apiBase);\n   }\n\n   /**\n    * Create a new RateLimit wrapper\n    * @return {RateLimit}\n    */\n   getRateLimit() {\n      return new RateLimit(this.__auth, this.__apiBase);\n   }\n\n   /**\n    * Create a new Markdown wrapper\n    * @return {Markdown}\n    */\n   getMarkdown() {\n      return new Markdown(this.__auth, this.__apiBase);\n   }\n\n   /**\n    * Create a new Project wrapper\n    * @param {string} id - the id of the project\n    * @return {Markdown}\n    */\n   getProject(id) {\n      return new Project(id, this.__auth, this.__apiBase);\n   }\n\n   /**\n    * Computes the full repository name\n    * @param {string} user - the username (or the full name)\n    * @param {string} repo - the repository name, must not be passed if `user` is the full name\n    * @return {string} the repository's full name\n    */\n   _getFullName(user, repo) {\n      let fullname = user;\n\n      if (repo) {\n         fullname = `${user}/${repo}`;\n      }\n\n      return fullname;\n   }\n}\n\nmodule.exports = GitHub;\n","/**\n * @file\n * @copyright  2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license    Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n *             Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\n\n/**\n * Issue wraps the functionality to get issues for repositories\n */\nclass Issue extends Requestable {\n   /**\n    * Create a new Issue\n    * @param {string} repository - the full name of the repository (`:user/:repo`) to get issues for\n    * @param {Requestable.auth} [auth] - information required to authenticate to Github\n    * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n    */\n   constructor(repository, auth, apiBase) {\n      super(auth, apiBase);\n      this.__repository = repository;\n   }\n\n   /**\n    * Create a new issue\n    * @see https://developer.github.com/v3/issues/#create-an-issue\n    * @param {Object} issueData - the issue to create\n    * @param {Requestable.callback} [cb] - will receive the created issue\n    * @return {Promise} - the promise for the http request\n    */\n   createIssue(issueData, cb) {\n      return this._request('POST', `/repos/${this.__repository}/issues`, issueData, cb);\n   }\n\n   /**\n    * List the issues for the repository\n    * @see https://developer.github.com/v3/issues/#list-issues-for-a-repository\n    * @param {Object} options - filtering options\n    * @param {Requestable.callback} [cb] - will receive the array of issues\n    * @return {Promise} - the promise for the http request\n    */\n   listIssues(options, cb) {\n      return this._requestAllPages(`/repos/${this.__repository}/issues`, options, cb);\n   }\n\n   /**\n    * List the events for an issue\n    * @see https://developer.github.com/v3/issues/events/#list-events-for-an-issue\n    * @param {number} issue - the issue to get events for\n    * @param {Requestable.callback} [cb] - will receive the list of events\n    * @return {Promise} - the promise for the http request\n    */\n   listIssueEvents(issue, cb) {\n      return this._request('GET', `/repos/${this.__repository}/issues/${issue}/events`, null, cb);\n   }\n\n   /**\n    * List comments on an issue\n    * @see https://developer.github.com/v3/issues/comments/#list-comments-on-an-issue\n    * @param {number} issue - the id of the issue to get comments from\n    * @param {Requestable.callback} [cb] - will receive the comments\n    * @return {Promise} - the promise for the http request\n    */\n   listIssueComments(issue, cb) {\n      return this._request('GET', `/repos/${this.__repository}/issues/${issue}/comments`, null, cb);\n   }\n\n   /**\n    * Get a single comment on an issue\n    * @see https://developer.github.com/v3/issues/comments/#get-a-single-comment\n    * @param {number} id - the comment id to get\n    * @param {Requestable.callback} [cb] - will receive the comment\n    * @return {Promise} - the promise for the http request\n    */\n   getIssueComment(id, cb) {\n      return this._request('GET', `/repos/${this.__repository}/issues/comments/${id}`, null, cb);\n   }\n\n   /**\n    * Comment on an issue\n    * @see https://developer.github.com/v3/issues/comments/#create-a-comment\n    * @param {number} issue - the id of the issue to comment on\n    * @param {string} comment - the comment to add\n    * @param {Requestable.callback} [cb] - will receive the created comment\n    * @return {Promise} - the promise for the http request\n    */\n   createIssueComment(issue, comment, cb) {\n      return this._request('POST', `/repos/${this.__repository}/issues/${issue}/comments`, {body: comment}, cb);\n   }\n\n   /**\n    * Edit a comment on an issue\n    * @see https://developer.github.com/v3/issues/comments/#edit-a-comment\n    * @param {number} id - the comment id to edit\n    * @param {string} comment - the comment to edit\n    * @param {Requestable.callback} [cb] - will receive the edited comment\n    * @return {Promise} - the promise for the http request\n    */\n   editIssueComment(id, comment, cb) {\n      return this._request('PATCH', `/repos/${this.__repository}/issues/comments/${id}`, {body: comment}, cb);\n   }\n\n   /**\n    * Delete a comment on an issue\n    * @see https://developer.github.com/v3/issues/comments/#delete-a-comment\n    * @param {number} id - the comment id to delete\n    * @param {Requestable.callback} [cb] - will receive true if the request is successful\n    * @return {Promise} - the promise for the http request\n    */\n   deleteIssueComment(id, cb) {\n      return this._request('DELETE', `/repos/${this.__repository}/issues/comments/${id}`, null, cb);\n   }\n\n   /**\n    * Edit an issue\n    * @see https://developer.github.com/v3/issues/#edit-an-issue\n    * @param {number} issue - the issue number to edit\n    * @param {Object} issueData - the new issue data\n    * @param {Requestable.callback} [cb] - will receive the modified issue\n    * @return {Promise} - the promise for the http request\n    */\n   editIssue(issue, issueData, cb) {\n      return this._request('PATCH', `/repos/${this.__repository}/issues/${issue}`, issueData, cb);\n   }\n\n   /**\n    * Get a particular issue\n    * @see https://developer.github.com/v3/issues/#get-a-single-issue\n    * @param {number} issue - the issue number to fetch\n    * @param {Requestable.callback} [cb] - will receive the issue\n    * @return {Promise} - the promise for the http request\n    */\n   getIssue(issue, cb) {\n      return this._request('GET', `/repos/${this.__repository}/issues/${issue}`, null, cb);\n   }\n\n   /**\n    * List the milestones for the repository\n    * @see https://developer.github.com/v3/issues/milestones/#list-milestones-for-a-repository\n    * @param {Object} options - filtering options\n    * @param {Requestable.callback} [cb] - will receive the array of milestones\n    * @return {Promise} - the promise for the http request\n    */\n   listMilestones(options, cb) {\n      return this._request('GET', `/repos/${this.__repository}/milestones`, options, cb);\n   }\n\n   /**\n    * Get a milestone\n    * @see https://developer.github.com/v3/issues/milestones/#get-a-single-milestone\n    * @param {string} milestone - the id of the milestone to fetch\n    * @param {Requestable.callback} [cb] - will receive the milestone\n    * @return {Promise} - the promise for the http request\n    */\n   getMilestone(milestone, cb) {\n      return this._request('GET', `/repos/${this.__repository}/milestones/${milestone}`, null, cb);\n   }\n\n   /**\n    * Create a new milestone\n    * @see https://developer.github.com/v3/issues/milestones/#create-a-milestone\n    * @param {Object} milestoneData - the milestone definition\n    * @param {Requestable.callback} [cb] - will receive the milestone\n    * @return {Promise} - the promise for the http request\n    */\n   createMilestone(milestoneData, cb) {\n      return this._request('POST', `/repos/${this.__repository}/milestones`, milestoneData, cb);\n   }\n\n   /**\n    * Edit a milestone\n    * @see https://developer.github.com/v3/issues/milestones/#update-a-milestone\n    * @param {string} milestone - the id of the milestone to edit\n    * @param {Object} milestoneData - the updates to make to the milestone\n    * @param {Requestable.callback} [cb] - will receive the updated milestone\n    * @return {Promise} - the promise for the http request\n    */\n   editMilestone(milestone, milestoneData, cb) {\n      return this._request('PATCH', `/repos/${this.__repository}/milestones/${milestone}`, milestoneData, cb);\n   }\n\n   /**\n    * Delete a milestone (this is distinct from closing a milestone)\n    * @see https://developer.github.com/v3/issues/milestones/#delete-a-milestone\n    * @param {string} milestone - the id of the milestone to delete\n    * @param {Requestable.callback} [cb] - will receive the status\n    * @return {Promise} - the promise for the http request\n    */\n   deleteMilestone(milestone, cb) {\n      return this._request('DELETE', `/repos/${this.__repository}/milestones/${milestone}`, null, cb);\n   }\n\n   /**\n    * Create a new label\n    * @see https://developer.github.com/v3/issues/labels/#create-a-label\n    * @param {Object} labelData - the label definition\n    * @param {Requestable.callback} [cb] - will receive the object representing the label\n    * @return {Promise} - the promise for the http request\n    */\n   createLabel(labelData, cb) {\n      return this._request('POST', `/repos/${this.__repository}/labels`, labelData, cb);\n   }\n\n  /**\n   * List the labels for the repository\n   * @see https://developer.github.com/v3/issues/labels/#list-all-labels-for-this-repository\n   * @param {Object} options - filtering options\n   * @param {Requestable.callback} [cb] - will receive the array of labels\n   * @return {Promise} - the promise for the http request\n   */\n   listLabels(options, cb) {\n      return this._request('GET', `/repos/${this.__repository}/labels`, options, cb);\n   }\n\n  /**\n   * Get a label\n   * @see https://developer.github.com/v3/issues/labels/#get-a-single-label\n   * @param {string} label - the name of the label to fetch\n   * @param {Requestable.callback} [cb] - will receive the label\n   * @return {Promise} - the promise for the http request\n   */\n   getLabel(label, cb) {\n      return this._request('GET', `/repos/${this.__repository}/labels/${label}`, null, cb);\n   }\n\n  /**\n   * Edit a label\n   * @see https://developer.github.com/v3/issues/labels/#update-a-label\n   * @param {string} label - the name of the label to edit\n   * @param {Object} labelData - the updates to make to the label\n   * @param {Requestable.callback} [cb] - will receive the updated label\n   * @return {Promise} - the promise for the http request\n   */\n   editLabel(label, labelData, cb) {\n      return this._request('PATCH', `/repos/${this.__repository}/labels/${label}`, labelData, cb);\n   }\n\n  /**\n   * Delete a label\n   * @see https://developer.github.com/v3/issues/labels/#delete-a-label\n   * @param {string} label - the name of the label to delete\n   * @param {Requestable.callback} [cb] - will receive the status\n   * @return {Promise} - the promise for the http request\n   */\n   deleteLabel(label, cb) {\n      return this._request('DELETE', `/repos/${this.__repository}/labels/${label}`, null, cb);\n   }\n}\n\nmodule.exports = Issue;\n","/**\n * @file\n * @copyright  2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license    Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n *             Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\n\n/**\n * Renders html from Markdown text\n */\nclass Markdown extends Requestable {\n   /**\n    * construct a Markdown\n    * @param {Requestable.auth} auth - the credentials to authenticate to GitHub\n    * @param {string} [apiBase] - the base Github API URL\n    * @return {Promise} - the promise for the http request\n    */\n   constructor(auth, apiBase) {\n      super(auth, apiBase);\n   }\n\n   /**\n    * Render html from Markdown text.\n    * @see https://developer.github.com/v3/markdown/#render-an-arbitrary-markdown-document\n    * @param {Object} options - conversion options\n    * @param {string} [options.text] - the markdown text to convert\n    * @param {string} [options.mode=markdown] - can be either `markdown` or `gfm`\n    * @param {string} [options.context] - repository name if mode is gfm\n    * @param {Requestable.callback} [cb] - will receive the converted html\n    * @return {Promise} - the promise for the http request\n    */\n   render(options, cb) {\n      return this._request('POST', '/markdown', options, cb);\n   }\n}\n\nmodule.exports = Markdown;\n","/**\n * @file\n * @copyright  2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license    Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n *             Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\n\n/**\n * Organization encapsulates the functionality to create repositories in organizations\n */\nclass Organization extends Requestable {\n   /**\n    * Create a new Organization\n    * @param {string} organization - the name of the organization\n    * @param {Requestable.auth} [auth] - information required to authenticate to Github\n    * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n    */\n   constructor(organization, auth, apiBase) {\n      super(auth, apiBase);\n      this.__name = organization;\n   }\n\n   /**\n    * Create a repository in an organization\n    * @see https://developer.github.com/v3/repos/#create\n    * @param {Object} options - the repository definition\n    * @param {Requestable.callback} [cb] - will receive the created repository\n    * @return {Promise} - the promise for the http request\n    */\n   createRepo(options, cb) {\n      return this._request('POST', `/orgs/${this.__name}/repos`, options, cb);\n   }\n\n   /**\n    * List the repositories in an organization\n    * @see https://developer.github.com/v3/repos/#list-organization-repositories\n    * @param {Requestable.callback} [cb] - will receive the list of repositories\n    * @return {Promise} - the promise for the http request\n    */\n   getRepos(cb) {\n      let requestOptions = this._getOptionsWithDefaults({direction: 'desc'});\n\n      return this._requestAllPages(`/orgs/${this.__name}/repos`, requestOptions, cb);\n   }\n\n   /**\n    * Query if the user is a member or not\n    * @param {string} username - the user in question\n    * @param {Requestable.callback} [cb] - will receive true if the user is a member\n    * @return {Promise} - the promise for the http request\n    */\n   isMember(username, cb) {\n      return this._request204or404(`/orgs/${this.__name}/members/${username}`, null, cb);\n   }\n\n   /**\n    * List the users who are members of the company\n    * @see https://developer.github.com/v3/orgs/members/#members-list\n    * @param {object} options - filtering options\n    * @param {string} [options.filter=all] - can be either `2fa_disabled` or `all`\n    * @param {string} [options.role=all] - can be one of: `all`, `admin`, or `member`\n    * @param {Requestable.callback} [cb] - will receive the list of users\n    * @return {Promise} - the promise for the http request\n    */\n   listMembers(options, cb) {\n      return this._request('GET', `/orgs/${this.__name}/members`, options, cb);\n   }\n\n   /**\n    * List the Teams in the Organization\n    * @see https://developer.github.com/v3/orgs/teams/#list-teams\n    * @param {Requestable.callback} [cb] - will receive the list of teams\n    * @return {Promise} - the promise for the http request\n    */\n   getTeams(cb) {\n      return this._requestAllPages(`/orgs/${this.__name}/teams`, undefined, cb);\n   }\n\n   /**\n    * Create a team\n    * @see https://developer.github.com/v3/orgs/teams/#create-team\n    * @param {object} options - Team creation parameters\n    * @param {string} options.name - The name of the team\n    * @param {string} [options.description] - Team description\n    * @param {string} [options.repo_names] - Repos to add the team to\n    * @param {string} [options.privacy=secret] - The level of privacy the team should have. Can be either one\n    * of: `secret`, or `closed`\n    * @param {Requestable.callback} [cb] - will receive the created team\n    * @return {Promise} - the promise for the http request\n    */\n   createTeam(options, cb) {\n      return this._request('POST', `/orgs/${this.__name}/teams`, options, cb);\n   }\n\n   /**\n    * Get information about all projects\n    * @see https://developer.github.com/v3/projects/#list-organization-projects\n    * @param {Requestable.callback} [cb] - will receive the list of projects\n    * @return {Promise} - the promise for the http request\n    */\n   listProjects(cb) {\n      return this._requestAllPages(`/orgs/${this.__name}/projects`, {AcceptHeader: 'inertia-preview'}, cb);\n   }\n\n   /**\n    * Create a new project\n    * @see https://developer.github.com/v3/repos/projects/#create-a-project\n    * @param {Object} options - the description of the project\n    * @param {Requestable.callback} cb - will receive the newly created project\n    * @return {Promise} - the promise for the http request\n    */\n   createProject(options, cb) {\n      options = options || {};\n      options.AcceptHeader = 'inertia-preview';\n      return this._request('POST', `/orgs/${this.__name}/projects`, options, cb);\n   }\n}\n\nmodule.exports = Organization;\n","/**\n * @file\n * @copyright  2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license    Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n *             Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\n\n/**\n * Project encapsulates the functionality to create, query, and modify cards and columns.\n */\nclass Project extends Requestable {\n   /**\n    * Create a Project.\n    * @param {string} id - the id of the project\n    * @param {Requestable.auth} [auth] - information required to authenticate to Github\n    * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n    */\n   constructor(id, auth, apiBase) {\n      super(auth, apiBase, 'inertia-preview');\n      this.__id = id;\n   }\n\n   /**\n    * Get information about a project\n    * @see https://developer.github.com/v3/projects/#get-a-project\n    * @param {Requestable.callback} cb - will receive the project information\n    * @return {Promise} - the promise for the http request\n    */\n   getProject(cb) {\n      return this._request('GET', `/projects/${this.__id}`, null, cb);\n   }\n\n   /**\n    * Edit a project\n    * @see https://developer.github.com/v3/projects/#update-a-project\n    * @param {Object} options - the description of the project\n    * @param {Requestable.callback} cb - will receive the modified project\n    * @return {Promise} - the promise for the http request\n    */\n   updateProject(options, cb) {\n      return this._request('PATCH', `/projects/${this.__id}`, options, cb);\n   }\n\n   /**\n    * Delete a project\n    * @see https://developer.github.com/v3/projects/#delete-a-project\n    * @param {Requestable.callback} cb - will receive true if the operation is successful\n    * @return {Promise} - the promise for the http request\n    */\n   deleteProject(cb) {\n      return this._request('DELETE', `/projects/${this.__id}`, null, cb);\n   }\n\n   /**\n    * Get information about all columns of a project\n    * @see https://developer.github.com/v3/projects/columns/#list-project-columns\n    * @param {Requestable.callback} [cb] - will receive the list of columns\n    * @return {Promise} - the promise for the http request\n    */\n   listProjectColumns(cb) {\n      return this._requestAllPages(`/projects/${this.__id}/columns`, null, cb);\n   }\n\n   /**\n    * Get information about a column\n    * @see https://developer.github.com/v3/projects/columns/#get-a-project-column\n    * @param {string} colId - the id of the column\n    * @param {Requestable.callback} cb - will receive the column information\n    * @return {Promise} - the promise for the http request\n    */\n   getProjectColumn(colId, cb) {\n      return this._request('GET', `/projects/columns/${colId}`, null, cb);\n   }\n\n   /**\n    * Create a new column\n    * @see https://developer.github.com/v3/projects/columns/#create-a-project-column\n    * @param {Object} options - the description of the column\n    * @param {Requestable.callback} cb - will receive the newly created column\n    * @return {Promise} - the promise for the http request\n    */\n   createProjectColumn(options, cb) {\n      return this._request('POST', `/projects/${this.__id}/columns`, options, cb);\n   }\n\n   /**\n    * Edit a column\n    * @see https://developer.github.com/v3/projects/columns/#update-a-project-column\n    * @param {string} colId - the column id\n    * @param {Object} options - the description of the column\n    * @param {Requestable.callback} cb - will receive the modified column\n    * @return {Promise} - the promise for the http request\n    */\n   updateProjectColumn(colId, options, cb) {\n      return this._request('PATCH', `/projects/columns/${colId}`, options, cb);\n   }\n\n   /**\n    * Delete a column\n    * @see https://developer.github.com/v3/projects/columns/#delete-a-project-column\n    * @param {string} colId - the column to be deleted\n    * @param {Requestable.callback} cb - will receive true if the operation is successful\n    * @return {Promise} - the promise for the http request\n    */\n   deleteProjectColumn(colId, cb) {\n      return this._request('DELETE', `/projects/columns/${colId}`, null, cb);\n   }\n\n   /**\n    * Move a column\n    * @see https://developer.github.com/v3/projects/columns/#move-a-project-column\n    * @param {string} colId - the column to be moved\n    * @param {string} position - can be one of first, last, or after:<column-id>,\n    * where <column-id> is the id value of a column in the same project.\n    * @param {Requestable.callback} cb - will receive true if the operation is successful\n    * @return {Promise} - the promise for the http request\n    */\n   moveProjectColumn(colId, position, cb) {\n      return this._request(\n         'POST',\n         `/projects/columns/${colId}/moves`,\n         {position: position},\n         cb\n      );\n   }\n\n  /**\n   * Get information about all cards of a project\n   * @see https://developer.github.com/v3/projects/cards/#list-project-cards\n   * @param {Requestable.callback} [cb] - will receive the list of cards\n   * @return {Promise} - the promise for the http request\n   */\n   listProjectCards(cb) {\n      return this.listProjectColumns()\n        .then(({data}) => {\n           return Promise.all(data.map((column) => {\n              return this._requestAllPages(`/projects/columns/${column.id}/cards`, null);\n           }));\n        }).then((cardsInColumns) => {\n           const cards = cardsInColumns.reduce((prev, {data}) => {\n              prev.push(...data);\n              return prev;\n           }, []);\n           if (cb) {\n              cb(null, cards);\n           }\n           return cards;\n        }).catch((err) => {\n           if (cb) {\n              cb(err);\n              return;\n           }\n           throw err;\n        });\n   }\n\n   /**\n   * Get information about all cards of a column\n   * @see https://developer.github.com/v3/projects/cards/#list-project-cards\n   * @param {string} colId - the id of the column\n   * @param {Requestable.callback} [cb] - will receive the list of cards\n   * @return {Promise} - the promise for the http request\n   */\n   listColumnCards(colId, cb) {\n      return this._requestAllPages(`/projects/columns/${colId}/cards`, null, cb);\n   }\n\n   /**\n   * Get information about a card\n   * @see https://developer.github.com/v3/projects/cards/#get-a-project-card\n   * @param {string} cardId - the id of the card\n   * @param {Requestable.callback} cb - will receive the card information\n   * @return {Promise} - the promise for the http request\n   */\n   getProjectCard(cardId, cb) {\n      return this._request('GET', `/projects/columns/cards/${cardId}`, null, cb);\n   }\n\n   /**\n   * Create a new card\n   * @see https://developer.github.com/v3/projects/cards/#create-a-project-card\n   * @param {string} colId - the column id\n   * @param {Object} options - the description of the card\n   * @param {Requestable.callback} cb - will receive the newly created card\n   * @return {Promise} - the promise for the http request\n   */\n   createProjectCard(colId, options, cb) {\n      return this._request('POST', `/projects/columns/${colId}/cards`, options, cb);\n   }\n\n   /**\n   * Edit a card\n   * @see https://developer.github.com/v3/projects/cards/#update-a-project-card\n   * @param {string} cardId - the card id\n   * @param {Object} options - the description of the card\n   * @param {Requestable.callback} cb - will receive the modified card\n   * @return {Promise} - the promise for the http request\n   */\n   updateProjectCard(cardId, options, cb) {\n      return this._request('PATCH', `/projects/columns/cards/${cardId}`, options, cb);\n   }\n\n   /**\n   * Delete a card\n   * @see https://developer.github.com/v3/projects/cards/#delete-a-project-card\n   * @param {string} cardId - the card to be deleted\n   * @param {Requestable.callback} cb - will receive true if the operation is successful\n   * @return {Promise} - the promise for the http request\n   */\n   deleteProjectCard(cardId, cb) {\n      return this._request('DELETE', `/projects/columns/cards/${cardId}`, null, cb);\n   }\n\n   /**\n   * Move a card\n   * @see https://developer.github.com/v3/projects/cards/#move-a-project-card\n   * @param {string} cardId - the card to be moved\n   * @param {string} position - can be one of top, bottom, or after:<card-id>,\n   * where <card-id> is the id value of a card in the same project.\n   * @param {string} colId - the id value of a column in the same project.\n   * @param {Requestable.callback} cb - will receive true if the operation is successful\n   * @return {Promise} - the promise for the http request\n   */\n   moveProjectCard(cardId, position, colId, cb) {\n      return this._request(\n         'POST',\n         `/projects/columns/cards/${cardId}/moves`,\n         {position: position, column_id: colId}, // eslint-disable-line camelcase\n         cb\n      );\n   }\n}\n\nmodule.exports = Project;\n","/**\n * @file\n * @copyright  2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license    Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n *             Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\n\n/**\n * RateLimit allows users to query their rate-limit status\n */\nclass RateLimit extends Requestable {\n   /**\n    * construct a RateLimit\n    * @param {Requestable.auth} auth - the credentials to authenticate to GitHub\n    * @param {string} [apiBase] - the base Github API URL\n    * @return {Promise} - the promise for the http request\n    */\n   constructor(auth, apiBase) {\n      super(auth, apiBase);\n   }\n\n   /**\n    * Query the current rate limit\n    * @see https://developer.github.com/v3/rate_limit/\n    * @param {Requestable.callback} [cb] - will receive the rate-limit data\n    * @return {Promise} - the promise for the http request\n    */\n   getRateLimit(cb) {\n      return this._request('GET', '/rate_limit', null, cb);\n   }\n}\n\nmodule.exports = RateLimit;\n","/**\n * @file\n * @copyright  2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license    Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n *             Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\nimport Utf8 from 'utf8';\nimport {\n   Base64,\n} from 'js-base64';\nimport debug from 'debug';\nconst log = debug('github:repository');\n\n/**\n * Respository encapsulates the functionality to create, query, and modify files.\n */\nclass Repository extends Requestable {\n   /**\n    * Create a Repository.\n    * @param {string} fullname - the full name of the repository\n    * @param {Requestable.auth} [auth] - information required to authenticate to Github\n    * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n    */\n   constructor(fullname, auth, apiBase) {\n      super(auth, apiBase);\n      this.__fullname = fullname;\n      this.__currentTree = {\n         branch: null,\n         sha: null,\n      };\n   }\n\n   /**\n    * Get a reference\n    * @see https://developer.github.com/v3/git/refs/#get-a-reference\n    * @param {string} ref - the reference to get\n    * @param {Requestable.callback} [cb] - will receive the reference's refSpec or a list of refSpecs that match `ref`\n    * @return {Promise} - the promise for the http request\n    */\n   getRef(ref, cb) {\n      return this._request('GET', `/repos/${this.__fullname}/git/refs/${ref}`, null, cb);\n   }\n\n   /**\n    * Create a reference\n    * @see https://developer.github.com/v3/git/refs/#create-a-reference\n    * @param {Object} options - the object describing the ref\n    * @param {Requestable.callback} [cb] - will receive the ref\n    * @return {Promise} - the promise for the http request\n    */\n   createRef(options, cb) {\n      return this._request('POST', `/repos/${this.__fullname}/git/refs`, options, cb);\n   }\n\n   /**\n    * Delete a reference\n    * @see https://developer.github.com/v3/git/refs/#delete-a-reference\n    * @param {string} ref - the name of the ref to delte\n    * @param {Requestable.callback} [cb] - will receive true if the request is successful\n    * @return {Promise} - the promise for the http request\n    */\n   deleteRef(ref, cb) {\n      return this._request('DELETE', `/repos/${this.__fullname}/git/refs/${ref}`, null, cb);\n   }\n\n   /**\n    * Delete a repository\n    * @see https://developer.github.com/v3/repos/#delete-a-repository\n    * @param {Requestable.callback} [cb] - will receive true if the request is successful\n    * @return {Promise} - the promise for the http request\n    */\n   deleteRepo(cb) {\n      return this._request('DELETE', `/repos/${this.__fullname}`, null, cb);\n   }\n\n   /**\n    * List the tags on a repository\n    * @see https://developer.github.com/v3/repos/#list-tags\n    * @param {Requestable.callback} [cb] - will receive the tag data\n    * @return {Promise} - the promise for the http request\n    */\n   listTags(cb) {\n      return this._request('GET', `/repos/${this.__fullname}/tags`, null, cb);\n   }\n\n   /**\n    * List the open pull requests on the repository\n    * @see https://developer.github.com/v3/pulls/#list-pull-requests\n    * @param {Object} options - options to filter the search\n    * @param {Requestable.callback} [cb] - will receive the list of PRs\n    * @return {Promise} - the promise for the http request\n    */\n   listPullRequests(options, cb) {\n      options = options || {};\n      return this._request('GET', `/repos/${this.__fullname}/pulls`, options, cb);\n   }\n\n   /**\n    * Get information about a specific pull request\n    * @see https://developer.github.com/v3/pulls/#get-a-single-pull-request\n    * @param {number} number - the PR you wish to fetch\n    * @param {Requestable.callback} [cb] - will receive the PR from the API\n    * @return {Promise} - the promise for the http request\n    */\n   getPullRequest(number, cb) {\n      return this._request('GET', `/repos/${this.__fullname}/pulls/${number}`, null, cb);\n   }\n\n   /**\n    * List the files of a specific pull request\n    * @see https://developer.github.com/v3/pulls/#list-pull-requests-files\n    * @param {number|string} number - the PR you wish to fetch\n    * @param {Requestable.callback} [cb] - will receive the list of files from the API\n    * @return {Promise} - the promise for the http request\n    */\n   listPullRequestFiles(number, cb) {\n      return this._request('GET', `/repos/${this.__fullname}/pulls/${number}/files`, null, cb);\n   }\n\n   /**\n    * Compare two branches/commits/repositories\n    * @see https://developer.github.com/v3/repos/commits/#compare-two-commits\n    * @param {string} base - the base commit\n    * @param {string} head - the head commit\n    * @param {Requestable.callback} cb - will receive the comparison\n    * @return {Promise} - the promise for the http request\n    */\n   compareBranches(base, head, cb) {\n      return this._request('GET', `/repos/${this.__fullname}/compare/${base}...${head}`, null, cb);\n   }\n\n   /**\n    * List all the branches for the repository\n    * @see https://developer.github.com/v3/repos/#list-branches\n    * @param {Requestable.callback} cb - will receive the list of branches\n    * @return {Promise} - the promise for the http request\n    */\n   listBranches(cb) {\n      return this._request('GET', `/repos/${this.__fullname}/branches`, null, cb);\n   }\n\n   /**\n    * Get a raw blob from the repository\n    * @see https://developer.github.com/v3/git/blobs/#get-a-blob\n    * @param {string} sha - the sha of the blob to fetch\n    * @param {Requestable.callback} cb - will receive the blob from the API\n    * @return {Promise} - the promise for the http request\n    */\n   getBlob(sha, cb) {\n      return this._request('GET', `/repos/${this.__fullname}/git/blobs/${sha}`, null, cb, 'raw');\n   }\n\n   /**\n    * Get a single branch\n    * @see https://developer.github.com/v3/repos/branches/#get-branch\n    * @param {string} branch - the name of the branch to fetch\n    * @param {Requestable.callback} cb - will receive the branch from the API\n    * @returns {Promise} - the promise for the http request\n    */\n   getBranch(branch, cb) {\n      return this._request('GET', `/repos/${this.__fullname}/branches/${branch}`, null, cb);\n   }\n\n   /**\n    * Get a commit from the repository\n    * @see https://developer.github.com/v3/repos/commits/#get-a-single-commit\n    * @param {string} sha - the sha for the commit to fetch\n    * @param {Requestable.callback} cb - will receive the commit data\n    * @return {Promise} - the promise for the http request\n    */\n   getCommit(sha, cb) {\n      return this._request('GET', `/repos/${this.__fullname}/git/commits/${sha}`, null, cb);\n   }\n\n   /**\n    * List the commits on a repository, optionally filtering by path, author or time range\n    * @see https://developer.github.com/v3/repos/commits/#list-commits-on-a-repository\n    * @param {Object} [options] - the filtering options for commits\n    * @param {string} [options.sha] - the SHA or branch to start from\n    * @param {string} [options.path] - the path to search on\n    * @param {string} [options.author] - the commit author\n    * @param {(Date|string)} [options.since] - only commits after this date will be returned\n    * @param {(Date|string)} [options.until] - only commits before this date will be returned\n    * @param {Requestable.callback} cb - will receive the list of commits found matching the criteria\n    * @return {Promise} - the promise for the http request\n    */\n   listCommits(options, cb) {\n      options = options || {};\n\n      options.since = this._dateToISO(options.since);\n      options.until = this._dateToISO(options.until);\n\n      return this._request('GET', `/repos/${this.__fullname}/commits`, options, cb);\n   }\n\n    /**\n     * Gets a single commit information for a repository\n     * @see https://developer.github.com/v3/repos/commits/#get-a-single-commit\n     * @param {string} ref - the reference for the commit-ish\n     * @param {Requestable.callback} cb - will receive the commit information\n     * @return {Promise} - the promise for the http request\n     */\n   getSingleCommit(ref, cb) {\n      ref = ref || '';\n      return this._request('GET', `/repos/${this.__fullname}/commits/${ref}`, null, cb);\n   }\n\n   /**\n    * Get tha sha for a particular object in the repository. This is a convenience function\n    * @see https://developer.github.com/v3/repos/contents/#get-contents\n    * @param {string} [branch] - the branch to look in, or the repository's default branch if omitted\n    * @param {string} path - the path of the file or directory\n    * @param {Requestable.callback} cb - will receive a description of the requested object, including a `SHA` property\n    * @return {Promise} - the promise for the http request\n    */\n   getSha(branch, path, cb) {\n      branch = branch ? `?ref=${branch}` : '';\n      return this._request('GET', `/repos/${this.__fullname}/contents/${path}${branch}`, null, cb);\n   }\n\n   /**\n    * List the commit statuses for a particular sha, branch, or tag\n    * @see https://developer.github.com/v3/repos/statuses/#list-statuses-for-a-specific-ref\n    * @param {string} sha - the sha, branch, or tag to get statuses for\n    * @param {Requestable.callback} cb - will receive the list of statuses\n    * @return {Promise} - the promise for the http request\n    */\n   listStatuses(sha, cb) {\n      return this._request('GET', `/repos/${this.__fullname}/commits/${sha}/statuses`, null, cb);\n   }\n\n   /**\n    * Get a description of a git tree\n    * @see https://developer.github.com/v3/git/trees/#get-a-tree\n    * @param {string} treeSHA - the SHA of the tree to fetch\n    * @param {Requestable.callback} cb - will receive the callback data\n    * @return {Promise} - the promise for the http request\n    */\n   getTree(treeSHA, cb) {\n      return this._request('GET', `/repos/${this.__fullname}/git/trees/${treeSHA}`, null, cb);\n   }\n\n   /**\n    * Create a blob\n    * @see https://developer.github.com/v3/git/blobs/#create-a-blob\n    * @param {(string|Buffer|Blob)} content - the content to add to the repository\n    * @param {Requestable.callback} cb - will receive the details of the created blob\n    * @return {Promise} - the promise for the http request\n    */\n   createBlob(content, cb) {\n      let postBody = this._getContentObject(content);\n\n      log('sending content', postBody);\n      return this._request('POST', `/repos/${this.__fullname}/git/blobs`, postBody, cb);\n   }\n\n   /**\n    * Get the object that represents the provided content\n    * @param {string|Buffer|Blob} content - the content to send to the server\n    * @return {Object} the representation of `content` for the GitHub API\n    */\n   _getContentObject(content) {\n      if (typeof content === 'string') {\n         log('contet is a string');\n         return {\n            content: Utf8.encode(content),\n            encoding: 'utf-8',\n         };\n\n      } else if (typeof Buffer !== 'undefined' && content instanceof Buffer) {\n         log('We appear to be in Node');\n         return {\n            content: content.toString('base64'),\n            encoding: 'base64',\n         };\n\n      } else if (typeof Blob !== 'undefined' && content instanceof Blob) {\n         log('We appear to be in the browser');\n         return {\n            content: Base64.encode(content),\n            encoding: 'base64',\n         };\n\n      } else { // eslint-disable-line\n         log(`Not sure what this content is: ${typeof content}, ${JSON.stringify(content)}`);\n         throw new Error('Unknown content passed to postBlob. Must be string or Buffer (node) or Blob (web)');\n      }\n   }\n\n   /**\n    * Update a tree in Git\n    * @see https://developer.github.com/v3/git/trees/#create-a-tree\n    * @param {string} baseTreeSHA - the SHA of the tree to update\n    * @param {string} path - the path for the new file\n    * @param {string} blobSHA - the SHA for the blob to put at `path`\n    * @param {Requestable.callback} cb - will receive the new tree that is created\n    * @return {Promise} - the promise for the http request\n    * @deprecated use {@link Repository#createTree} instead\n    */\n   updateTree(baseTreeSHA, path, blobSHA, cb) {\n      let newTree = {\n         base_tree: baseTreeSHA, // eslint-disable-line\n         tree: [{\n            path: path,\n            sha: blobSHA,\n            mode: '100644',\n            type: 'blob',\n         }],\n      };\n\n      return this._request('POST', `/repos/${this.__fullname}/git/trees`, newTree, cb);\n   }\n\n   /**\n    * Create a new tree in git\n    * @see https://developer.github.com/v3/git/trees/#create-a-tree\n    * @param {Object} tree - the tree to create\n    * @param {string} baseSHA - the root sha of the tree\n    * @param {Requestable.callback} cb - will receive the new tree that is created\n    * @return {Promise} - the promise for the http request\n    */\n   createTree(tree, baseSHA, cb) {\n      return this._request('POST', `/repos/${this.__fullname}/git/trees`, {\n         tree,\n         base_tree: baseSHA, // eslint-disable-line camelcase\n      }, cb);\n   }\n\n   /**\n    * Add a commit to the repository\n    * @see https://developer.github.com/v3/git/commits/#create-a-commit\n    * @param {string} parent - the SHA of the parent commit\n    * @param {string} tree - the SHA of the tree for this commit\n    * @param {string} message - the commit message\n    * @param {Requestable.callback} cb - will receive the commit that is created\n    * @return {Promise} - the promise for the http request\n    */\n   commit(parent, tree, message, cb) {\n      let data = {\n         message,\n         tree,\n         parents: [parent],\n      };\n\n      return this._request('POST', `/repos/${this.__fullname}/git/commits`, data, cb)\n         .then((response) => {\n            this.__currentTree.sha = response.data.sha; // Update latest commit\n            return response;\n         });\n   }\n\n   /**\n    * Update a ref\n    * @see https://developer.github.com/v3/git/refs/#update-a-reference\n    * @param {string} ref - the ref to update\n    * @param {string} commitSHA - the SHA to point the reference to\n    * @param {boolean} force - indicates whether to force or ensure a fast-forward update\n    * @param {Requestable.callback} cb - will receive the updated ref back\n    * @return {Promise} - the promise for the http request\n    */\n   updateHead(ref, commitSHA, force, cb) {\n      return this._request('PATCH', `/repos/${this.__fullname}/git/refs/${ref}`, {\n         sha: commitSHA,\n         force: force,\n      }, cb);\n   }\n\n   /**\n    * Update commit status\n    * @see https://developer.github.com/v3/repos/statuses/\n    * @param {string} commitSHA - the SHA of the commit that should be updated\n    * @param {object} options - Commit status parameters\n    * @param {string} options.state - The state of the status. Can be one of: pending, success, error, or failure.\n    * @param {string} [options.target_url] - The target URL to associate with this status.\n    * @param {string} [options.description] - A short description of the status.\n    * @param {string} [options.context] - A string label to differentiate this status among CI systems.\n    * @param {Requestable.callback} cb - will receive the updated commit back\n    * @return {Promise} - the promise for the http request\n    */\n   updateStatus(commitSHA, options, cb) {\n      return this._request('POST', `/repos/${this.__fullname}/statuses/${commitSHA}`, options, cb);\n   }\n\n   /**\n    * Update repository information\n    * @see https://developer.github.com/v3/repos/#edit\n    * @param {object} options - New parameters that will be set to the repository\n    * @param {string} options.name - Name of the repository\n    * @param {string} [options.description] - A short description of the repository\n    * @param {string} [options.homepage] - A URL with more information about the repository\n    * @param {boolean} [options.private] - Either true to make the repository private, or false to make it public.\n    * @param {boolean} [options.has_issues] - Either true to enable issues for this repository, false to disable them.\n    * @param {boolean} [options.has_wiki] - Either true to enable the wiki for this repository, false to disable it.\n    * @param {boolean} [options.has_downloads] - Either true to enable downloads, false to disable them.\n    * @param {string} [options.default_branch] - Updates the default branch for this repository.\n    * @param {Requestable.callback} cb - will receive the updated repository back\n    * @return {Promise} - the promise for the http request\n    */\n   updateRepository(options, cb) {\n      return this._request('PATCH', `/repos/${this.__fullname}`, options, cb);\n   }\n\n  /**\n    * Get information about the repository\n    * @see https://developer.github.com/v3/repos/#get\n    * @param {Requestable.callback} cb - will receive the information about the repository\n    * @return {Promise} - the promise for the http request\n    */\n   getDetails(cb) {\n      return this._request('GET', `/repos/${this.__fullname}`, null, cb);\n   }\n\n   /**\n    * List the contributors to the repository\n    * @see https://developer.github.com/v3/repos/#list-contributors\n    * @param {Requestable.callback} cb - will receive the list of contributors\n    * @return {Promise} - the promise for the http request\n    */\n   getContributors(cb) {\n      return this._request('GET', `/repos/${this.__fullname}/contributors`, null, cb);\n   }\n\n   /**\n    * List the contributor stats to the repository\n    * @see https://developer.github.com/v3/repos/#list-contributors\n    * @param {Requestable.callback} cb - will receive the list of contributors\n    * @return {Promise} - the promise for the http request\n    */\n   getContributorStats(cb) {\n      return this._request('GET', `/repos/${this.__fullname}/stats/contributors`, null, cb);\n   }\n\n   /**\n    * List the users who are collaborators on the repository. The currently authenticated user must have\n    * push access to use this method\n    * @see https://developer.github.com/v3/repos/collaborators/#list-collaborators\n    * @param {Requestable.callback} cb - will receive the list of collaborators\n    * @return {Promise} - the promise for the http request\n    */\n   getCollaborators(cb) {\n      return this._request('GET', `/repos/${this.__fullname}/collaborators`, null, cb);\n   }\n\n   /**\n    * Check if a user is a collaborator on the repository\n    * @see https://developer.github.com/v3/repos/collaborators/#check-if-a-user-is-a-collaborator\n    * @param {string} username - the user to check\n    * @param {Requestable.callback} cb - will receive true if the user is a collaborator and false if they are not\n    * @return {Promise} - the promise for the http request {Boolean} [description]\n    */\n   isCollaborator(username, cb) {\n      return this._request('GET', `/repos/${this.__fullname}/collaborators/${username}`, null, cb);\n   }\n\n   /**\n    * Get the contents of a repository\n    * @see https://developer.github.com/v3/repos/contents/#get-contents\n    * @param {string} ref - the ref to check\n    * @param {string} path - the path containing the content to fetch\n    * @param {boolean} raw - `true` if the results should be returned raw instead of GitHub's normalized format\n    * @param {Requestable.callback} cb - will receive the fetched data\n    * @return {Promise} - the promise for the http request\n    */\n   getContents(ref, path, raw, cb) {\n      path = path ? `${encodeURI(path)}` : '';\n      return this._request('GET', `/repos/${this.__fullname}/contents/${path}`, {\n         ref,\n      }, cb, raw);\n   }\n\n   /**\n    * Get the README of a repository\n    * @see https://developer.github.com/v3/repos/contents/#get-the-readme\n    * @param {string} ref - the ref to check\n    * @param {boolean} raw - `true` if the results should be returned raw instead of GitHub's normalized format\n    * @param {Requestable.callback} cb - will receive the fetched data\n    * @return {Promise} - the promise for the http request\n    */\n   getReadme(ref, raw, cb) {\n      return this._request('GET', `/repos/${this.__fullname}/readme`, {\n         ref,\n      }, cb, raw);\n   }\n\n   /**\n    * Fork a repository\n    * @see https://developer.github.com/v3/repos/forks/#create-a-fork\n    * @param {Requestable.callback} cb - will receive the information about the newly created fork\n    * @return {Promise} - the promise for the http request\n    */\n   fork(cb) {\n      return this._request('POST', `/repos/${this.__fullname}/forks`, null, cb);\n   }\n\n   /**\n    * List a repository's forks\n    * @see https://developer.github.com/v3/repos/forks/#list-forks\n    * @param {Requestable.callback} cb - will receive the list of repositories forked from this one\n    * @return {Promise} - the promise for the http request\n    */\n   listForks(cb) {\n      return this._request('GET', `/repos/${this.__fullname}/forks`, null, cb);\n   }\n\n   /**\n    * Create a new branch from an existing branch.\n    * @param {string} [oldBranch=master] - the name of the existing branch\n    * @param {string} newBranch - the name of the new branch\n    * @param {Requestable.callback} cb - will receive the commit data for the head of the new branch\n    * @return {Promise} - the promise for the http request\n    */\n   createBranch(oldBranch, newBranch, cb) {\n      if (typeof newBranch === 'function') {\n         cb = newBranch;\n         newBranch = oldBranch;\n         oldBranch = 'master';\n      }\n\n      return this.getRef(`heads/${oldBranch}`)\n         .then((response) => {\n            let sha = response.data.object.sha;\n            return this.createRef({\n               sha,\n               ref: `refs/heads/${newBranch}`,\n            }, cb);\n         });\n   }\n\n   /**\n    * Create a new pull request\n    * @see https://developer.github.com/v3/pulls/#create-a-pull-request\n    * @param {Object} options - the pull request description\n    * @param {Requestable.callback} cb - will receive the new pull request\n    * @return {Promise} - the promise for the http request\n    */\n   createPullRequest(options, cb) {\n      return this._request('POST', `/repos/${this.__fullname}/pulls`, options, cb);\n   }\n\n   /**\n    * Update a pull request\n    * @see https://developer.github.com/v3/pulls/#update-a-pull-request\n    * @param {number|string} number - the number of the pull request to update\n    * @param {Object} options - the pull request description\n    * @param {Requestable.callback} [cb] - will receive the pull request information\n    * @return {Promise} - the promise for the http request\n    */\n   updatePullRequest(number, options, cb) {\n      return this._request('PATCH', `/repos/${this.__fullname}/pulls/${number}`, options, cb);\n   }\n\n   /**\n    * List the hooks for the repository\n    * @see https://developer.github.com/v3/repos/hooks/#list-hooks\n    * @param {Requestable.callback} cb - will receive the list of hooks\n    * @return {Promise} - the promise for the http request\n    */\n   listHooks(cb) {\n      return this._request('GET', `/repos/${this.__fullname}/hooks`, null, cb);\n   }\n\n   /**\n    * Get a hook for the repository\n    * @see https://developer.github.com/v3/repos/hooks/#get-single-hook\n    * @param {number} id - the id of the webook\n    * @param {Requestable.callback} cb - will receive the details of the webook\n    * @return {Promise} - the promise for the http request\n    */\n   getHook(id, cb) {\n      return this._request('GET', `/repos/${this.__fullname}/hooks/${id}`, null, cb);\n   }\n\n   /**\n    * Add a new hook to the repository\n    * @see https://developer.github.com/v3/repos/hooks/#create-a-hook\n    * @param {Object} options - the configuration describing the new hook\n    * @param {Requestable.callback} cb - will receive the new webhook\n    * @return {Promise} - the promise for the http request\n    */\n   createHook(options, cb) {\n      return this._request('POST', `/repos/${this.__fullname}/hooks`, options, cb);\n   }\n\n   /**\n    * Edit an existing webhook\n    * @see https://developer.github.com/v3/repos/hooks/#edit-a-hook\n    * @param {number} id - the id of the webhook\n    * @param {Object} options - the new description of the webhook\n    * @param {Requestable.callback} cb - will receive the updated webhook\n    * @return {Promise} - the promise for the http request\n    */\n   updateHook(id, options, cb) {\n      return this._request('PATCH', `/repos/${this.__fullname}/hooks/${id}`, options, cb);\n   }\n\n   /**\n    * Delete a webhook\n    * @see https://developer.github.com/v3/repos/hooks/#delete-a-hook\n    * @param {number} id - the id of the webhook to be deleted\n    * @param {Requestable.callback} cb - will receive true if the call is successful\n    * @return {Promise} - the promise for the http request\n    */\n   deleteHook(id, cb) {\n      return this._request('DELETE', `/repos/${this.__fullname}/hooks/${id}`, null, cb);\n   }\n\n   /**\n    * List the deploy keys for the repository\n    * @see https://developer.github.com/v3/repos/keys/#list-deploy-keys\n    * @param {Requestable.callback} cb - will receive the list of deploy keys\n    * @return {Promise} - the promise for the http request\n    */\n   listKeys(cb) {\n      return this._request('GET', `/repos/${this.__fullname}/keys`, null, cb);\n   }\n\n   /**\n    * Get a deploy key for the repository\n    * @see https://developer.github.com/v3/repos/keys/#get-a-deploy-key\n    * @param {number} id - the id of the deploy key\n    * @param {Requestable.callback} cb - will receive the details of the deploy key\n    * @return {Promise} - the promise for the http request\n    */\n   getKey(id, cb) {\n      return this._request('GET', `/repos/${this.__fullname}/keys/${id}`, null, cb);\n   }\n\n   /**\n    * Add a new deploy key to the repository\n    * @see https://developer.github.com/v3/repos/keys/#add-a-new-deploy-key\n    * @param {Object} options - the configuration describing the new deploy key\n    * @param {Requestable.callback} cb - will receive the new deploy key\n    * @return {Promise} - the promise for the http request\n    */\n   createKey(options, cb) {\n      return this._request('POST', `/repos/${this.__fullname}/keys`, options, cb);\n   }\n\n   /**\n    * Delete a deploy key\n    * @see https://developer.github.com/v3/repos/keys/#remove-a-deploy-key\n    * @param {number} id - the id of the deploy key to be deleted\n    * @param {Requestable.callback} cb - will receive true if the call is successful\n    * @return {Promise} - the promise for the http request\n    */\n   deleteKey(id, cb) {\n      return this._request('DELETE', `/repos/${this.__fullname}/keys/${id}`, null, cb);\n   }\n\n   /**\n    * Delete a file from a branch\n    * @see https://developer.github.com/v3/repos/contents/#delete-a-file\n    * @param {string} branch - the branch to delete from, or the default branch if not specified\n    * @param {string} path - the path of the file to remove\n    * @param {Requestable.callback} cb - will receive the commit in which the delete occurred\n    * @return {Promise} - the promise for the http request\n    */\n   deleteFile(branch, path, cb) {\n      return this.getSha(branch, path)\n         .then((response) => {\n            const deleteCommit = {\n               message: `Delete the file at '${path}'`,\n               sha: response.data.sha,\n               branch,\n            };\n            return this._request('DELETE', `/repos/${this.__fullname}/contents/${path}`, deleteCommit, cb);\n         });\n   }\n\n   /**\n    * Change all references in a repo from oldPath to new_path\n    * @param {string} branch - the branch to carry out the reference change, or the default branch if not specified\n    * @param {string} oldPath - original path\n    * @param {string} newPath - new reference path\n    * @param {Requestable.callback} cb - will receive the commit in which the move occurred\n    * @return {Promise} - the promise for the http request\n    */\n   move(branch, oldPath, newPath, cb) {\n      let oldSha;\n      return this.getRef(`heads/${branch}`)\n         .then(({data: {object}}) => this.getTree(`${object.sha}?recursive=true`))\n         .then(({data: {tree, sha}}) => {\n            oldSha = sha;\n            let newTree = tree.map((ref) => {\n               if (ref.path === oldPath) {\n                  ref.path = newPath;\n               }\n               if (ref.type === 'tree') {\n                  delete ref.sha;\n               }\n               return ref;\n            });\n            return this.createTree(newTree);\n         })\n         .then(({data: tree}) => this.commit(oldSha, tree.sha, `Renamed '${oldPath}' to '${newPath}'`))\n         .then(({data: commit}) => this.updateHead(`heads/${branch}`, commit.sha, true, cb));\n   }\n\n   /**\n    * Write a file to the repository\n    * @see https://developer.github.com/v3/repos/contents/#update-a-file\n    * @param {string} branch - the name of the branch\n    * @param {string} path - the path for the file\n    * @param {string} content - the contents of the file\n    * @param {string} message - the commit message\n    * @param {Object} [options] - commit options\n    * @param {Object} [options.author] - the author of the commit\n    * @param {Object} [options.commiter] - the committer\n    * @param {boolean} [options.encode] - true if the content should be base64 encoded\n    * @param {Requestable.callback} cb - will receive the new commit\n    * @return {Promise} - the promise for the http request\n    */\n   writeFile(branch, path, content, message, options, cb) {\n      if (typeof options === 'function') {\n         cb = options;\n         options = {};\n      }\n      let filePath = path ? encodeURI(path) : '';\n      let shouldEncode = options.encode !== false;\n      let commit = {\n         branch,\n         message,\n         author: options.author,\n         committer: options.committer,\n         content: shouldEncode ? Base64.encode(content) : content,\n      };\n\n      return this.getSha(branch, filePath)\n         .then((response) => {\n            commit.sha = response.data.sha;\n            return this._request('PUT', `/repos/${this.__fullname}/contents/${filePath}`, commit, cb);\n         }, () => {\n            return this._request('PUT', `/repos/${this.__fullname}/contents/${filePath}`, commit, cb);\n         });\n   }\n\n   /**\n    * Check if a repository is starred by you\n    * @see https://developer.github.com/v3/activity/starring/#check-if-you-are-starring-a-repository\n    * @param {Requestable.callback} cb - will receive true if the repository is starred and false if the repository\n    *                                  is not starred\n    * @return {Promise} - the promise for the http request {Boolean} [description]\n    */\n   isStarred(cb) {\n      return this._request204or404(`/user/starred/${this.__fullname}`, null, cb);\n   }\n\n   /**\n    * Star a repository\n    * @see https://developer.github.com/v3/activity/starring/#star-a-repository\n    * @param {Requestable.callback} cb - will receive true if the repository is starred\n    * @return {Promise} - the promise for the http request\n    */\n   star(cb) {\n      return this._request('PUT', `/user/starred/${this.__fullname}`, null, cb);\n   }\n\n   /**\n    * Unstar a repository\n    * @see https://developer.github.com/v3/activity/starring/#unstar-a-repository\n    * @param {Requestable.callback} cb - will receive true if the repository is unstarred\n    * @return {Promise} - the promise for the http request\n    */\n   unstar(cb) {\n      return this._request('DELETE', `/user/starred/${this.__fullname}`, null, cb);\n   }\n\n   /**\n    * Create a new release\n    * @see https://developer.github.com/v3/repos/releases/#create-a-release\n    * @param {Object} options - the description of the release\n    * @param {Requestable.callback} cb - will receive the newly created release\n    * @return {Promise} - the promise for the http request\n    */\n   createRelease(options, cb) {\n      return this._request('POST', `/repos/${this.__fullname}/releases`, options, cb);\n   }\n\n   /**\n    * Edit a release\n    * @see https://developer.github.com/v3/repos/releases/#edit-a-release\n    * @param {string} id - the id of the release\n    * @param {Object} options - the description of the release\n    * @param {Requestable.callback} cb - will receive the modified release\n    * @return {Promise} - the promise for the http request\n    */\n   updateRelease(id, options, cb) {\n      return this._request('PATCH', `/repos/${this.__fullname}/releases/${id}`, options, cb);\n   }\n\n   /**\n    * Get information about all releases\n    * @see https://developer.github.com/v3/repos/releases/#list-releases-for-a-repository\n    * @param {Requestable.callback} cb - will receive the release information\n    * @return {Promise} - the promise for the http request\n    */\n   listReleases(cb) {\n      return this._request('GET', `/repos/${this.__fullname}/releases`, null, cb);\n   }\n\n   /**\n    * Get information about a release\n    * @see https://developer.github.com/v3/repos/releases/#get-a-single-release\n    * @param {string} id - the id of the release\n    * @param {Requestable.callback} cb - will receive the release information\n    * @return {Promise} - the promise for the http request\n    */\n   getRelease(id, cb) {\n      return this._request('GET', `/repos/${this.__fullname}/releases/${id}`, null, cb);\n   }\n\n   /**\n    * Delete a release\n    * @see https://developer.github.com/v3/repos/releases/#delete-a-release\n    * @param {string} id - the release to be deleted\n    * @param {Requestable.callback} cb - will receive true if the operation is successful\n    * @return {Promise} - the promise for the http request\n    */\n   deleteRelease(id, cb) {\n      return this._request('DELETE', `/repos/${this.__fullname}/releases/${id}`, null, cb);\n   }\n\n   /**\n    * Merge a pull request\n    * @see https://developer.github.com/v3/pulls/#merge-a-pull-request-merge-button\n    * @param {number|string} number - the number of the pull request to merge\n    * @param {Object} options - the merge options for the pull request\n    * @param {Requestable.callback} [cb] - will receive the merge information if the operation is successful\n    * @return {Promise} - the promise for the http request\n    */\n   mergePullRequest(number, options, cb) {\n      return this._request('PUT', `/repos/${this.__fullname}/pulls/${number}/merge`, options, cb);\n   }\n\n   /**\n    * Get information about all projects\n    * @see https://developer.github.com/v3/projects/#list-repository-projects\n    * @param {Requestable.callback} [cb] - will receive the list of projects\n    * @return {Promise} - the promise for the http request\n    */\n   listProjects(cb) {\n      return this._requestAllPages(`/repos/${this.__fullname}/projects`, {AcceptHeader: 'inertia-preview'}, cb);\n   }\n\n   /**\n    * Create a new project\n    * @see https://developer.github.com/v3/projects/#create-a-repository-project\n    * @param {Object} options - the description of the project\n    * @param {Requestable.callback} cb - will receive the newly created project\n    * @return {Promise} - the promise for the http request\n    */\n   createProject(options, cb) {\n      options = options || {};\n      options.AcceptHeader = 'inertia-preview';\n      return this._request('POST', `/repos/${this.__fullname}/projects`, options, cb);\n   }\n\n}\n\nmodule.exports = Repository;\n","/**\n * @file\n * @copyright  2016 Yahoo Inc.\n * @license    Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n *             Github.js is freely distributable.\n */\n\nimport axios from 'axios';\nimport debug from 'debug';\nimport {Base64} from 'js-base64';\n\nconst log = debug('github:request');\n\n/**\n * The error structure returned when a network call fails\n */\nclass ResponseError extends Error {\n   /**\n    * Construct a new ResponseError\n    * @param {string} message - an message to return instead of the the default error message\n    * @param {string} path - the requested path\n    * @param {Object} response - the object returned by Axios\n    */\n   constructor(message, path, response) {\n      super(message);\n      this.path = path;\n      this.request = response.config;\n      this.response = (response || {}).response || response;\n      this.status = response.status;\n   }\n}\n\n/**\n * Requestable wraps the logic for making http requests to the API\n */\nclass Requestable {\n   /**\n    * Either a username and password or an oauth token for Github\n    * @typedef {Object} Requestable.auth\n    * @prop {string} [username] - the Github username\n    * @prop {string} [password] - the user's password\n    * @prop {token} [token] - an OAuth token\n    */\n   /**\n    * Initialize the http internals.\n    * @param {Requestable.auth} [auth] - the credentials to authenticate to Github. If auth is\n    *                                  not provided request will be made unauthenticated\n    * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n    * @param {string} [AcceptHeader=v3] - the accept header for the requests\n    */\n   constructor(auth, apiBase, AcceptHeader) {\n      this.__apiBase = apiBase || 'https://api.github.com';\n      this.__auth = {\n         token: auth.token,\n         username: auth.username,\n         password: auth.password,\n      };\n      this.__AcceptHeader = AcceptHeader || 'v3';\n\n      if (auth.token) {\n         this.__authorizationHeader = 'token ' + auth.token;\n      } else if (auth.username && auth.password) {\n         this.__authorizationHeader = 'Basic ' + Base64.encode(auth.username + ':' + auth.password);\n      }\n   }\n\n   /**\n    * Compute the URL to use to make a request.\n    * @private\n    * @param {string} path - either a URL relative to the API base or an absolute URL\n    * @return {string} - the URL to use\n    */\n   __getURL(path) {\n      let url = path;\n\n      if (path.indexOf('//') === -1) {\n         url = this.__apiBase + path;\n      }\n\n      let newCacheBuster = 'timestamp=' + new Date().getTime();\n      return url.replace(/(timestamp=\\d+)/, newCacheBuster);\n   }\n\n   /**\n    * Compute the headers required for an API request.\n    * @private\n    * @param {boolean} raw - if the request should be treated as JSON or as a raw request\n    * @param {string} AcceptHeader - the accept header for the request\n    * @return {Object} - the headers to use in the request\n    */\n   __getRequestHeaders(raw, AcceptHeader) {\n      let headers = {\n         'Content-Type': 'application/json;charset=UTF-8',\n         'Accept': 'application/vnd.github.' + (AcceptHeader || this.__AcceptHeader),\n      };\n\n      if (raw) {\n         headers.Accept += '.raw';\n      }\n      headers.Accept += '+json';\n\n      if (this.__authorizationHeader) {\n         headers.Authorization = this.__authorizationHeader;\n      }\n\n      return headers;\n   }\n\n   /**\n    * Sets the default options for API requests\n    * @protected\n    * @param {Object} [requestOptions={}] - the current options for the request\n    * @return {Object} - the options to pass to the request\n    */\n   _getOptionsWithDefaults(requestOptions = {}) {\n      if (!(requestOptions.visibility || requestOptions.affiliation)) {\n         requestOptions.type = requestOptions.type || 'all';\n      }\n      requestOptions.sort = requestOptions.sort || 'updated';\n      requestOptions.per_page = requestOptions.per_page || '100'; // eslint-disable-line\n\n      return requestOptions;\n   }\n\n   /**\n    * if a `Date` is passed to this function it will be converted to an ISO string\n    * @param {*} date - the object to attempt to cooerce into an ISO date string\n    * @return {string} - the ISO representation of `date` or whatever was passed in if it was not a date\n    */\n   _dateToISO(date) {\n      if (date && (date instanceof Date)) {\n         date = date.toISOString();\n      }\n\n      return date;\n   }\n\n   /**\n    * A function that receives the result of the API request.\n    * @callback Requestable.callback\n    * @param {Requestable.Error} error - the error returned by the API or `null`\n    * @param {(Object|true)} result - the data returned by the API or `true` if the API returns `204 No Content`\n    * @param {Object} request - the raw {@linkcode https://github.com/mzabriskie/axios#response-schema Response}\n    */\n   /**\n    * Make a request.\n    * @param {string} method - the method for the request (GET, PUT, POST, DELETE)\n    * @param {string} path - the path for the request\n    * @param {*} [data] - the data to send to the server. For HTTP methods that don't have a body the data\n    *                   will be sent as query parameters\n    * @param {Requestable.callback} [cb] - the callback for the request\n    * @param {boolean} [raw=false] - if the request should be sent as raw. If this is a falsy value then the\n    *                              request will be made as JSON\n    * @return {Promise} - the Promise for the http request\n    */\n   _request(method, path, data, cb, raw) {\n      const url = this.__getURL(path);\n\n      const AcceptHeader = (data || {}).AcceptHeader;\n      if (AcceptHeader) {\n         delete data.AcceptHeader;\n      }\n      const headers = this.__getRequestHeaders(raw, AcceptHeader);\n\n      let queryParams = {};\n\n      const shouldUseDataAsParams = data && (typeof data === 'object') && methodHasNoBody(method);\n      if (shouldUseDataAsParams) {\n         queryParams = data;\n         data = undefined;\n      }\n\n      const config = {\n         url: url,\n         method: method,\n         headers: headers,\n         params: queryParams,\n         data: data,\n         responseType: raw ? 'text' : 'json',\n      };\n\n      log(`${config.method} to ${config.url}`);\n      const requestPromise = axios(config).catch(callbackErrorOrThrow(cb, path));\n\n      if (cb) {\n         requestPromise.then((response) => {\n            if (response.data && Object.keys(response.data).length > 0) {\n               // When data has results\n               cb(null, response.data, response);\n            } else if (config.method !== 'GET' && Object.keys(response.data).length < 1) {\n               // True when successful submit a request and receive a empty object\n               cb(null, (response.status < 300), response);\n            } else {\n               cb(null, response.data, response);\n            }\n         });\n      }\n\n      return requestPromise;\n   }\n\n   /**\n    * Make a request to an endpoint the returns 204 when true and 404 when false\n    * @param {string} path - the path to request\n    * @param {Object} data - any query parameters for the request\n    * @param {Requestable.callback} cb - the callback that will receive `true` or `false`\n    * @param {method} [method=GET] - HTTP Method to use\n    * @return {Promise} - the promise for the http request\n    */\n   _request204or404(path, data, cb, method = 'GET') {\n      return this._request(method, path, data)\n         .then(function success(response) {\n            if (cb) {\n               cb(null, true, response);\n            }\n            return true;\n         }, function failure(response) {\n            if (response.response.status === 404) {\n               if (cb) {\n                  cb(null, false, response);\n               }\n               return false;\n            }\n\n            if (cb) {\n               cb(response);\n            }\n            throw response;\n         });\n   }\n\n   /**\n    * Make a request and fetch all the available data. Github will paginate responses so for queries\n    * that might span multiple pages this method is preferred to {@link Requestable#request}\n    * @param {string} path - the path to request\n    * @param {Object} options - the query parameters to include\n    * @param {Requestable.callback} [cb] - the function to receive the data. The returned data will always be an array.\n    * @param {Object[]} results - the partial results. This argument is intended for interal use only.\n    * @return {Promise} - a promise which will resolve when all pages have been fetched\n    * @deprecated This will be folded into {@link Requestable#_request} in the 2.0 release.\n    */\n   _requestAllPages(path, options, cb, results) {\n      results = results || [];\n\n      return this._request('GET', path, options)\n         .then((response) => {\n            let thisGroup;\n            if (response.data instanceof Array) {\n               thisGroup = response.data;\n            } else if (response.data.items instanceof Array) {\n               thisGroup = response.data.items;\n            } else {\n               let message = `cannot figure out how to append ${response.data} to the result set`;\n               throw new ResponseError(message, path, response);\n            }\n            results.push(...thisGroup);\n\n            const nextUrl = getNextPage(response.headers.link);\n            if (nextUrl && typeof options.page !== 'number') {\n               log(`getting next page: ${nextUrl}`);\n               return this._requestAllPages(nextUrl, options, cb, results);\n            }\n\n            if (cb) {\n               cb(null, results, response);\n            }\n\n            response.data = results;\n            return response;\n         }).catch(callbackErrorOrThrow(cb, path));\n   }\n}\n\nmodule.exports = Requestable;\n\n// ////////////////////////// //\n//  Private helper functions  //\n// ////////////////////////// //\nconst METHODS_WITH_NO_BODY = ['GET', 'HEAD', 'DELETE'];\nfunction methodHasNoBody(method) {\n   return METHODS_WITH_NO_BODY.indexOf(method) !== -1;\n}\n\nfunction getNextPage(linksHeader = '') {\n   const links = linksHeader.split(/\\s*,\\s*/); // splits and strips the urls\n   return links.reduce(function(nextUrl, link) {\n      if (link.search(/rel=\"next\"/) !== -1) {\n         return (link.match(/<(.*)>/) || [])[1];\n      }\n\n      return nextUrl;\n   }, undefined);\n}\n\nfunction callbackErrorOrThrow(cb, path) {\n   return function handler(object) {\n      let error;\n      if (object.hasOwnProperty('config')) {\n         const {response: {status, statusText}, config: {method, url}} = object;\n         let message = (`${status} error making request ${method} ${url}: \"${statusText}\"`);\n         error = new ResponseError(message, path, object);\n         log(`${message} ${JSON.stringify(object.data)}`);\n      } else {\n         error = object;\n      }\n      if (cb) {\n         log('going to error callback');\n         cb(error);\n      } else {\n         log('throwing error');\n         throw error;\n      }\n   };\n}\n","/**\n * @file\n * @copyright  2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license    Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n *             Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\nimport debug from 'debug';\nconst log = debug('github:search');\n\n/**\n * Wrap the Search API\n */\nclass Search extends Requestable {\n   /**\n    * Create a Search\n    * @param {Object} defaults - defaults for the search\n    * @param {Requestable.auth} [auth] - information required to authenticate to Github\n    * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n    */\n   constructor(defaults, auth, apiBase) {\n      super(auth, apiBase);\n      this.__defaults = this._getOptionsWithDefaults(defaults);\n   }\n\n   /**\n    * Available search options\n    * @see https://developer.github.com/v3/search/#parameters\n    * @typedef {Object} Search.Params\n    * @param {string} q - the query to make\n    * @param {string} sort - the sort field, one of `stars`, `forks`, or `updated`.\n    *                      Default is [best match](https://developer.github.com/v3/search/#ranking-search-results)\n    * @param {string} order - the ordering, either `asc` or `desc`\n    */\n   /**\n    * Perform a search on the GitHub API\n    * @private\n    * @param {string} path - the scope of the search\n    * @param {Search.Params} [withOptions] - additional parameters for the search\n    * @param {Requestable.callback} [cb] - will receive the results of the search\n    * @return {Promise} - the promise for the http request\n    */\n   _search(path, withOptions = {}, cb = undefined) {\n      let requestOptions = {};\n      Object.keys(this.__defaults).forEach((prop) => {\n         requestOptions[prop] = this.__defaults[prop];\n      });\n      Object.keys(withOptions).forEach((prop) => {\n         requestOptions[prop] = withOptions[prop];\n      });\n\n      log(`searching ${path} with options:`, requestOptions);\n      return this._requestAllPages(`/search/${path}`, requestOptions, cb);\n   }\n\n   /**\n    * Search for repositories\n    * @see https://developer.github.com/v3/search/#search-repositories\n    * @param {Search.Params} [options] - additional parameters for the search\n    * @param {Requestable.callback} [cb] - will receive the results of the search\n    * @return {Promise} - the promise for the http request\n    */\n   forRepositories(options, cb) {\n      return this._search('repositories', options, cb);\n   }\n\n   /**\n    * Search for code\n    * @see https://developer.github.com/v3/search/#search-code\n    * @param {Search.Params} [options] - additional parameters for the search\n    * @param {Requestable.callback} [cb] - will receive the results of the search\n    * @return {Promise} - the promise for the http request\n    */\n   forCode(options, cb) {\n      return this._search('code', options, cb);\n   }\n\n   /**\n    * Search for issues\n    * @see https://developer.github.com/v3/search/#search-issues\n    * @param {Search.Params} [options] - additional parameters for the search\n    * @param {Requestable.callback} [cb] - will receive the results of the search\n    * @return {Promise} - the promise for the http request\n    */\n   forIssues(options, cb) {\n      return this._search('issues', options, cb);\n   }\n\n   /**\n    * Search for users\n    * @see https://developer.github.com/v3/search/#search-users\n    * @param {Search.Params} [options] - additional parameters for the search\n    * @param {Requestable.callback} [cb] - will receive the results of the search\n    * @return {Promise} - the promise for the http request\n    */\n   forUsers(options, cb) {\n      return this._search('users', options, cb);\n   }\n}\n\nmodule.exports = Search;\n","/**\n * @file\n * @copyright  2016 Matt Smith (Development Seed)\n * @license    Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n *             Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\nimport debug from 'debug';\nconst log = debug('github:team');\n\n/**\n * A Team allows scoping of API requests to a particular Github Organization Team.\n */\nclass Team extends Requestable {\n   /**\n    * Create a Team.\n    * @param {string} [teamId] - the id for the team\n    * @param {Requestable.auth} [auth] - information required to authenticate to Github\n    * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n    */\n   constructor(teamId, auth, apiBase) {\n      super(auth, apiBase);\n      this.__teamId = teamId;\n   }\n\n   /**\n    * Get Team information\n    * @see https://developer.github.com/v3/orgs/teams/#get-team\n    * @param {Requestable.callback} [cb] - will receive the team\n    * @return {Promise} - the promise for the http request\n    */\n   getTeam(cb) {\n      log(`Fetching Team ${this.__teamId}`);\n      return this._request('Get', `/teams/${this.__teamId}`, undefined, cb);\n   }\n\n   /**\n    * List the Team's repositories\n    * @see https://developer.github.com/v3/orgs/teams/#list-team-repos\n    * @param {Requestable.callback} [cb] - will receive the list of repositories\n    * @return {Promise} - the promise for the http request\n    */\n   listRepos(cb) {\n      log(`Fetching repositories for Team ${this.__teamId}`);\n      return this._requestAllPages(`/teams/${this.__teamId}/repos`, undefined, cb);\n   }\n\n   /**\n    * Edit Team information\n    * @see https://developer.github.com/v3/orgs/teams/#edit-team\n    * @param {object} options - Parameters for team edit\n    * @param {string} options.name - The name of the team\n    * @param {string} [options.description] - Team description\n    * @param {string} [options.repo_names] - Repos to add the team to\n    * @param {string} [options.privacy=secret] - The level of privacy the team should have. Can be either one\n    * of: `secret`, or `closed`\n    * @param {Requestable.callback} [cb] - will receive the updated team\n    * @return {Promise} - the promise for the http request\n    */\n   editTeam(options, cb) {\n      log(`Editing Team ${this.__teamId}`);\n      return this._request('PATCH', `/teams/${this.__teamId}`, options, cb);\n   }\n\n   /**\n    * List the users who are members of the Team\n    * @see https://developer.github.com/v3/orgs/teams/#list-team-members\n    * @param {object} options - Parameters for listing team users\n    * @param {string} [options.role=all] - can be one of: `all`, `maintainer`, or `member`\n    * @param {Requestable.callback} [cb] - will receive the list of users\n    * @return {Promise} - the promise for the http request\n    */\n   listMembers(options, cb) {\n      log(`Getting members of Team ${this.__teamId}`);\n      return this._requestAllPages(`/teams/${this.__teamId}/members`, options, cb);\n   }\n\n   /**\n    * Get Team membership status for a user\n    * @see https://developer.github.com/v3/orgs/teams/#get-team-membership\n    * @param {string} username - can be one of: `all`, `maintainer`, or `member`\n    * @param {Requestable.callback} [cb] - will receive the membership status of a user\n    * @return {Promise} - the promise for the http request\n    */\n   getMembership(username, cb) {\n      log(`Getting membership of user ${username} in Team ${this.__teamId}`);\n      return this._request('GET', `/teams/${this.__teamId}/memberships/${username}`, undefined, cb);\n   }\n\n   /**\n    * Add a member to the Team\n    * @see https://developer.github.com/v3/orgs/teams/#add-team-membership\n    * @param {string} username - can be one of: `all`, `maintainer`, or `member`\n    * @param {object} options - Parameters for adding a team member\n    * @param {string} [options.role=member] - The role that this user should have in the team. Can be one\n    * of: `member`, or `maintainer`\n    * @param {Requestable.callback} [cb] - will receive the membership status of added user\n    * @return {Promise} - the promise for the http request\n    */\n   addMembership(username, options, cb) {\n      log(`Adding user ${username} to Team ${this.__teamId}`);\n      return this._request('PUT', `/teams/${this.__teamId}/memberships/${username}`, options, cb);\n   }\n\n   /**\n    * Get repo management status for team\n    * @see https://developer.github.com/v3/orgs/teams/#remove-team-membership\n    * @param {string} owner - Organization name\n    * @param {string} repo - Repo name\n    * @param {Requestable.callback} [cb] - will receive the membership status of added user\n    * @return {Promise} - the promise for the http request\n    */\n   isManagedRepo(owner, repo, cb) {\n      log(`Getting repo management by Team ${this.__teamId} for repo ${owner}/${repo}`);\n      return this._request204or404(`/teams/${this.__teamId}/repos/${owner}/${repo}`, undefined, cb);\n   }\n\n   /**\n    * Add or Update repo management status for team\n    * @see https://developer.github.com/v3/orgs/teams/#add-or-update-team-repository\n    * @param {string} owner - Organization name\n    * @param {string} repo - Repo name\n    * @param {object} options - Parameters for adding or updating repo management for the team\n    * @param {string} [options.permission] - The permission to grant the team on this repository. Can be one\n    * of: `pull`, `push`, or `admin`\n    * @param {Requestable.callback} [cb] - will receive the membership status of added user\n    * @return {Promise} - the promise for the http request\n    */\n   manageRepo(owner, repo, options, cb) {\n      log(`Adding or Updating repo management by Team ${this.__teamId} for repo ${owner}/${repo}`);\n      return this._request204or404(`/teams/${this.__teamId}/repos/${owner}/${repo}`, options, cb, 'PUT');\n   }\n\n   /**\n    * Remove repo management status for team\n    * @see https://developer.github.com/v3/orgs/teams/#remove-team-repository\n    * @param {string} owner - Organization name\n    * @param {string} repo - Repo name\n    * @param {Requestable.callback} [cb] - will receive the membership status of added user\n    * @return {Promise} - the promise for the http request\n    */\n   unmanageRepo(owner, repo, cb) {\n      log(`Remove repo management by Team ${this.__teamId} for repo ${owner}/${repo}`);\n      return this._request204or404(`/teams/${this.__teamId}/repos/${owner}/${repo}`, undefined, cb, 'DELETE');\n   }\n\n   /**\n    * Delete Team\n    * @see https://developer.github.com/v3/orgs/teams/#delete-team\n    * @param {Requestable.callback} [cb] - will receive the list of repositories\n    * @return {Promise} - the promise for the http request\n    */\n   deleteTeam(cb) {\n      log(`Deleting Team ${this.__teamId}`);\n      return this._request204or404(`/teams/${this.__teamId}`, undefined, cb, 'DELETE');\n   }\n}\n\nmodule.exports = Team;\n","/**\n * @file\n * @copyright  2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license    Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n *             Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\nimport debug from 'debug';\nconst log = debug('github:user');\n\n/**\n * A User allows scoping of API requests to a particular Github user.\n */\nclass User extends Requestable {\n   /**\n    * Create a User.\n    * @param {string} [username] - the user to use for user-scoped queries\n    * @param {Requestable.auth} [auth] - information required to authenticate to Github\n    * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n    */\n   constructor(username, auth, apiBase) {\n      super(auth, apiBase);\n      this.__user = username;\n   }\n\n   /**\n    * Get the url for the request. (dependent on if we're requesting for the authenticated user or not)\n    * @private\n    * @param {string} endpoint - the endpoint being requested\n    * @return {string} - the resolved endpoint\n    */\n   __getScopedUrl(endpoint) {\n      if (this.__user) {\n         return endpoint ?\n            `/users/${this.__user}/${endpoint}` :\n            `/users/${this.__user}`\n            ;\n\n      } else { // eslint-disable-line\n         switch (endpoint) {\n            case '':\n               return '/user';\n\n            case 'notifications':\n            case 'gists':\n               return `/${endpoint}`;\n\n            default:\n               return `/user/${endpoint}`;\n         }\n      }\n   }\n\n   /**\n    * List the user's repositories\n    * @see https://developer.github.com/v3/repos/#list-user-repositories\n    * @param {Object} [options={}] - any options to refine the search\n    * @param {Requestable.callback} [cb] - will receive the list of repositories\n    * @return {Promise} - the promise for the http request\n    */\n   listRepos(options, cb) {\n      if (typeof options === 'function') {\n         cb = options;\n         options = {};\n      }\n\n      options = this._getOptionsWithDefaults(options);\n\n      log(`Fetching repositories with options: ${JSON.stringify(options)}`);\n      return this._requestAllPages(this.__getScopedUrl('repos'), options, cb);\n   }\n\n   /**\n    * List the orgs that the user belongs to\n    * @see https://developer.github.com/v3/orgs/#list-user-organizations\n    * @param {Requestable.callback} [cb] - will receive the list of organizations\n    * @return {Promise} - the promise for the http request\n    */\n   listOrgs(cb) {\n      return this._request('GET', this.__getScopedUrl('orgs'), null, cb);\n   }\n\n   /**\n    * List the user's gists\n    * @see https://developer.github.com/v3/gists/#list-a-users-gists\n    * @param {Requestable.callback} [cb] - will receive the list of gists\n    * @return {Promise} - the promise for the http request\n    */\n   listGists(cb) {\n      return this._request('GET', this.__getScopedUrl('gists'), null, cb);\n   }\n\n   /**\n    * List the user's starred gists\n    * @see https://developer.github.com/v3/gists/#list-starred-gists\n    * @param {Requestable.callback} [cb] - will receive the list of gists\n    * @return {Promise} - the promise for the http request\n    */\n   listStarredGists(cb) {\n      return this._request('GET', this.__getScopedUrl('gists/starred'), null, cb);\n   }\n\n   /**\n    * List the user's gists\n    * @see https://developer.github.com/v3/gists/#list-a-users-gists\n    * @param {Requestable.callback} [cb] - will receive the list of gists\n    * @return {Promise} - the promise for the http request\n    */\n   listStarredGists(cb) {\n      return this._request('GET', this.__getScopedUrl('gists'), null, cb);\n   }\n\n   /**\n    * List the user's notifications\n    * @see https://developer.github.com/v3/activity/notifications/#list-your-notifications\n    * @param {Object} [options={}] - any options to refine the search\n    * @param {Requestable.callback} [cb] - will receive the list of repositories\n    * @return {Promise} - the promise for the http request\n    */\n   listNotifications(options, cb) {\n      options = options || {};\n      if (typeof options === 'function') {\n         cb = options;\n         options = {};\n      }\n\n      options.since = this._dateToISO(options.since);\n      options.before = this._dateToISO(options.before);\n\n      return this._request('GET', this.__getScopedUrl('notifications'), options, cb);\n   }\n\n   /**\n    * Show the user's profile\n    * @see https://developer.github.com/v3/users/#get-a-single-user\n    * @param {Requestable.callback} [cb] - will receive the user's information\n    * @return {Promise} - the promise for the http request\n    */\n   getProfile(cb) {\n      return this._request('GET', this.__getScopedUrl(''), null, cb);\n   }\n\n   /**\n    * Gets the list of starred repositories for the user\n    * @see https://developer.github.com/v3/activity/starring/#list-repositories-being-starred\n    * @param {Requestable.callback} [cb] - will receive the list of starred repositories\n    * @return {Promise} - the promise for the http request\n    */\n   listStarredRepos(cb) {\n      let requestOptions = this._getOptionsWithDefaults();\n      return this._requestAllPages(this.__getScopedUrl('starred'), requestOptions, cb);\n   }\n\n   /**\n    * List email addresses for a user\n    * @see https://developer.github.com/v3/users/emails/#list-email-addresses-for-a-user\n    * @param {Requestable.callback} [cb] - will receive the list of emails\n    * @return {Promise} - the promise for the http request\n    */\n   getEmails(cb) {\n      return this._request('GET', '/user/emails', null, cb);\n   }\n\n   /**\n    * Have the authenticated user follow this user\n    * @see https://developer.github.com/v3/users/followers/#follow-a-user\n    * @param {string} username - the user to follow\n    * @param {Requestable.callback} [cb] - will receive true if the request succeeds\n    * @return {Promise} - the promise for the http request\n    */\n   follow(username, cb) {\n      return this._request('PUT', `/user/following/${this.__user}`, null, cb);\n   }\n\n   /**\n    * Have the currently authenticated user unfollow this user\n    * @see https://developer.github.com/v3/users/followers/#follow-a-user\n    * @param {string} username - the user to unfollow\n    * @param {Requestable.callback} [cb] - receives true if the request succeeds\n    * @return {Promise} - the promise for the http request\n    */\n   unfollow(username, cb) {\n      return this._request('DELETE', `/user/following/${this.__user}`, null, cb);\n   }\n\n   /**\n    * Create a new repository for the currently authenticated user\n    * @see https://developer.github.com/v3/repos/#create\n    * @param {object} options - the repository definition\n    * @param {Requestable.callback} [cb] - will receive the API response\n    * @return {Promise} - the promise for the http request\n    */\n   createRepo(options, cb) {\n      return this._request('POST', '/user/repos', options, cb);\n   }\n}\n\nmodule.exports = User;\n"]}"} \ No newline at end of file diff --git a/dist/GitHub.min.js b/dist/GitHub.min.js new file mode 100644 index 00000000..5298ef6b --- /dev/null +++ b/dist/GitHub.min.js @@ -0,0 +1,3 @@ +!function(e){if("object"==typeof exports&&"undefined"!=typeof module)module.exports=e();else if("function"==typeof define&&define.amd)define([],e);else{var t;t="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof self?self:this,t.GitHub=e()}}(function(){return function e(t,r,n){function u(o,i){if(!r[o]){if(!t[o]){var a="function"==typeof require&&require;if(!i&&a)return a(o,!0);if(s)return s(o,!0);var l=new Error("Cannot find module '"+o+"'");throw l.code="MODULE_NOT_FOUND",l}var c=r[o]={exports:{}};t[o][0].call(c.exports,function(e){var r=t[o][1][e];return u(r?r:e)},c,c.exports,e,t,r,n)}return r[o].exports}for(var s="function"==typeof require&&require,o=0;o1&&void 0!==arguments[1]?arguments[1]:"https://api.github.com";u(this,e),this.__apiBase=r,this.__auth=t||{}}return s(e,[{key:"getGist",value:function(e){return new i.default(e,this.__auth,this.__apiBase)}},{key:"getUser",value:function(e){return new l.default(e,this.__auth,this.__apiBase)}},{key:"getOrganization",value:function(e){return new b.default(e,this.__auth,this.__apiBase)}},{key:"getTeam",value:function(e){return new k.default(e,this.__auth,this.__apiBase)}},{key:"getRepo",value:function(e,t){return new m.default(this._getFullName(e,t),this.__auth,this.__apiBase)}},{key:"getIssues",value:function(e,t){return new f.default(this._getFullName(e,t),this.__auth,this.__apiBase)}},{key:"search",value:function(e){return new h.default(e,this.__auth,this.__apiBase)}},{key:"getRateLimit",value:function(){return new y.default(this.__auth,this.__apiBase)}},{key:"getMarkdown",value:function(){return new q.default(this.__auth,this.__apiBase)}},{key:"getProject",value:function(e){return new O.default(e,this.__auth,this.__apiBase)}},{key:"_getFullName",value:function(e,t){var r=e;return t&&(r=e+"/"+t),r}}]),e}();t.exports=w},{"./Gist":1,"./Issue":3,"./Markdown":4,"./Organization":5,"./Project":6,"./RateLimit":7,"./Repository":8,"./Search":10,"./Team":11,"./User":12}],3:[function(e,t,r){"use strict";function n(e){return e&&e.__esModule?e:{default:e}}function u(e,t){if(!(e instanceof t))throw new TypeError("Cannot call a class as a function")}function s(e,t){if(!e)throw new ReferenceError("this hasn't been initialised - super() hasn't been called");return!t||"object"!=typeof t&&"function"!=typeof t?e:t}function o(e,t){if("function"!=typeof t&&null!==t)throw new TypeError("Super expression must either be null or a function, not "+typeof t);e.prototype=Object.create(t&&t.prototype,{constructor:{value:e,enumerable:!1,writable:!0,configurable:!0}}),t&&(Object.setPrototypeOf?Object.setPrototypeOf(e,t):e.__proto__=t)}var i=function(){function e(e,t){for(var r=0;r0&&void 0!==arguments[0]?arguments[0]:"",t=e.split(/\s*,\s*/);return t.reduce(function(e,t){return t.search(/rel="next"/)!==-1?(t.match(/<(.*)>/)||[])[1]:e},void 0)}function c(e,t){return function(r){var n=void 0;if(r.hasOwnProperty("config")){var u=r.response,s=u.status,o=u.statusText,i=r.config,a=i.method,l=i.url,c=s+" error making request "+a+" "+l+': "'+o+'"';n=new b(c,t,r),v(c+" "+JSON.stringify(r.data))}else n=r;if(!e)throw v("throwing error"),n;v("going to error callback"),e(n)}}var f="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(e){return typeof e}:function(e){return e&&"function"==typeof Symbol&&e.constructor===Symbol&&e!==Symbol.prototype?"symbol":typeof e},_=function(){function e(e,t){for(var r=0;r0&&void 0!==arguments[0]?arguments[0]:{};return e.visibility||e.affiliation||(e.type=e.type||"all"),e.sort=e.sort||"updated",e.per_page=e.per_page||"100",e}},{key:"_dateToISO",value:function(e){return e&&e instanceof Date&&(e=e.toISOString()),e}},{key:"_request",value:function(e,t,r,n,u){var s=this.__getURL(t),o=(r||{}).AcceptHeader;o&&delete r.AcceptHeader;var i=this.__getRequestHeaders(u,o),l={},_=r&&"object"===("undefined"==typeof r?"undefined":f(r))&&a(e);_&&(l=r,r=void 0);var h={url:s,method:e,headers:i,params:l,data:r,responseType:u?"text":"json"};v(h.method+" to "+h.url);var y=(0,p.default)(h).catch(c(n,t));return n&&y.then(function(e){e.data&&Object.keys(e.data).length>0?n(null,e.data,e):"GET"!==h.method&&Object.keys(e.data).length<1?n(null,e.status<300,e):n(null,e.data,e)}),y}},{key:"_request204or404",value:function(e,t,r){var n=arguments.length>3&&void 0!==arguments[3]?arguments[3]:"GET";return this._request(n,e,t).then(function(e){return r&&r(null,!0,e),!0},function(e){if(404===e.response.status)return r&&r(null,!1,e),!1;throw r&&r(e),e})}},{key:"_requestAllPages",value:function(e,t,r,n){var s=this;return n=n||[],this._request("GET",e,t).then(function(o){var i,a=void 0;if(o.data instanceof Array)a=o.data;else{if(!(o.data.items instanceof Array)){var c="cannot figure out how to append "+o.data+" to the result set";throw new b(c,e,o)}a=o.data.items}(i=n).push.apply(i,u(a));var f=l(o.headers.link);return f&&"number"!=typeof t.page?(v("getting next page: "+f),s._requestAllPages(f,t,r,n)):(r&&r(null,n,o),o.data=n,o)}).catch(c(r,e))}}]),e}();t.exports=g;var k=["GET","HEAD","DELETE"]},{axios:void 0,debug:void 0,"js-base64":void 0}],10:[function(e,t,r){"use strict";function n(e){return e&&e.__esModule?e:{ +default:e}}function u(e,t){if(!(e instanceof t))throw new TypeError("Cannot call a class as a function")}function s(e,t){if(!e)throw new ReferenceError("this hasn't been initialised - super() hasn't been called");return!t||"object"!=typeof t&&"function"!=typeof t?e:t}function o(e,t){if("function"!=typeof t&&null!==t)throw new TypeError("Super expression must either be null or a function, not "+typeof t);e.prototype=Object.create(t&&t.prototype,{constructor:{value:e,enumerable:!1,writable:!0,configurable:!0}}),t&&(Object.setPrototypeOf?Object.setPrototypeOf(e,t):e.__proto__=t)}var i=function(){function e(e,t){for(var r=0;r1&&void 0!==arguments[1]?arguments[1]:{},n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:void 0,u={};return Object.keys(this.__defaults).forEach(function(e){u[e]=t.__defaults[e]}),Object.keys(r).forEach(function(e){u[e]=r[e]}),_("searching "+e+" with options:",u),this._requestAllPages("/search/"+e,u,n)}},{key:"forRepositories",value:function(e,t){return this._search("repositories",e,t)}},{key:"forCode",value:function(e,t){return this._search("code",e,t)}},{key:"forIssues",value:function(e,t){return this._search("issues",e,t)}},{key:"forUsers",value:function(e,t){return this._search("users",e,t)}}]),t}(l.default);t.exports=h},{"./Requestable":9,debug:void 0}],11:[function(e,t,r){"use strict";function n(e){return e&&e.__esModule?e:{default:e}}function u(e,t){if(!(e instanceof t))throw new TypeError("Cannot call a class as a function")}function s(e,t){if(!e)throw new ReferenceError("this hasn't been initialised - super() hasn't been called");return!t||"object"!=typeof t&&"function"!=typeof t?e:t}function o(e,t){if("function"!=typeof t&&null!==t)throw new TypeError("Super expression must either be null or a function, not "+typeof t);e.prototype=Object.create(t&&t.prototype,{constructor:{value:e,enumerable:!1,writable:!0,configurable:!0}}),t&&(Object.setPrototypeOf?Object.setPrototypeOf(e,t):e.__proto__=t)}var i=function(){function e(e,t){for(var r=0;r {\n this.__id = response.data.id;\n return response;\n });\n }\n\n /**\n * Delete a gist.\n * @see https://developer.github.com/v3/gists/#delete-a-gist\n * @param {Requestable.callback} [cb] - will receive true if the request succeeds\n * @return {Promise} - the Promise for the http request\n */\n delete(cb) {\n return this._request('DELETE', `/gists/${this.__id}`, null, cb);\n }\n\n /**\n * Fork a gist.\n * @see https://developer.github.com/v3/gists/#fork-a-gist\n * @param {Requestable.callback} [cb] - the function that will receive the gist\n * @return {Promise} - the Promise for the http request\n */\n fork(cb) {\n return this._request('POST', `/gists/${this.__id}/forks`, null, cb);\n }\n\n /**\n * Update a gist.\n * @see https://developer.github.com/v3/gists/#edit-a-gist\n * @param {Object} gist - the new data for the gist\n * @param {Requestable.callback} [cb] - the function that receives the API result\n * @return {Promise} - the Promise for the http request\n */\n update(gist, cb) {\n return this._request('PATCH', `/gists/${this.__id}`, gist, cb);\n }\n\n /**\n * Star a gist.\n * @see https://developer.github.com/v3/gists/#star-a-gist\n * @param {Requestable.callback} [cb] - will receive true if the request is successful\n * @return {Promise} - the Promise for the http request\n */\n star(cb) {\n return this._request('PUT', `/gists/${this.__id}/star`, null, cb);\n }\n\n /**\n * Unstar a gist.\n * @see https://developer.github.com/v3/gists/#unstar-a-gist\n * @param {Requestable.callback} [cb] - will receive true if the request is successful\n * @return {Promise} - the Promise for the http request\n */\n unstar(cb) {\n return this._request('DELETE', `/gists/${this.__id}/star`, null, cb);\n }\n\n /**\n * Check if a gist is starred by the user.\n * @see https://developer.github.com/v3/gists/#check-if-a-gist-is-starred\n * @param {Requestable.callback} [cb] - will receive true if the gist is starred and false if the gist is not starred\n * @return {Promise} - the Promise for the http request\n */\n isStarred(cb) {\n return this._request204or404(`/gists/${this.__id}/star`, null, cb);\n }\n\n /**\n * List the gist's commits\n * @see https://developer.github.com/v3/gists/#list-gist-commits\n * @param {Requestable.callback} [cb] - will receive the array of commits\n * @return {Promise} - the Promise for the http request\n */\n listCommits(cb) {\n return this._requestAllPages(`/gists/${this.__id}/commits`, null, cb);\n }\n\n /**\n * Fetch one of the gist's revision.\n * @see https://developer.github.com/v3/gists/#get-a-specific-revision-of-a-gist\n * @param {string} revision - the id of the revision\n * @param {Requestable.callback} [cb] - will receive the revision\n * @return {Promise} - the Promise for the http request\n */\n getRevision(revision, cb) {\n return this._request('GET', `/gists/${this.__id}/${revision}`, null, cb);\n }\n\n /**\n * List the gist's comments\n * @see https://developer.github.com/v3/gists/comments/#list-comments-on-a-gist\n * @param {Requestable.callback} [cb] - will receive the array of comments\n * @return {Promise} - the promise for the http request\n */\n listComments(cb) {\n return this._requestAllPages(`/gists/${this.__id}/comments`, null, cb);\n }\n\n /**\n * Fetch one of the gist's comments\n * @see https://developer.github.com/v3/gists/comments/#get-a-single-comment\n * @param {number} comment - the id of the comment\n * @param {Requestable.callback} [cb] - will receive the comment\n * @return {Promise} - the Promise for the http request\n */\n getComment(comment, cb) {\n return this._request('GET', `/gists/${this.__id}/comments/${comment}`, null, cb);\n }\n\n /**\n * Comment on a gist\n * @see https://developer.github.com/v3/gists/comments/#create-a-comment\n * @param {string} comment - the comment to add\n * @param {Requestable.callback} [cb] - the function that receives the API result\n * @return {Promise} - the Promise for the http request\n */\n createComment(comment, cb) {\n return this._request('POST', `/gists/${this.__id}/comments`, {body: comment}, cb);\n }\n\n /**\n * Edit a comment on the gist\n * @see https://developer.github.com/v3/gists/comments/#edit-a-comment\n * @param {number} comment - the id of the comment\n * @param {string} body - the new comment\n * @param {Requestable.callback} [cb] - will receive the modified comment\n * @return {Promise} - the promise for the http request\n */\n editComment(comment, body, cb) {\n return this._request('PATCH', `/gists/${this.__id}/comments/${comment}`, {body: body}, cb);\n }\n\n /**\n * Delete a comment on the gist.\n * @see https://developer.github.com/v3/gists/comments/#delete-a-comment\n * @param {number} comment - the id of the comment\n * @param {Requestable.callback} [cb] - will receive true if the request succeeds\n * @return {Promise} - the Promise for the http request\n */\n deleteComment(comment, cb) {\n return this._request('DELETE', `/gists/${this.__id}/comments/${comment}`, null, cb);\n }\n}\n\nmodule.exports = Gist;\n","/**\n * @file\n * @copyright 2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n * Github.js is freely distributable.\n */\n/* eslint valid-jsdoc: [\"error\", {\"requireReturnDescription\": false}] */\n\nimport Gist from './Gist';\nimport User from './User';\nimport Issue from './Issue';\nimport Search from './Search';\nimport RateLimit from './RateLimit';\nimport Repository from './Repository';\nimport Organization from './Organization';\nimport Team from './Team';\nimport Markdown from './Markdown';\nimport Project from './Project';\n\n/**\n * GitHub encapsulates the functionality to create various API wrapper objects.\n */\nclass GitHub {\n /**\n * Create a new GitHub.\n * @param {Requestable.auth} [auth] - the credentials to authenticate to Github. If auth is\n * not provided requests will be made unauthenticated\n * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n */\n constructor(auth, apiBase = 'https://api.github.com') {\n this.__apiBase = apiBase;\n this.__auth = auth || {};\n }\n\n /**\n * Create a new Gist wrapper\n * @param {number} [id] - the id for the gist, leave undefined when creating a new gist\n * @return {Gist}\n */\n getGist(id) {\n return new Gist(id, this.__auth, this.__apiBase);\n }\n\n /**\n * Create a new User wrapper\n * @param {string} [user] - the name of the user to get information about\n * leave undefined for the authenticated user\n * @return {User}\n */\n getUser(user) {\n return new User(user, this.__auth, this.__apiBase);\n }\n\n /**\n * Create a new Organization wrapper\n * @param {string} organization - the name of the organization\n * @return {Organization}\n */\n getOrganization(organization) {\n return new Organization(organization, this.__auth, this.__apiBase);\n }\n\n /**\n * create a new Team wrapper\n * @param {string} teamId - the name of the team\n * @return {team}\n */\n getTeam(teamId) {\n return new Team(teamId, this.__auth, this.__apiBase);\n }\n\n /**\n * Create a new Repository wrapper\n * @param {string} user - the user who owns the respository\n * @param {string} repo - the name of the repository\n * @return {Repository}\n */\n getRepo(user, repo) {\n return new Repository(this._getFullName(user, repo), this.__auth, this.__apiBase);\n }\n\n /**\n * Create a new Issue wrapper\n * @param {string} user - the user who owns the respository\n * @param {string} repo - the name of the repository\n * @return {Issue}\n */\n getIssues(user, repo) {\n return new Issue(this._getFullName(user, repo), this.__auth, this.__apiBase);\n }\n\n /**\n * Create a new Search wrapper\n * @param {string} query - the query to search for\n * @return {Search}\n */\n search(query) {\n return new Search(query, this.__auth, this.__apiBase);\n }\n\n /**\n * Create a new RateLimit wrapper\n * @return {RateLimit}\n */\n getRateLimit() {\n return new RateLimit(this.__auth, this.__apiBase);\n }\n\n /**\n * Create a new Markdown wrapper\n * @return {Markdown}\n */\n getMarkdown() {\n return new Markdown(this.__auth, this.__apiBase);\n }\n\n /**\n * Create a new Project wrapper\n * @param {string} id - the id of the project\n * @return {Markdown}\n */\n getProject(id) {\n return new Project(id, this.__auth, this.__apiBase);\n }\n\n /**\n * Computes the full repository name\n * @param {string} user - the username (or the full name)\n * @param {string} repo - the repository name, must not be passed if `user` is the full name\n * @return {string} the repository's full name\n */\n _getFullName(user, repo) {\n let fullname = user;\n\n if (repo) {\n fullname = `${user}/${repo}`;\n }\n\n return fullname;\n }\n}\n\nmodule.exports = GitHub;\n","/**\n * @file\n * @copyright 2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n * Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\n\n/**\n * Issue wraps the functionality to get issues for repositories\n */\nclass Issue extends Requestable {\n /**\n * Create a new Issue\n * @param {string} repository - the full name of the repository (`:user/:repo`) to get issues for\n * @param {Requestable.auth} [auth] - information required to authenticate to Github\n * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n */\n constructor(repository, auth, apiBase) {\n super(auth, apiBase);\n this.__repository = repository;\n }\n\n /**\n * Create a new issue\n * @see https://developer.github.com/v3/issues/#create-an-issue\n * @param {Object} issueData - the issue to create\n * @param {Requestable.callback} [cb] - will receive the created issue\n * @return {Promise} - the promise for the http request\n */\n createIssue(issueData, cb) {\n return this._request('POST', `/repos/${this.__repository}/issues`, issueData, cb);\n }\n\n /**\n * List the issues for the repository\n * @see https://developer.github.com/v3/issues/#list-issues-for-a-repository\n * @param {Object} options - filtering options\n * @param {Requestable.callback} [cb] - will receive the array of issues\n * @return {Promise} - the promise for the http request\n */\n listIssues(options, cb) {\n return this._requestAllPages(`/repos/${this.__repository}/issues`, options, cb);\n }\n\n /**\n * List the events for an issue\n * @see https://developer.github.com/v3/issues/events/#list-events-for-an-issue\n * @param {number} issue - the issue to get events for\n * @param {Requestable.callback} [cb] - will receive the list of events\n * @return {Promise} - the promise for the http request\n */\n listIssueEvents(issue, cb) {\n return this._request('GET', `/repos/${this.__repository}/issues/${issue}/events`, null, cb);\n }\n\n /**\n * List comments on an issue\n * @see https://developer.github.com/v3/issues/comments/#list-comments-on-an-issue\n * @param {number} issue - the id of the issue to get comments from\n * @param {Requestable.callback} [cb] - will receive the comments\n * @return {Promise} - the promise for the http request\n */\n listIssueComments(issue, cb) {\n return this._request('GET', `/repos/${this.__repository}/issues/${issue}/comments`, null, cb);\n }\n\n /**\n * Get a single comment on an issue\n * @see https://developer.github.com/v3/issues/comments/#get-a-single-comment\n * @param {number} id - the comment id to get\n * @param {Requestable.callback} [cb] - will receive the comment\n * @return {Promise} - the promise for the http request\n */\n getIssueComment(id, cb) {\n return this._request('GET', `/repos/${this.__repository}/issues/comments/${id}`, null, cb);\n }\n\n /**\n * Comment on an issue\n * @see https://developer.github.com/v3/issues/comments/#create-a-comment\n * @param {number} issue - the id of the issue to comment on\n * @param {string} comment - the comment to add\n * @param {Requestable.callback} [cb] - will receive the created comment\n * @return {Promise} - the promise for the http request\n */\n createIssueComment(issue, comment, cb) {\n return this._request('POST', `/repos/${this.__repository}/issues/${issue}/comments`, {body: comment}, cb);\n }\n\n /**\n * Edit a comment on an issue\n * @see https://developer.github.com/v3/issues/comments/#edit-a-comment\n * @param {number} id - the comment id to edit\n * @param {string} comment - the comment to edit\n * @param {Requestable.callback} [cb] - will receive the edited comment\n * @return {Promise} - the promise for the http request\n */\n editIssueComment(id, comment, cb) {\n return this._request('PATCH', `/repos/${this.__repository}/issues/comments/${id}`, {body: comment}, cb);\n }\n\n /**\n * Delete a comment on an issue\n * @see https://developer.github.com/v3/issues/comments/#delete-a-comment\n * @param {number} id - the comment id to delete\n * @param {Requestable.callback} [cb] - will receive true if the request is successful\n * @return {Promise} - the promise for the http request\n */\n deleteIssueComment(id, cb) {\n return this._request('DELETE', `/repos/${this.__repository}/issues/comments/${id}`, null, cb);\n }\n\n /**\n * Edit an issue\n * @see https://developer.github.com/v3/issues/#edit-an-issue\n * @param {number} issue - the issue number to edit\n * @param {Object} issueData - the new issue data\n * @param {Requestable.callback} [cb] - will receive the modified issue\n * @return {Promise} - the promise for the http request\n */\n editIssue(issue, issueData, cb) {\n return this._request('PATCH', `/repos/${this.__repository}/issues/${issue}`, issueData, cb);\n }\n\n /**\n * Get a particular issue\n * @see https://developer.github.com/v3/issues/#get-a-single-issue\n * @param {number} issue - the issue number to fetch\n * @param {Requestable.callback} [cb] - will receive the issue\n * @return {Promise} - the promise for the http request\n */\n getIssue(issue, cb) {\n return this._request('GET', `/repos/${this.__repository}/issues/${issue}`, null, cb);\n }\n\n /**\n * List the milestones for the repository\n * @see https://developer.github.com/v3/issues/milestones/#list-milestones-for-a-repository\n * @param {Object} options - filtering options\n * @param {Requestable.callback} [cb] - will receive the array of milestones\n * @return {Promise} - the promise for the http request\n */\n listMilestones(options, cb) {\n return this._request('GET', `/repos/${this.__repository}/milestones`, options, cb);\n }\n\n /**\n * Get a milestone\n * @see https://developer.github.com/v3/issues/milestones/#get-a-single-milestone\n * @param {string} milestone - the id of the milestone to fetch\n * @param {Requestable.callback} [cb] - will receive the milestone\n * @return {Promise} - the promise for the http request\n */\n getMilestone(milestone, cb) {\n return this._request('GET', `/repos/${this.__repository}/milestones/${milestone}`, null, cb);\n }\n\n /**\n * Create a new milestone\n * @see https://developer.github.com/v3/issues/milestones/#create-a-milestone\n * @param {Object} milestoneData - the milestone definition\n * @param {Requestable.callback} [cb] - will receive the milestone\n * @return {Promise} - the promise for the http request\n */\n createMilestone(milestoneData, cb) {\n return this._request('POST', `/repos/${this.__repository}/milestones`, milestoneData, cb);\n }\n\n /**\n * Edit a milestone\n * @see https://developer.github.com/v3/issues/milestones/#update-a-milestone\n * @param {string} milestone - the id of the milestone to edit\n * @param {Object} milestoneData - the updates to make to the milestone\n * @param {Requestable.callback} [cb] - will receive the updated milestone\n * @return {Promise} - the promise for the http request\n */\n editMilestone(milestone, milestoneData, cb) {\n return this._request('PATCH', `/repos/${this.__repository}/milestones/${milestone}`, milestoneData, cb);\n }\n\n /**\n * Delete a milestone (this is distinct from closing a milestone)\n * @see https://developer.github.com/v3/issues/milestones/#delete-a-milestone\n * @param {string} milestone - the id of the milestone to delete\n * @param {Requestable.callback} [cb] - will receive the status\n * @return {Promise} - the promise for the http request\n */\n deleteMilestone(milestone, cb) {\n return this._request('DELETE', `/repos/${this.__repository}/milestones/${milestone}`, null, cb);\n }\n\n /**\n * Create a new label\n * @see https://developer.github.com/v3/issues/labels/#create-a-label\n * @param {Object} labelData - the label definition\n * @param {Requestable.callback} [cb] - will receive the object representing the label\n * @return {Promise} - the promise for the http request\n */\n createLabel(labelData, cb) {\n return this._request('POST', `/repos/${this.__repository}/labels`, labelData, cb);\n }\n\n /**\n * List the labels for the repository\n * @see https://developer.github.com/v3/issues/labels/#list-all-labels-for-this-repository\n * @param {Object} options - filtering options\n * @param {Requestable.callback} [cb] - will receive the array of labels\n * @return {Promise} - the promise for the http request\n */\n listLabels(options, cb) {\n return this._request('GET', `/repos/${this.__repository}/labels`, options, cb);\n }\n\n /**\n * Get a label\n * @see https://developer.github.com/v3/issues/labels/#get-a-single-label\n * @param {string} label - the name of the label to fetch\n * @param {Requestable.callback} [cb] - will receive the label\n * @return {Promise} - the promise for the http request\n */\n getLabel(label, cb) {\n return this._request('GET', `/repos/${this.__repository}/labels/${label}`, null, cb);\n }\n\n /**\n * Edit a label\n * @see https://developer.github.com/v3/issues/labels/#update-a-label\n * @param {string} label - the name of the label to edit\n * @param {Object} labelData - the updates to make to the label\n * @param {Requestable.callback} [cb] - will receive the updated label\n * @return {Promise} - the promise for the http request\n */\n editLabel(label, labelData, cb) {\n return this._request('PATCH', `/repos/${this.__repository}/labels/${label}`, labelData, cb);\n }\n\n /**\n * Delete a label\n * @see https://developer.github.com/v3/issues/labels/#delete-a-label\n * @param {string} label - the name of the label to delete\n * @param {Requestable.callback} [cb] - will receive the status\n * @return {Promise} - the promise for the http request\n */\n deleteLabel(label, cb) {\n return this._request('DELETE', `/repos/${this.__repository}/labels/${label}`, null, cb);\n }\n}\n\nmodule.exports = Issue;\n","/**\n * @file\n * @copyright 2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n * Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\n\n/**\n * Renders html from Markdown text\n */\nclass Markdown extends Requestable {\n /**\n * construct a Markdown\n * @param {Requestable.auth} auth - the credentials to authenticate to GitHub\n * @param {string} [apiBase] - the base Github API URL\n * @return {Promise} - the promise for the http request\n */\n constructor(auth, apiBase) {\n super(auth, apiBase);\n }\n\n /**\n * Render html from Markdown text.\n * @see https://developer.github.com/v3/markdown/#render-an-arbitrary-markdown-document\n * @param {Object} options - conversion options\n * @param {string} [options.text] - the markdown text to convert\n * @param {string} [options.mode=markdown] - can be either `markdown` or `gfm`\n * @param {string} [options.context] - repository name if mode is gfm\n * @param {Requestable.callback} [cb] - will receive the converted html\n * @return {Promise} - the promise for the http request\n */\n render(options, cb) {\n return this._request('POST', '/markdown', options, cb);\n }\n}\n\nmodule.exports = Markdown;\n","/**\n * @file\n * @copyright 2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n * Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\n\n/**\n * Organization encapsulates the functionality to create repositories in organizations\n */\nclass Organization extends Requestable {\n /**\n * Create a new Organization\n * @param {string} organization - the name of the organization\n * @param {Requestable.auth} [auth] - information required to authenticate to Github\n * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n */\n constructor(organization, auth, apiBase) {\n super(auth, apiBase);\n this.__name = organization;\n }\n\n /**\n * Create a repository in an organization\n * @see https://developer.github.com/v3/repos/#create\n * @param {Object} options - the repository definition\n * @param {Requestable.callback} [cb] - will receive the created repository\n * @return {Promise} - the promise for the http request\n */\n createRepo(options, cb) {\n return this._request('POST', `/orgs/${this.__name}/repos`, options, cb);\n }\n\n /**\n * List the repositories in an organization\n * @see https://developer.github.com/v3/repos/#list-organization-repositories\n * @param {Requestable.callback} [cb] - will receive the list of repositories\n * @return {Promise} - the promise for the http request\n */\n getRepos(cb) {\n let requestOptions = this._getOptionsWithDefaults({direction: 'desc'});\n\n return this._requestAllPages(`/orgs/${this.__name}/repos`, requestOptions, cb);\n }\n\n /**\n * Query if the user is a member or not\n * @param {string} username - the user in question\n * @param {Requestable.callback} [cb] - will receive true if the user is a member\n * @return {Promise} - the promise for the http request\n */\n isMember(username, cb) {\n return this._request204or404(`/orgs/${this.__name}/members/${username}`, null, cb);\n }\n\n /**\n * List the users who are members of the company\n * @see https://developer.github.com/v3/orgs/members/#members-list\n * @param {object} options - filtering options\n * @param {string} [options.filter=all] - can be either `2fa_disabled` or `all`\n * @param {string} [options.role=all] - can be one of: `all`, `admin`, or `member`\n * @param {Requestable.callback} [cb] - will receive the list of users\n * @return {Promise} - the promise for the http request\n */\n listMembers(options, cb) {\n return this._request('GET', `/orgs/${this.__name}/members`, options, cb);\n }\n\n /**\n * List the Teams in the Organization\n * @see https://developer.github.com/v3/orgs/teams/#list-teams\n * @param {Requestable.callback} [cb] - will receive the list of teams\n * @return {Promise} - the promise for the http request\n */\n getTeams(cb) {\n return this._requestAllPages(`/orgs/${this.__name}/teams`, undefined, cb);\n }\n\n /**\n * Create a team\n * @see https://developer.github.com/v3/orgs/teams/#create-team\n * @param {object} options - Team creation parameters\n * @param {string} options.name - The name of the team\n * @param {string} [options.description] - Team description\n * @param {string} [options.repo_names] - Repos to add the team to\n * @param {string} [options.privacy=secret] - The level of privacy the team should have. Can be either one\n * of: `secret`, or `closed`\n * @param {Requestable.callback} [cb] - will receive the created team\n * @return {Promise} - the promise for the http request\n */\n createTeam(options, cb) {\n return this._request('POST', `/orgs/${this.__name}/teams`, options, cb);\n }\n\n /**\n * Get information about all projects\n * @see https://developer.github.com/v3/projects/#list-organization-projects\n * @param {Requestable.callback} [cb] - will receive the list of projects\n * @return {Promise} - the promise for the http request\n */\n listProjects(cb) {\n return this._requestAllPages(`/orgs/${this.__name}/projects`, {AcceptHeader: 'inertia-preview'}, cb);\n }\n\n /**\n * Create a new project\n * @see https://developer.github.com/v3/repos/projects/#create-a-project\n * @param {Object} options - the description of the project\n * @param {Requestable.callback} cb - will receive the newly created project\n * @return {Promise} - the promise for the http request\n */\n createProject(options, cb) {\n options = options || {};\n options.AcceptHeader = 'inertia-preview';\n return this._request('POST', `/orgs/${this.__name}/projects`, options, cb);\n }\n}\n\nmodule.exports = Organization;\n","/**\n * @file\n * @copyright 2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n * Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\n\n/**\n * Project encapsulates the functionality to create, query, and modify cards and columns.\n */\nclass Project extends Requestable {\n /**\n * Create a Project.\n * @param {string} id - the id of the project\n * @param {Requestable.auth} [auth] - information required to authenticate to Github\n * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n */\n constructor(id, auth, apiBase) {\n super(auth, apiBase, 'inertia-preview');\n this.__id = id;\n }\n\n /**\n * Get information about a project\n * @see https://developer.github.com/v3/projects/#get-a-project\n * @param {Requestable.callback} cb - will receive the project information\n * @return {Promise} - the promise for the http request\n */\n getProject(cb) {\n return this._request('GET', `/projects/${this.__id}`, null, cb);\n }\n\n /**\n * Edit a project\n * @see https://developer.github.com/v3/projects/#update-a-project\n * @param {Object} options - the description of the project\n * @param {Requestable.callback} cb - will receive the modified project\n * @return {Promise} - the promise for the http request\n */\n updateProject(options, cb) {\n return this._request('PATCH', `/projects/${this.__id}`, options, cb);\n }\n\n /**\n * Delete a project\n * @see https://developer.github.com/v3/projects/#delete-a-project\n * @param {Requestable.callback} cb - will receive true if the operation is successful\n * @return {Promise} - the promise for the http request\n */\n deleteProject(cb) {\n return this._request('DELETE', `/projects/${this.__id}`, null, cb);\n }\n\n /**\n * Get information about all columns of a project\n * @see https://developer.github.com/v3/projects/columns/#list-project-columns\n * @param {Requestable.callback} [cb] - will receive the list of columns\n * @return {Promise} - the promise for the http request\n */\n listProjectColumns(cb) {\n return this._requestAllPages(`/projects/${this.__id}/columns`, null, cb);\n }\n\n /**\n * Get information about a column\n * @see https://developer.github.com/v3/projects/columns/#get-a-project-column\n * @param {string} colId - the id of the column\n * @param {Requestable.callback} cb - will receive the column information\n * @return {Promise} - the promise for the http request\n */\n getProjectColumn(colId, cb) {\n return this._request('GET', `/projects/columns/${colId}`, null, cb);\n }\n\n /**\n * Create a new column\n * @see https://developer.github.com/v3/projects/columns/#create-a-project-column\n * @param {Object} options - the description of the column\n * @param {Requestable.callback} cb - will receive the newly created column\n * @return {Promise} - the promise for the http request\n */\n createProjectColumn(options, cb) {\n return this._request('POST', `/projects/${this.__id}/columns`, options, cb);\n }\n\n /**\n * Edit a column\n * @see https://developer.github.com/v3/projects/columns/#update-a-project-column\n * @param {string} colId - the column id\n * @param {Object} options - the description of the column\n * @param {Requestable.callback} cb - will receive the modified column\n * @return {Promise} - the promise for the http request\n */\n updateProjectColumn(colId, options, cb) {\n return this._request('PATCH', `/projects/columns/${colId}`, options, cb);\n }\n\n /**\n * Delete a column\n * @see https://developer.github.com/v3/projects/columns/#delete-a-project-column\n * @param {string} colId - the column to be deleted\n * @param {Requestable.callback} cb - will receive true if the operation is successful\n * @return {Promise} - the promise for the http request\n */\n deleteProjectColumn(colId, cb) {\n return this._request('DELETE', `/projects/columns/${colId}`, null, cb);\n }\n\n /**\n * Move a column\n * @see https://developer.github.com/v3/projects/columns/#move-a-project-column\n * @param {string} colId - the column to be moved\n * @param {string} position - can be one of first, last, or after:,\n * where is the id value of a column in the same project.\n * @param {Requestable.callback} cb - will receive true if the operation is successful\n * @return {Promise} - the promise for the http request\n */\n moveProjectColumn(colId, position, cb) {\n return this._request(\n 'POST',\n `/projects/columns/${colId}/moves`,\n {position: position},\n cb\n );\n }\n\n /**\n * Get information about all cards of a project\n * @see https://developer.github.com/v3/projects/cards/#list-project-cards\n * @param {Requestable.callback} [cb] - will receive the list of cards\n * @return {Promise} - the promise for the http request\n */\n listProjectCards(cb) {\n return this.listProjectColumns()\n .then(({data}) => {\n return Promise.all(data.map((column) => {\n return this._requestAllPages(`/projects/columns/${column.id}/cards`, null);\n }));\n }).then((cardsInColumns) => {\n const cards = cardsInColumns.reduce((prev, {data}) => {\n prev.push(...data);\n return prev;\n }, []);\n if (cb) {\n cb(null, cards);\n }\n return cards;\n }).catch((err) => {\n if (cb) {\n cb(err);\n return;\n }\n throw err;\n });\n }\n\n /**\n * Get information about all cards of a column\n * @see https://developer.github.com/v3/projects/cards/#list-project-cards\n * @param {string} colId - the id of the column\n * @param {Requestable.callback} [cb] - will receive the list of cards\n * @return {Promise} - the promise for the http request\n */\n listColumnCards(colId, cb) {\n return this._requestAllPages(`/projects/columns/${colId}/cards`, null, cb);\n }\n\n /**\n * Get information about a card\n * @see https://developer.github.com/v3/projects/cards/#get-a-project-card\n * @param {string} cardId - the id of the card\n * @param {Requestable.callback} cb - will receive the card information\n * @return {Promise} - the promise for the http request\n */\n getProjectCard(cardId, cb) {\n return this._request('GET', `/projects/columns/cards/${cardId}`, null, cb);\n }\n\n /**\n * Create a new card\n * @see https://developer.github.com/v3/projects/cards/#create-a-project-card\n * @param {string} colId - the column id\n * @param {Object} options - the description of the card\n * @param {Requestable.callback} cb - will receive the newly created card\n * @return {Promise} - the promise for the http request\n */\n createProjectCard(colId, options, cb) {\n return this._request('POST', `/projects/columns/${colId}/cards`, options, cb);\n }\n\n /**\n * Edit a card\n * @see https://developer.github.com/v3/projects/cards/#update-a-project-card\n * @param {string} cardId - the card id\n * @param {Object} options - the description of the card\n * @param {Requestable.callback} cb - will receive the modified card\n * @return {Promise} - the promise for the http request\n */\n updateProjectCard(cardId, options, cb) {\n return this._request('PATCH', `/projects/columns/cards/${cardId}`, options, cb);\n }\n\n /**\n * Delete a card\n * @see https://developer.github.com/v3/projects/cards/#delete-a-project-card\n * @param {string} cardId - the card to be deleted\n * @param {Requestable.callback} cb - will receive true if the operation is successful\n * @return {Promise} - the promise for the http request\n */\n deleteProjectCard(cardId, cb) {\n return this._request('DELETE', `/projects/columns/cards/${cardId}`, null, cb);\n }\n\n /**\n * Move a card\n * @see https://developer.github.com/v3/projects/cards/#move-a-project-card\n * @param {string} cardId - the card to be moved\n * @param {string} position - can be one of top, bottom, or after:,\n * where is the id value of a card in the same project.\n * @param {string} colId - the id value of a column in the same project.\n * @param {Requestable.callback} cb - will receive true if the operation is successful\n * @return {Promise} - the promise for the http request\n */\n moveProjectCard(cardId, position, colId, cb) {\n return this._request(\n 'POST',\n `/projects/columns/cards/${cardId}/moves`,\n {position: position, column_id: colId}, // eslint-disable-line camelcase\n cb\n );\n }\n}\n\nmodule.exports = Project;\n","/**\n * @file\n * @copyright 2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n * Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\n\n/**\n * RateLimit allows users to query their rate-limit status\n */\nclass RateLimit extends Requestable {\n /**\n * construct a RateLimit\n * @param {Requestable.auth} auth - the credentials to authenticate to GitHub\n * @param {string} [apiBase] - the base Github API URL\n * @return {Promise} - the promise for the http request\n */\n constructor(auth, apiBase) {\n super(auth, apiBase);\n }\n\n /**\n * Query the current rate limit\n * @see https://developer.github.com/v3/rate_limit/\n * @param {Requestable.callback} [cb] - will receive the rate-limit data\n * @return {Promise} - the promise for the http request\n */\n getRateLimit(cb) {\n return this._request('GET', '/rate_limit', null, cb);\n }\n}\n\nmodule.exports = RateLimit;\n","/**\n * @file\n * @copyright 2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n * Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\nimport Utf8 from 'utf8';\nimport {\n Base64,\n} from 'js-base64';\nimport debug from 'debug';\nconst log = debug('github:repository');\n\n/**\n * Respository encapsulates the functionality to create, query, and modify files.\n */\nclass Repository extends Requestable {\n /**\n * Create a Repository.\n * @param {string} fullname - the full name of the repository\n * @param {Requestable.auth} [auth] - information required to authenticate to Github\n * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n */\n constructor(fullname, auth, apiBase) {\n super(auth, apiBase);\n this.__fullname = fullname;\n this.__currentTree = {\n branch: null,\n sha: null,\n };\n }\n\n /**\n * Get a reference\n * @see https://developer.github.com/v3/git/refs/#get-a-reference\n * @param {string} ref - the reference to get\n * @param {Requestable.callback} [cb] - will receive the reference's refSpec or a list of refSpecs that match `ref`\n * @return {Promise} - the promise for the http request\n */\n getRef(ref, cb) {\n return this._request('GET', `/repos/${this.__fullname}/git/refs/${ref}`, null, cb);\n }\n\n /**\n * Create a reference\n * @see https://developer.github.com/v3/git/refs/#create-a-reference\n * @param {Object} options - the object describing the ref\n * @param {Requestable.callback} [cb] - will receive the ref\n * @return {Promise} - the promise for the http request\n */\n createRef(options, cb) {\n return this._request('POST', `/repos/${this.__fullname}/git/refs`, options, cb);\n }\n\n /**\n * Delete a reference\n * @see https://developer.github.com/v3/git/refs/#delete-a-reference\n * @param {string} ref - the name of the ref to delte\n * @param {Requestable.callback} [cb] - will receive true if the request is successful\n * @return {Promise} - the promise for the http request\n */\n deleteRef(ref, cb) {\n return this._request('DELETE', `/repos/${this.__fullname}/git/refs/${ref}`, null, cb);\n }\n\n /**\n * Delete a repository\n * @see https://developer.github.com/v3/repos/#delete-a-repository\n * @param {Requestable.callback} [cb] - will receive true if the request is successful\n * @return {Promise} - the promise for the http request\n */\n deleteRepo(cb) {\n return this._request('DELETE', `/repos/${this.__fullname}`, null, cb);\n }\n\n /**\n * List the tags on a repository\n * @see https://developer.github.com/v3/repos/#list-tags\n * @param {Requestable.callback} [cb] - will receive the tag data\n * @return {Promise} - the promise for the http request\n */\n listTags(cb) {\n return this._request('GET', `/repos/${this.__fullname}/tags`, null, cb);\n }\n\n /**\n * List the open pull requests on the repository\n * @see https://developer.github.com/v3/pulls/#list-pull-requests\n * @param {Object} options - options to filter the search\n * @param {Requestable.callback} [cb] - will receive the list of PRs\n * @return {Promise} - the promise for the http request\n */\n listPullRequests(options, cb) {\n options = options || {};\n return this._request('GET', `/repos/${this.__fullname}/pulls`, options, cb);\n }\n\n /**\n * Get information about a specific pull request\n * @see https://developer.github.com/v3/pulls/#get-a-single-pull-request\n * @param {number} number - the PR you wish to fetch\n * @param {Requestable.callback} [cb] - will receive the PR from the API\n * @return {Promise} - the promise for the http request\n */\n getPullRequest(number, cb) {\n return this._request('GET', `/repos/${this.__fullname}/pulls/${number}`, null, cb);\n }\n\n /**\n * List the files of a specific pull request\n * @see https://developer.github.com/v3/pulls/#list-pull-requests-files\n * @param {number|string} number - the PR you wish to fetch\n * @param {Requestable.callback} [cb] - will receive the list of files from the API\n * @return {Promise} - the promise for the http request\n */\n listPullRequestFiles(number, cb) {\n return this._request('GET', `/repos/${this.__fullname}/pulls/${number}/files`, null, cb);\n }\n\n /**\n * Compare two branches/commits/repositories\n * @see https://developer.github.com/v3/repos/commits/#compare-two-commits\n * @param {string} base - the base commit\n * @param {string} head - the head commit\n * @param {Requestable.callback} cb - will receive the comparison\n * @return {Promise} - the promise for the http request\n */\n compareBranches(base, head, cb) {\n return this._request('GET', `/repos/${this.__fullname}/compare/${base}...${head}`, null, cb);\n }\n\n /**\n * List all the branches for the repository\n * @see https://developer.github.com/v3/repos/#list-branches\n * @param {Requestable.callback} cb - will receive the list of branches\n * @return {Promise} - the promise for the http request\n */\n listBranches(cb) {\n return this._request('GET', `/repos/${this.__fullname}/branches`, null, cb);\n }\n\n /**\n * Get a raw blob from the repository\n * @see https://developer.github.com/v3/git/blobs/#get-a-blob\n * @param {string} sha - the sha of the blob to fetch\n * @param {Requestable.callback} cb - will receive the blob from the API\n * @return {Promise} - the promise for the http request\n */\n getBlob(sha, cb) {\n return this._request('GET', `/repos/${this.__fullname}/git/blobs/${sha}`, null, cb, 'raw');\n }\n\n /**\n * Get a single branch\n * @see https://developer.github.com/v3/repos/branches/#get-branch\n * @param {string} branch - the name of the branch to fetch\n * @param {Requestable.callback} cb - will receive the branch from the API\n * @returns {Promise} - the promise for the http request\n */\n getBranch(branch, cb) {\n return this._request('GET', `/repos/${this.__fullname}/branches/${branch}`, null, cb);\n }\n\n /**\n * Get a commit from the repository\n * @see https://developer.github.com/v3/repos/commits/#get-a-single-commit\n * @param {string} sha - the sha for the commit to fetch\n * @param {Requestable.callback} cb - will receive the commit data\n * @return {Promise} - the promise for the http request\n */\n getCommit(sha, cb) {\n return this._request('GET', `/repos/${this.__fullname}/git/commits/${sha}`, null, cb);\n }\n\n /**\n * List the commits on a repository, optionally filtering by path, author or time range\n * @see https://developer.github.com/v3/repos/commits/#list-commits-on-a-repository\n * @param {Object} [options] - the filtering options for commits\n * @param {string} [options.sha] - the SHA or branch to start from\n * @param {string} [options.path] - the path to search on\n * @param {string} [options.author] - the commit author\n * @param {(Date|string)} [options.since] - only commits after this date will be returned\n * @param {(Date|string)} [options.until] - only commits before this date will be returned\n * @param {Requestable.callback} cb - will receive the list of commits found matching the criteria\n * @return {Promise} - the promise for the http request\n */\n listCommits(options, cb) {\n options = options || {};\n\n options.since = this._dateToISO(options.since);\n options.until = this._dateToISO(options.until);\n\n return this._request('GET', `/repos/${this.__fullname}/commits`, options, cb);\n }\n\n /**\n * Gets a single commit information for a repository\n * @see https://developer.github.com/v3/repos/commits/#get-a-single-commit\n * @param {string} ref - the reference for the commit-ish\n * @param {Requestable.callback} cb - will receive the commit information\n * @return {Promise} - the promise for the http request\n */\n getSingleCommit(ref, cb) {\n ref = ref || '';\n return this._request('GET', `/repos/${this.__fullname}/commits/${ref}`, null, cb);\n }\n\n /**\n * Get tha sha for a particular object in the repository. This is a convenience function\n * @see https://developer.github.com/v3/repos/contents/#get-contents\n * @param {string} [branch] - the branch to look in, or the repository's default branch if omitted\n * @param {string} path - the path of the file or directory\n * @param {Requestable.callback} cb - will receive a description of the requested object, including a `SHA` property\n * @return {Promise} - the promise for the http request\n */\n getSha(branch, path, cb) {\n branch = branch ? `?ref=${branch}` : '';\n return this._request('GET', `/repos/${this.__fullname}/contents/${path}${branch}`, null, cb);\n }\n\n /**\n * List the commit statuses for a particular sha, branch, or tag\n * @see https://developer.github.com/v3/repos/statuses/#list-statuses-for-a-specific-ref\n * @param {string} sha - the sha, branch, or tag to get statuses for\n * @param {Requestable.callback} cb - will receive the list of statuses\n * @return {Promise} - the promise for the http request\n */\n listStatuses(sha, cb) {\n return this._request('GET', `/repos/${this.__fullname}/commits/${sha}/statuses`, null, cb);\n }\n\n /**\n * Get a description of a git tree\n * @see https://developer.github.com/v3/git/trees/#get-a-tree\n * @param {string} treeSHA - the SHA of the tree to fetch\n * @param {Requestable.callback} cb - will receive the callback data\n * @return {Promise} - the promise for the http request\n */\n getTree(treeSHA, cb) {\n return this._request('GET', `/repos/${this.__fullname}/git/trees/${treeSHA}`, null, cb);\n }\n\n /**\n * Create a blob\n * @see https://developer.github.com/v3/git/blobs/#create-a-blob\n * @param {(string|Buffer|Blob)} content - the content to add to the repository\n * @param {Requestable.callback} cb - will receive the details of the created blob\n * @return {Promise} - the promise for the http request\n */\n createBlob(content, cb) {\n let postBody = this._getContentObject(content);\n\n log('sending content', postBody);\n return this._request('POST', `/repos/${this.__fullname}/git/blobs`, postBody, cb);\n }\n\n /**\n * Get the object that represents the provided content\n * @param {string|Buffer|Blob} content - the content to send to the server\n * @return {Object} the representation of `content` for the GitHub API\n */\n _getContentObject(content) {\n if (typeof content === 'string') {\n log('contet is a string');\n return {\n content: Utf8.encode(content),\n encoding: 'utf-8',\n };\n\n } else if (typeof Buffer !== 'undefined' && content instanceof Buffer) {\n log('We appear to be in Node');\n return {\n content: content.toString('base64'),\n encoding: 'base64',\n };\n\n } else if (typeof Blob !== 'undefined' && content instanceof Blob) {\n log('We appear to be in the browser');\n return {\n content: Base64.encode(content),\n encoding: 'base64',\n };\n\n } else { // eslint-disable-line\n log(`Not sure what this content is: ${typeof content}, ${JSON.stringify(content)}`);\n throw new Error('Unknown content passed to postBlob. Must be string or Buffer (node) or Blob (web)');\n }\n }\n\n /**\n * Update a tree in Git\n * @see https://developer.github.com/v3/git/trees/#create-a-tree\n * @param {string} baseTreeSHA - the SHA of the tree to update\n * @param {string} path - the path for the new file\n * @param {string} blobSHA - the SHA for the blob to put at `path`\n * @param {Requestable.callback} cb - will receive the new tree that is created\n * @return {Promise} - the promise for the http request\n * @deprecated use {@link Repository#createTree} instead\n */\n updateTree(baseTreeSHA, path, blobSHA, cb) {\n let newTree = {\n base_tree: baseTreeSHA, // eslint-disable-line\n tree: [{\n path: path,\n sha: blobSHA,\n mode: '100644',\n type: 'blob',\n }],\n };\n\n return this._request('POST', `/repos/${this.__fullname}/git/trees`, newTree, cb);\n }\n\n /**\n * Create a new tree in git\n * @see https://developer.github.com/v3/git/trees/#create-a-tree\n * @param {Object} tree - the tree to create\n * @param {string} baseSHA - the root sha of the tree\n * @param {Requestable.callback} cb - will receive the new tree that is created\n * @return {Promise} - the promise for the http request\n */\n createTree(tree, baseSHA, cb) {\n return this._request('POST', `/repos/${this.__fullname}/git/trees`, {\n tree,\n base_tree: baseSHA, // eslint-disable-line camelcase\n }, cb);\n }\n\n /**\n * Add a commit to the repository\n * @see https://developer.github.com/v3/git/commits/#create-a-commit\n * @param {string} parent - the SHA of the parent commit\n * @param {string} tree - the SHA of the tree for this commit\n * @param {string} message - the commit message\n * @param {Requestable.callback} cb - will receive the commit that is created\n * @return {Promise} - the promise for the http request\n */\n commit(parent, tree, message, cb) {\n let data = {\n message,\n tree,\n parents: [parent],\n };\n\n return this._request('POST', `/repos/${this.__fullname}/git/commits`, data, cb)\n .then((response) => {\n this.__currentTree.sha = response.data.sha; // Update latest commit\n return response;\n });\n }\n\n /**\n * Update a ref\n * @see https://developer.github.com/v3/git/refs/#update-a-reference\n * @param {string} ref - the ref to update\n * @param {string} commitSHA - the SHA to point the reference to\n * @param {boolean} force - indicates whether to force or ensure a fast-forward update\n * @param {Requestable.callback} cb - will receive the updated ref back\n * @return {Promise} - the promise for the http request\n */\n updateHead(ref, commitSHA, force, cb) {\n return this._request('PATCH', `/repos/${this.__fullname}/git/refs/${ref}`, {\n sha: commitSHA,\n force: force,\n }, cb);\n }\n\n /**\n * Update commit status\n * @see https://developer.github.com/v3/repos/statuses/\n * @param {string} commitSHA - the SHA of the commit that should be updated\n * @param {object} options - Commit status parameters\n * @param {string} options.state - The state of the status. Can be one of: pending, success, error, or failure.\n * @param {string} [options.target_url] - The target URL to associate with this status.\n * @param {string} [options.description] - A short description of the status.\n * @param {string} [options.context] - A string label to differentiate this status among CI systems.\n * @param {Requestable.callback} cb - will receive the updated commit back\n * @return {Promise} - the promise for the http request\n */\n updateStatus(commitSHA, options, cb) {\n return this._request('POST', `/repos/${this.__fullname}/statuses/${commitSHA}`, options, cb);\n }\n\n /**\n * Update repository information\n * @see https://developer.github.com/v3/repos/#edit\n * @param {object} options - New parameters that will be set to the repository\n * @param {string} options.name - Name of the repository\n * @param {string} [options.description] - A short description of the repository\n * @param {string} [options.homepage] - A URL with more information about the repository\n * @param {boolean} [options.private] - Either true to make the repository private, or false to make it public.\n * @param {boolean} [options.has_issues] - Either true to enable issues for this repository, false to disable them.\n * @param {boolean} [options.has_wiki] - Either true to enable the wiki for this repository, false to disable it.\n * @param {boolean} [options.has_downloads] - Either true to enable downloads, false to disable them.\n * @param {string} [options.default_branch] - Updates the default branch for this repository.\n * @param {Requestable.callback} cb - will receive the updated repository back\n * @return {Promise} - the promise for the http request\n */\n updateRepository(options, cb) {\n return this._request('PATCH', `/repos/${this.__fullname}`, options, cb);\n }\n\n /**\n * Get information about the repository\n * @see https://developer.github.com/v3/repos/#get\n * @param {Requestable.callback} cb - will receive the information about the repository\n * @return {Promise} - the promise for the http request\n */\n getDetails(cb) {\n return this._request('GET', `/repos/${this.__fullname}`, null, cb);\n }\n\n /**\n * List the contributors to the repository\n * @see https://developer.github.com/v3/repos/#list-contributors\n * @param {Requestable.callback} cb - will receive the list of contributors\n * @return {Promise} - the promise for the http request\n */\n getContributors(cb) {\n return this._request('GET', `/repos/${this.__fullname}/contributors`, null, cb);\n }\n\n /**\n * List the contributor stats to the repository\n * @see https://developer.github.com/v3/repos/#list-contributors\n * @param {Requestable.callback} cb - will receive the list of contributors\n * @return {Promise} - the promise for the http request\n */\n getContributorStats(cb) {\n return this._request('GET', `/repos/${this.__fullname}/stats/contributors`, null, cb);\n }\n\n /**\n * List the users who are collaborators on the repository. The currently authenticated user must have\n * push access to use this method\n * @see https://developer.github.com/v3/repos/collaborators/#list-collaborators\n * @param {Requestable.callback} cb - will receive the list of collaborators\n * @return {Promise} - the promise for the http request\n */\n getCollaborators(cb) {\n return this._request('GET', `/repos/${this.__fullname}/collaborators`, null, cb);\n }\n\n /**\n * Check if a user is a collaborator on the repository\n * @see https://developer.github.com/v3/repos/collaborators/#check-if-a-user-is-a-collaborator\n * @param {string} username - the user to check\n * @param {Requestable.callback} cb - will receive true if the user is a collaborator and false if they are not\n * @return {Promise} - the promise for the http request {Boolean} [description]\n */\n isCollaborator(username, cb) {\n return this._request('GET', `/repos/${this.__fullname}/collaborators/${username}`, null, cb);\n }\n\n /**\n * Get the contents of a repository\n * @see https://developer.github.com/v3/repos/contents/#get-contents\n * @param {string} ref - the ref to check\n * @param {string} path - the path containing the content to fetch\n * @param {boolean} raw - `true` if the results should be returned raw instead of GitHub's normalized format\n * @param {Requestable.callback} cb - will receive the fetched data\n * @return {Promise} - the promise for the http request\n */\n getContents(ref, path, raw, cb) {\n path = path ? `${encodeURI(path)}` : '';\n return this._request('GET', `/repos/${this.__fullname}/contents/${path}`, {\n ref,\n }, cb, raw);\n }\n\n /**\n * Get the README of a repository\n * @see https://developer.github.com/v3/repos/contents/#get-the-readme\n * @param {string} ref - the ref to check\n * @param {boolean} raw - `true` if the results should be returned raw instead of GitHub's normalized format\n * @param {Requestable.callback} cb - will receive the fetched data\n * @return {Promise} - the promise for the http request\n */\n getReadme(ref, raw, cb) {\n return this._request('GET', `/repos/${this.__fullname}/readme`, {\n ref,\n }, cb, raw);\n }\n\n /**\n * Fork a repository\n * @see https://developer.github.com/v3/repos/forks/#create-a-fork\n * @param {Requestable.callback} cb - will receive the information about the newly created fork\n * @return {Promise} - the promise for the http request\n */\n fork(cb) {\n return this._request('POST', `/repos/${this.__fullname}/forks`, null, cb);\n }\n\n /**\n * List a repository's forks\n * @see https://developer.github.com/v3/repos/forks/#list-forks\n * @param {Requestable.callback} cb - will receive the list of repositories forked from this one\n * @return {Promise} - the promise for the http request\n */\n listForks(cb) {\n return this._request('GET', `/repos/${this.__fullname}/forks`, null, cb);\n }\n\n /**\n * Create a new branch from an existing branch.\n * @param {string} [oldBranch=master] - the name of the existing branch\n * @param {string} newBranch - the name of the new branch\n * @param {Requestable.callback} cb - will receive the commit data for the head of the new branch\n * @return {Promise} - the promise for the http request\n */\n createBranch(oldBranch, newBranch, cb) {\n if (typeof newBranch === 'function') {\n cb = newBranch;\n newBranch = oldBranch;\n oldBranch = 'master';\n }\n\n return this.getRef(`heads/${oldBranch}`)\n .then((response) => {\n let sha = response.data.object.sha;\n return this.createRef({\n sha,\n ref: `refs/heads/${newBranch}`,\n }, cb);\n });\n }\n\n /**\n * Create a new pull request\n * @see https://developer.github.com/v3/pulls/#create-a-pull-request\n * @param {Object} options - the pull request description\n * @param {Requestable.callback} cb - will receive the new pull request\n * @return {Promise} - the promise for the http request\n */\n createPullRequest(options, cb) {\n return this._request('POST', `/repos/${this.__fullname}/pulls`, options, cb);\n }\n\n /**\n * Update a pull request\n * @see https://developer.github.com/v3/pulls/#update-a-pull-request\n * @param {number|string} number - the number of the pull request to update\n * @param {Object} options - the pull request description\n * @param {Requestable.callback} [cb] - will receive the pull request information\n * @return {Promise} - the promise for the http request\n */\n updatePullRequest(number, options, cb) {\n return this._request('PATCH', `/repos/${this.__fullname}/pulls/${number}`, options, cb);\n }\n\n /**\n * List the hooks for the repository\n * @see https://developer.github.com/v3/repos/hooks/#list-hooks\n * @param {Requestable.callback} cb - will receive the list of hooks\n * @return {Promise} - the promise for the http request\n */\n listHooks(cb) {\n return this._request('GET', `/repos/${this.__fullname}/hooks`, null, cb);\n }\n\n /**\n * Get a hook for the repository\n * @see https://developer.github.com/v3/repos/hooks/#get-single-hook\n * @param {number} id - the id of the webook\n * @param {Requestable.callback} cb - will receive the details of the webook\n * @return {Promise} - the promise for the http request\n */\n getHook(id, cb) {\n return this._request('GET', `/repos/${this.__fullname}/hooks/${id}`, null, cb);\n }\n\n /**\n * Add a new hook to the repository\n * @see https://developer.github.com/v3/repos/hooks/#create-a-hook\n * @param {Object} options - the configuration describing the new hook\n * @param {Requestable.callback} cb - will receive the new webhook\n * @return {Promise} - the promise for the http request\n */\n createHook(options, cb) {\n return this._request('POST', `/repos/${this.__fullname}/hooks`, options, cb);\n }\n\n /**\n * Edit an existing webhook\n * @see https://developer.github.com/v3/repos/hooks/#edit-a-hook\n * @param {number} id - the id of the webhook\n * @param {Object} options - the new description of the webhook\n * @param {Requestable.callback} cb - will receive the updated webhook\n * @return {Promise} - the promise for the http request\n */\n updateHook(id, options, cb) {\n return this._request('PATCH', `/repos/${this.__fullname}/hooks/${id}`, options, cb);\n }\n\n /**\n * Delete a webhook\n * @see https://developer.github.com/v3/repos/hooks/#delete-a-hook\n * @param {number} id - the id of the webhook to be deleted\n * @param {Requestable.callback} cb - will receive true if the call is successful\n * @return {Promise} - the promise for the http request\n */\n deleteHook(id, cb) {\n return this._request('DELETE', `/repos/${this.__fullname}/hooks/${id}`, null, cb);\n }\n\n /**\n * List the deploy keys for the repository\n * @see https://developer.github.com/v3/repos/keys/#list-deploy-keys\n * @param {Requestable.callback} cb - will receive the list of deploy keys\n * @return {Promise} - the promise for the http request\n */\n listKeys(cb) {\n return this._request('GET', `/repos/${this.__fullname}/keys`, null, cb);\n }\n\n /**\n * Get a deploy key for the repository\n * @see https://developer.github.com/v3/repos/keys/#get-a-deploy-key\n * @param {number} id - the id of the deploy key\n * @param {Requestable.callback} cb - will receive the details of the deploy key\n * @return {Promise} - the promise for the http request\n */\n getKey(id, cb) {\n return this._request('GET', `/repos/${this.__fullname}/keys/${id}`, null, cb);\n }\n\n /**\n * Add a new deploy key to the repository\n * @see https://developer.github.com/v3/repos/keys/#add-a-new-deploy-key\n * @param {Object} options - the configuration describing the new deploy key\n * @param {Requestable.callback} cb - will receive the new deploy key\n * @return {Promise} - the promise for the http request\n */\n createKey(options, cb) {\n return this._request('POST', `/repos/${this.__fullname}/keys`, options, cb);\n }\n\n /**\n * Delete a deploy key\n * @see https://developer.github.com/v3/repos/keys/#remove-a-deploy-key\n * @param {number} id - the id of the deploy key to be deleted\n * @param {Requestable.callback} cb - will receive true if the call is successful\n * @return {Promise} - the promise for the http request\n */\n deleteKey(id, cb) {\n return this._request('DELETE', `/repos/${this.__fullname}/keys/${id}`, null, cb);\n }\n\n /**\n * Delete a file from a branch\n * @see https://developer.github.com/v3/repos/contents/#delete-a-file\n * @param {string} branch - the branch to delete from, or the default branch if not specified\n * @param {string} path - the path of the file to remove\n * @param {Requestable.callback} cb - will receive the commit in which the delete occurred\n * @return {Promise} - the promise for the http request\n */\n deleteFile(branch, path, cb) {\n return this.getSha(branch, path)\n .then((response) => {\n const deleteCommit = {\n message: `Delete the file at '${path}'`,\n sha: response.data.sha,\n branch,\n };\n return this._request('DELETE', `/repos/${this.__fullname}/contents/${path}`, deleteCommit, cb);\n });\n }\n\n /**\n * Change all references in a repo from oldPath to new_path\n * @param {string} branch - the branch to carry out the reference change, or the default branch if not specified\n * @param {string} oldPath - original path\n * @param {string} newPath - new reference path\n * @param {Requestable.callback} cb - will receive the commit in which the move occurred\n * @return {Promise} - the promise for the http request\n */\n move(branch, oldPath, newPath, cb) {\n let oldSha;\n return this.getRef(`heads/${branch}`)\n .then(({data: {object}}) => this.getTree(`${object.sha}?recursive=true`))\n .then(({data: {tree, sha}}) => {\n oldSha = sha;\n let newTree = tree.map((ref) => {\n if (ref.path === oldPath) {\n ref.path = newPath;\n }\n if (ref.type === 'tree') {\n delete ref.sha;\n }\n return ref;\n });\n return this.createTree(newTree);\n })\n .then(({data: tree}) => this.commit(oldSha, tree.sha, `Renamed '${oldPath}' to '${newPath}'`))\n .then(({data: commit}) => this.updateHead(`heads/${branch}`, commit.sha, true, cb));\n }\n\n /**\n * Write a file to the repository\n * @see https://developer.github.com/v3/repos/contents/#update-a-file\n * @param {string} branch - the name of the branch\n * @param {string} path - the path for the file\n * @param {string} content - the contents of the file\n * @param {string} message - the commit message\n * @param {Object} [options] - commit options\n * @param {Object} [options.author] - the author of the commit\n * @param {Object} [options.commiter] - the committer\n * @param {boolean} [options.encode] - true if the content should be base64 encoded\n * @param {Requestable.callback} cb - will receive the new commit\n * @return {Promise} - the promise for the http request\n */\n writeFile(branch, path, content, message, options, cb) {\n if (typeof options === 'function') {\n cb = options;\n options = {};\n }\n let filePath = path ? encodeURI(path) : '';\n let shouldEncode = options.encode !== false;\n let commit = {\n branch,\n message,\n author: options.author,\n committer: options.committer,\n content: shouldEncode ? Base64.encode(content) : content,\n };\n\n return this.getSha(branch, filePath)\n .then((response) => {\n commit.sha = response.data.sha;\n return this._request('PUT', `/repos/${this.__fullname}/contents/${filePath}`, commit, cb);\n }, () => {\n return this._request('PUT', `/repos/${this.__fullname}/contents/${filePath}`, commit, cb);\n });\n }\n\n /**\n * Check if a repository is starred by you\n * @see https://developer.github.com/v3/activity/starring/#check-if-you-are-starring-a-repository\n * @param {Requestable.callback} cb - will receive true if the repository is starred and false if the repository\n * is not starred\n * @return {Promise} - the promise for the http request {Boolean} [description]\n */\n isStarred(cb) {\n return this._request204or404(`/user/starred/${this.__fullname}`, null, cb);\n }\n\n /**\n * Star a repository\n * @see https://developer.github.com/v3/activity/starring/#star-a-repository\n * @param {Requestable.callback} cb - will receive true if the repository is starred\n * @return {Promise} - the promise for the http request\n */\n star(cb) {\n return this._request('PUT', `/user/starred/${this.__fullname}`, null, cb);\n }\n\n /**\n * Unstar a repository\n * @see https://developer.github.com/v3/activity/starring/#unstar-a-repository\n * @param {Requestable.callback} cb - will receive true if the repository is unstarred\n * @return {Promise} - the promise for the http request\n */\n unstar(cb) {\n return this._request('DELETE', `/user/starred/${this.__fullname}`, null, cb);\n }\n\n /**\n * Create a new release\n * @see https://developer.github.com/v3/repos/releases/#create-a-release\n * @param {Object} options - the description of the release\n * @param {Requestable.callback} cb - will receive the newly created release\n * @return {Promise} - the promise for the http request\n */\n createRelease(options, cb) {\n return this._request('POST', `/repos/${this.__fullname}/releases`, options, cb);\n }\n\n /**\n * Edit a release\n * @see https://developer.github.com/v3/repos/releases/#edit-a-release\n * @param {string} id - the id of the release\n * @param {Object} options - the description of the release\n * @param {Requestable.callback} cb - will receive the modified release\n * @return {Promise} - the promise for the http request\n */\n updateRelease(id, options, cb) {\n return this._request('PATCH', `/repos/${this.__fullname}/releases/${id}`, options, cb);\n }\n\n /**\n * Get information about all releases\n * @see https://developer.github.com/v3/repos/releases/#list-releases-for-a-repository\n * @param {Requestable.callback} cb - will receive the release information\n * @return {Promise} - the promise for the http request\n */\n listReleases(cb) {\n return this._request('GET', `/repos/${this.__fullname}/releases`, null, cb);\n }\n\n /**\n * Get information about a release\n * @see https://developer.github.com/v3/repos/releases/#get-a-single-release\n * @param {string} id - the id of the release\n * @param {Requestable.callback} cb - will receive the release information\n * @return {Promise} - the promise for the http request\n */\n getRelease(id, cb) {\n return this._request('GET', `/repos/${this.__fullname}/releases/${id}`, null, cb);\n }\n\n /**\n * Delete a release\n * @see https://developer.github.com/v3/repos/releases/#delete-a-release\n * @param {string} id - the release to be deleted\n * @param {Requestable.callback} cb - will receive true if the operation is successful\n * @return {Promise} - the promise for the http request\n */\n deleteRelease(id, cb) {\n return this._request('DELETE', `/repos/${this.__fullname}/releases/${id}`, null, cb);\n }\n\n /**\n * Merge a pull request\n * @see https://developer.github.com/v3/pulls/#merge-a-pull-request-merge-button\n * @param {number|string} number - the number of the pull request to merge\n * @param {Object} options - the merge options for the pull request\n * @param {Requestable.callback} [cb] - will receive the merge information if the operation is successful\n * @return {Promise} - the promise for the http request\n */\n mergePullRequest(number, options, cb) {\n return this._request('PUT', `/repos/${this.__fullname}/pulls/${number}/merge`, options, cb);\n }\n\n /**\n * Get information about all projects\n * @see https://developer.github.com/v3/projects/#list-repository-projects\n * @param {Requestable.callback} [cb] - will receive the list of projects\n * @return {Promise} - the promise for the http request\n */\n listProjects(cb) {\n return this._requestAllPages(`/repos/${this.__fullname}/projects`, {AcceptHeader: 'inertia-preview'}, cb);\n }\n\n /**\n * Create a new project\n * @see https://developer.github.com/v3/projects/#create-a-repository-project\n * @param {Object} options - the description of the project\n * @param {Requestable.callback} cb - will receive the newly created project\n * @return {Promise} - the promise for the http request\n */\n createProject(options, cb) {\n options = options || {};\n options.AcceptHeader = 'inertia-preview';\n return this._request('POST', `/repos/${this.__fullname}/projects`, options, cb);\n }\n\n}\n\nmodule.exports = Repository;\n","/**\n * @file\n * @copyright 2016 Yahoo Inc.\n * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n * Github.js is freely distributable.\n */\n\nimport axios from 'axios';\nimport debug from 'debug';\nimport {Base64} from 'js-base64';\n\nconst log = debug('github:request');\n\n/**\n * The error structure returned when a network call fails\n */\nclass ResponseError extends Error {\n /**\n * Construct a new ResponseError\n * @param {string} message - an message to return instead of the the default error message\n * @param {string} path - the requested path\n * @param {Object} response - the object returned by Axios\n */\n constructor(message, path, response) {\n super(message);\n this.path = path;\n this.request = response.config;\n this.response = (response || {}).response || response;\n this.status = response.status;\n }\n}\n\n/**\n * Requestable wraps the logic for making http requests to the API\n */\nclass Requestable {\n /**\n * Either a username and password or an oauth token for Github\n * @typedef {Object} Requestable.auth\n * @prop {string} [username] - the Github username\n * @prop {string} [password] - the user's password\n * @prop {token} [token] - an OAuth token\n */\n /**\n * Initialize the http internals.\n * @param {Requestable.auth} [auth] - the credentials to authenticate to Github. If auth is\n * not provided request will be made unauthenticated\n * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n * @param {string} [AcceptHeader=v3] - the accept header for the requests\n */\n constructor(auth, apiBase, AcceptHeader) {\n this.__apiBase = apiBase || 'https://api.github.com';\n this.__auth = {\n token: auth.token,\n username: auth.username,\n password: auth.password,\n };\n this.__AcceptHeader = AcceptHeader || 'v3';\n\n if (auth.token) {\n this.__authorizationHeader = 'token ' + auth.token;\n } else if (auth.username && auth.password) {\n this.__authorizationHeader = 'Basic ' + Base64.encode(auth.username + ':' + auth.password);\n }\n }\n\n /**\n * Compute the URL to use to make a request.\n * @private\n * @param {string} path - either a URL relative to the API base or an absolute URL\n * @return {string} - the URL to use\n */\n __getURL(path) {\n let url = path;\n\n if (path.indexOf('//') === -1) {\n url = this.__apiBase + path;\n }\n\n let newCacheBuster = 'timestamp=' + new Date().getTime();\n return url.replace(/(timestamp=\\d+)/, newCacheBuster);\n }\n\n /**\n * Compute the headers required for an API request.\n * @private\n * @param {boolean} raw - if the request should be treated as JSON or as a raw request\n * @param {string} AcceptHeader - the accept header for the request\n * @return {Object} - the headers to use in the request\n */\n __getRequestHeaders(raw, AcceptHeader) {\n let headers = {\n 'Content-Type': 'application/json;charset=UTF-8',\n 'Accept': 'application/vnd.github.' + (AcceptHeader || this.__AcceptHeader),\n };\n\n if (raw) {\n headers.Accept += '.raw';\n }\n headers.Accept += '+json';\n\n if (this.__authorizationHeader) {\n headers.Authorization = this.__authorizationHeader;\n }\n\n return headers;\n }\n\n /**\n * Sets the default options for API requests\n * @protected\n * @param {Object} [requestOptions={}] - the current options for the request\n * @return {Object} - the options to pass to the request\n */\n _getOptionsWithDefaults(requestOptions = {}) {\n if (!(requestOptions.visibility || requestOptions.affiliation)) {\n requestOptions.type = requestOptions.type || 'all';\n }\n requestOptions.sort = requestOptions.sort || 'updated';\n requestOptions.per_page = requestOptions.per_page || '100'; // eslint-disable-line\n\n return requestOptions;\n }\n\n /**\n * if a `Date` is passed to this function it will be converted to an ISO string\n * @param {*} date - the object to attempt to cooerce into an ISO date string\n * @return {string} - the ISO representation of `date` or whatever was passed in if it was not a date\n */\n _dateToISO(date) {\n if (date && (date instanceof Date)) {\n date = date.toISOString();\n }\n\n return date;\n }\n\n /**\n * A function that receives the result of the API request.\n * @callback Requestable.callback\n * @param {Requestable.Error} error - the error returned by the API or `null`\n * @param {(Object|true)} result - the data returned by the API or `true` if the API returns `204 No Content`\n * @param {Object} request - the raw {@linkcode https://github.com/mzabriskie/axios#response-schema Response}\n */\n /**\n * Make a request.\n * @param {string} method - the method for the request (GET, PUT, POST, DELETE)\n * @param {string} path - the path for the request\n * @param {*} [data] - the data to send to the server. For HTTP methods that don't have a body the data\n * will be sent as query parameters\n * @param {Requestable.callback} [cb] - the callback for the request\n * @param {boolean} [raw=false] - if the request should be sent as raw. If this is a falsy value then the\n * request will be made as JSON\n * @return {Promise} - the Promise for the http request\n */\n _request(method, path, data, cb, raw) {\n const url = this.__getURL(path);\n\n const AcceptHeader = (data || {}).AcceptHeader;\n if (AcceptHeader) {\n delete data.AcceptHeader;\n }\n const headers = this.__getRequestHeaders(raw, AcceptHeader);\n\n let queryParams = {};\n\n const shouldUseDataAsParams = data && (typeof data === 'object') && methodHasNoBody(method);\n if (shouldUseDataAsParams) {\n queryParams = data;\n data = undefined;\n }\n\n const config = {\n url: url,\n method: method,\n headers: headers,\n params: queryParams,\n data: data,\n responseType: raw ? 'text' : 'json',\n };\n\n log(`${config.method} to ${config.url}`);\n const requestPromise = axios(config).catch(callbackErrorOrThrow(cb, path));\n\n if (cb) {\n requestPromise.then((response) => {\n if (response.data && Object.keys(response.data).length > 0) {\n // When data has results\n cb(null, response.data, response);\n } else if (config.method !== 'GET' && Object.keys(response.data).length < 1) {\n // True when successful submit a request and receive a empty object\n cb(null, (response.status < 300), response);\n } else {\n cb(null, response.data, response);\n }\n });\n }\n\n return requestPromise;\n }\n\n /**\n * Make a request to an endpoint the returns 204 when true and 404 when false\n * @param {string} path - the path to request\n * @param {Object} data - any query parameters for the request\n * @param {Requestable.callback} cb - the callback that will receive `true` or `false`\n * @param {method} [method=GET] - HTTP Method to use\n * @return {Promise} - the promise for the http request\n */\n _request204or404(path, data, cb, method = 'GET') {\n return this._request(method, path, data)\n .then(function success(response) {\n if (cb) {\n cb(null, true, response);\n }\n return true;\n }, function failure(response) {\n if (response.response.status === 404) {\n if (cb) {\n cb(null, false, response);\n }\n return false;\n }\n\n if (cb) {\n cb(response);\n }\n throw response;\n });\n }\n\n /**\n * Make a request and fetch all the available data. Github will paginate responses so for queries\n * that might span multiple pages this method is preferred to {@link Requestable#request}\n * @param {string} path - the path to request\n * @param {Object} options - the query parameters to include\n * @param {Requestable.callback} [cb] - the function to receive the data. The returned data will always be an array.\n * @param {Object[]} results - the partial results. This argument is intended for interal use only.\n * @return {Promise} - a promise which will resolve when all pages have been fetched\n * @deprecated This will be folded into {@link Requestable#_request} in the 2.0 release.\n */\n _requestAllPages(path, options, cb, results) {\n results = results || [];\n\n return this._request('GET', path, options)\n .then((response) => {\n let thisGroup;\n if (response.data instanceof Array) {\n thisGroup = response.data;\n } else if (response.data.items instanceof Array) {\n thisGroup = response.data.items;\n } else {\n let message = `cannot figure out how to append ${response.data} to the result set`;\n throw new ResponseError(message, path, response);\n }\n results.push(...thisGroup);\n\n const nextUrl = getNextPage(response.headers.link);\n if (nextUrl && typeof options.page !== 'number') {\n log(`getting next page: ${nextUrl}`);\n return this._requestAllPages(nextUrl, options, cb, results);\n }\n\n if (cb) {\n cb(null, results, response);\n }\n\n response.data = results;\n return response;\n }).catch(callbackErrorOrThrow(cb, path));\n }\n}\n\nmodule.exports = Requestable;\n\n// ////////////////////////// //\n// Private helper functions //\n// ////////////////////////// //\nconst METHODS_WITH_NO_BODY = ['GET', 'HEAD', 'DELETE'];\nfunction methodHasNoBody(method) {\n return METHODS_WITH_NO_BODY.indexOf(method) !== -1;\n}\n\nfunction getNextPage(linksHeader = '') {\n const links = linksHeader.split(/\\s*,\\s*/); // splits and strips the urls\n return links.reduce(function(nextUrl, link) {\n if (link.search(/rel=\"next\"/) !== -1) {\n return (link.match(/<(.*)>/) || [])[1];\n }\n\n return nextUrl;\n }, undefined);\n}\n\nfunction callbackErrorOrThrow(cb, path) {\n return function handler(object) {\n let error;\n if (object.hasOwnProperty('config')) {\n const {response: {status, statusText}, config: {method, url}} = object;\n let message = (`${status} error making request ${method} ${url}: \"${statusText}\"`);\n error = new ResponseError(message, path, object);\n log(`${message} ${JSON.stringify(object.data)}`);\n } else {\n error = object;\n }\n if (cb) {\n log('going to error callback');\n cb(error);\n } else {\n log('throwing error');\n throw error;\n }\n };\n}\n","/**\n * @file\n * @copyright 2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n * Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\nimport debug from 'debug';\nconst log = debug('github:search');\n\n/**\n * Wrap the Search API\n */\nclass Search extends Requestable {\n /**\n * Create a Search\n * @param {Object} defaults - defaults for the search\n * @param {Requestable.auth} [auth] - information required to authenticate to Github\n * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n */\n constructor(defaults, auth, apiBase) {\n super(auth, apiBase);\n this.__defaults = this._getOptionsWithDefaults(defaults);\n }\n\n /**\n * Available search options\n * @see https://developer.github.com/v3/search/#parameters\n * @typedef {Object} Search.Params\n * @param {string} q - the query to make\n * @param {string} sort - the sort field, one of `stars`, `forks`, or `updated`.\n * Default is [best match](https://developer.github.com/v3/search/#ranking-search-results)\n * @param {string} order - the ordering, either `asc` or `desc`\n */\n /**\n * Perform a search on the GitHub API\n * @private\n * @param {string} path - the scope of the search\n * @param {Search.Params} [withOptions] - additional parameters for the search\n * @param {Requestable.callback} [cb] - will receive the results of the search\n * @return {Promise} - the promise for the http request\n */\n _search(path, withOptions = {}, cb = undefined) {\n let requestOptions = {};\n Object.keys(this.__defaults).forEach((prop) => {\n requestOptions[prop] = this.__defaults[prop];\n });\n Object.keys(withOptions).forEach((prop) => {\n requestOptions[prop] = withOptions[prop];\n });\n\n log(`searching ${path} with options:`, requestOptions);\n return this._requestAllPages(`/search/${path}`, requestOptions, cb);\n }\n\n /**\n * Search for repositories\n * @see https://developer.github.com/v3/search/#search-repositories\n * @param {Search.Params} [options] - additional parameters for the search\n * @param {Requestable.callback} [cb] - will receive the results of the search\n * @return {Promise} - the promise for the http request\n */\n forRepositories(options, cb) {\n return this._search('repositories', options, cb);\n }\n\n /**\n * Search for code\n * @see https://developer.github.com/v3/search/#search-code\n * @param {Search.Params} [options] - additional parameters for the search\n * @param {Requestable.callback} [cb] - will receive the results of the search\n * @return {Promise} - the promise for the http request\n */\n forCode(options, cb) {\n return this._search('code', options, cb);\n }\n\n /**\n * Search for issues\n * @see https://developer.github.com/v3/search/#search-issues\n * @param {Search.Params} [options] - additional parameters for the search\n * @param {Requestable.callback} [cb] - will receive the results of the search\n * @return {Promise} - the promise for the http request\n */\n forIssues(options, cb) {\n return this._search('issues', options, cb);\n }\n\n /**\n * Search for users\n * @see https://developer.github.com/v3/search/#search-users\n * @param {Search.Params} [options] - additional parameters for the search\n * @param {Requestable.callback} [cb] - will receive the results of the search\n * @return {Promise} - the promise for the http request\n */\n forUsers(options, cb) {\n return this._search('users', options, cb);\n }\n}\n\nmodule.exports = Search;\n","/**\n * @file\n * @copyright 2016 Matt Smith (Development Seed)\n * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n * Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\nimport debug from 'debug';\nconst log = debug('github:team');\n\n/**\n * A Team allows scoping of API requests to a particular Github Organization Team.\n */\nclass Team extends Requestable {\n /**\n * Create a Team.\n * @param {string} [teamId] - the id for the team\n * @param {Requestable.auth} [auth] - information required to authenticate to Github\n * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n */\n constructor(teamId, auth, apiBase) {\n super(auth, apiBase);\n this.__teamId = teamId;\n }\n\n /**\n * Get Team information\n * @see https://developer.github.com/v3/orgs/teams/#get-team\n * @param {Requestable.callback} [cb] - will receive the team\n * @return {Promise} - the promise for the http request\n */\n getTeam(cb) {\n log(`Fetching Team ${this.__teamId}`);\n return this._request('Get', `/teams/${this.__teamId}`, undefined, cb);\n }\n\n /**\n * List the Team's repositories\n * @see https://developer.github.com/v3/orgs/teams/#list-team-repos\n * @param {Requestable.callback} [cb] - will receive the list of repositories\n * @return {Promise} - the promise for the http request\n */\n listRepos(cb) {\n log(`Fetching repositories for Team ${this.__teamId}`);\n return this._requestAllPages(`/teams/${this.__teamId}/repos`, undefined, cb);\n }\n\n /**\n * Edit Team information\n * @see https://developer.github.com/v3/orgs/teams/#edit-team\n * @param {object} options - Parameters for team edit\n * @param {string} options.name - The name of the team\n * @param {string} [options.description] - Team description\n * @param {string} [options.repo_names] - Repos to add the team to\n * @param {string} [options.privacy=secret] - The level of privacy the team should have. Can be either one\n * of: `secret`, or `closed`\n * @param {Requestable.callback} [cb] - will receive the updated team\n * @return {Promise} - the promise for the http request\n */\n editTeam(options, cb) {\n log(`Editing Team ${this.__teamId}`);\n return this._request('PATCH', `/teams/${this.__teamId}`, options, cb);\n }\n\n /**\n * List the users who are members of the Team\n * @see https://developer.github.com/v3/orgs/teams/#list-team-members\n * @param {object} options - Parameters for listing team users\n * @param {string} [options.role=all] - can be one of: `all`, `maintainer`, or `member`\n * @param {Requestable.callback} [cb] - will receive the list of users\n * @return {Promise} - the promise for the http request\n */\n listMembers(options, cb) {\n log(`Getting members of Team ${this.__teamId}`);\n return this._requestAllPages(`/teams/${this.__teamId}/members`, options, cb);\n }\n\n /**\n * Get Team membership status for a user\n * @see https://developer.github.com/v3/orgs/teams/#get-team-membership\n * @param {string} username - can be one of: `all`, `maintainer`, or `member`\n * @param {Requestable.callback} [cb] - will receive the membership status of a user\n * @return {Promise} - the promise for the http request\n */\n getMembership(username, cb) {\n log(`Getting membership of user ${username} in Team ${this.__teamId}`);\n return this._request('GET', `/teams/${this.__teamId}/memberships/${username}`, undefined, cb);\n }\n\n /**\n * Add a member to the Team\n * @see https://developer.github.com/v3/orgs/teams/#add-team-membership\n * @param {string} username - can be one of: `all`, `maintainer`, or `member`\n * @param {object} options - Parameters for adding a team member\n * @param {string} [options.role=member] - The role that this user should have in the team. Can be one\n * of: `member`, or `maintainer`\n * @param {Requestable.callback} [cb] - will receive the membership status of added user\n * @return {Promise} - the promise for the http request\n */\n addMembership(username, options, cb) {\n log(`Adding user ${username} to Team ${this.__teamId}`);\n return this._request('PUT', `/teams/${this.__teamId}/memberships/${username}`, options, cb);\n }\n\n /**\n * Get repo management status for team\n * @see https://developer.github.com/v3/orgs/teams/#remove-team-membership\n * @param {string} owner - Organization name\n * @param {string} repo - Repo name\n * @param {Requestable.callback} [cb] - will receive the membership status of added user\n * @return {Promise} - the promise for the http request\n */\n isManagedRepo(owner, repo, cb) {\n log(`Getting repo management by Team ${this.__teamId} for repo ${owner}/${repo}`);\n return this._request204or404(`/teams/${this.__teamId}/repos/${owner}/${repo}`, undefined, cb);\n }\n\n /**\n * Add or Update repo management status for team\n * @see https://developer.github.com/v3/orgs/teams/#add-or-update-team-repository\n * @param {string} owner - Organization name\n * @param {string} repo - Repo name\n * @param {object} options - Parameters for adding or updating repo management for the team\n * @param {string} [options.permission] - The permission to grant the team on this repository. Can be one\n * of: `pull`, `push`, or `admin`\n * @param {Requestable.callback} [cb] - will receive the membership status of added user\n * @return {Promise} - the promise for the http request\n */\n manageRepo(owner, repo, options, cb) {\n log(`Adding or Updating repo management by Team ${this.__teamId} for repo ${owner}/${repo}`);\n return this._request204or404(`/teams/${this.__teamId}/repos/${owner}/${repo}`, options, cb, 'PUT');\n }\n\n /**\n * Remove repo management status for team\n * @see https://developer.github.com/v3/orgs/teams/#remove-team-repository\n * @param {string} owner - Organization name\n * @param {string} repo - Repo name\n * @param {Requestable.callback} [cb] - will receive the membership status of added user\n * @return {Promise} - the promise for the http request\n */\n unmanageRepo(owner, repo, cb) {\n log(`Remove repo management by Team ${this.__teamId} for repo ${owner}/${repo}`);\n return this._request204or404(`/teams/${this.__teamId}/repos/${owner}/${repo}`, undefined, cb, 'DELETE');\n }\n\n /**\n * Delete Team\n * @see https://developer.github.com/v3/orgs/teams/#delete-team\n * @param {Requestable.callback} [cb] - will receive the list of repositories\n * @return {Promise} - the promise for the http request\n */\n deleteTeam(cb) {\n log(`Deleting Team ${this.__teamId}`);\n return this._request204or404(`/teams/${this.__teamId}`, undefined, cb, 'DELETE');\n }\n}\n\nmodule.exports = Team;\n","/**\n * @file\n * @copyright 2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n * Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\nimport debug from 'debug';\nconst log = debug('github:user');\n\n/**\n * A User allows scoping of API requests to a particular Github user.\n */\nclass User extends Requestable {\n /**\n * Create a User.\n * @param {string} [username] - the user to use for user-scoped queries\n * @param {Requestable.auth} [auth] - information required to authenticate to Github\n * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n */\n constructor(username, auth, apiBase) {\n super(auth, apiBase);\n this.__user = username;\n }\n\n /**\n * Get the url for the request. (dependent on if we're requesting for the authenticated user or not)\n * @private\n * @param {string} endpoint - the endpoint being requested\n * @return {string} - the resolved endpoint\n */\n __getScopedUrl(endpoint) {\n if (this.__user) {\n return endpoint ?\n `/users/${this.__user}/${endpoint}` :\n `/users/${this.__user}`\n ;\n\n } else { // eslint-disable-line\n switch (endpoint) {\n case '':\n return '/user';\n\n case 'notifications':\n case 'gists':\n return `/${endpoint}`;\n\n default:\n return `/user/${endpoint}`;\n }\n }\n }\n\n /**\n * List the user's repositories\n * @see https://developer.github.com/v3/repos/#list-user-repositories\n * @param {Object} [options={}] - any options to refine the search\n * @param {Requestable.callback} [cb] - will receive the list of repositories\n * @return {Promise} - the promise for the http request\n */\n listRepos(options, cb) {\n if (typeof options === 'function') {\n cb = options;\n options = {};\n }\n\n options = this._getOptionsWithDefaults(options);\n\n log(`Fetching repositories with options: ${JSON.stringify(options)}`);\n return this._requestAllPages(this.__getScopedUrl('repos'), options, cb);\n }\n\n /**\n * List the orgs that the user belongs to\n * @see https://developer.github.com/v3/orgs/#list-user-organizations\n * @param {Requestable.callback} [cb] - will receive the list of organizations\n * @return {Promise} - the promise for the http request\n */\n listOrgs(cb) {\n return this._request('GET', this.__getScopedUrl('orgs'), null, cb);\n }\n\n /**\n * List the user's gists\n * @see https://developer.github.com/v3/gists/#list-a-users-gists\n * @param {Requestable.callback} [cb] - will receive the list of gists\n * @return {Promise} - the promise for the http request\n */\n listGists(cb) {\n return this._request('GET', this.__getScopedUrl('gists'), null, cb);\n }\n\n /**\n * List the user's starred gists\n * @see https://developer.github.com/v3/gists/#list-starred-gists\n * @param {Requestable.callback} [cb] - will receive the list of gists\n * @return {Promise} - the promise for the http request\n */\n listStarredGists(cb) {\n return this._request('GET', this.__getScopedUrl('gists/starred'), null, cb);\n }\n\n /**\n * List the user's gists\n * @see https://developer.github.com/v3/gists/#list-a-users-gists\n * @param {Requestable.callback} [cb] - will receive the list of gists\n * @return {Promise} - the promise for the http request\n */\n listStarredGists(cb) {\n return this._request('GET', this.__getScopedUrl('gists'), null, cb);\n }\n\n /**\n * List the user's notifications\n * @see https://developer.github.com/v3/activity/notifications/#list-your-notifications\n * @param {Object} [options={}] - any options to refine the search\n * @param {Requestable.callback} [cb] - will receive the list of repositories\n * @return {Promise} - the promise for the http request\n */\n listNotifications(options, cb) {\n options = options || {};\n if (typeof options === 'function') {\n cb = options;\n options = {};\n }\n\n options.since = this._dateToISO(options.since);\n options.before = this._dateToISO(options.before);\n\n return this._request('GET', this.__getScopedUrl('notifications'), options, cb);\n }\n\n /**\n * Show the user's profile\n * @see https://developer.github.com/v3/users/#get-a-single-user\n * @param {Requestable.callback} [cb] - will receive the user's information\n * @return {Promise} - the promise for the http request\n */\n getProfile(cb) {\n return this._request('GET', this.__getScopedUrl(''), null, cb);\n }\n\n /**\n * Gets the list of starred repositories for the user\n * @see https://developer.github.com/v3/activity/starring/#list-repositories-being-starred\n * @param {Requestable.callback} [cb] - will receive the list of starred repositories\n * @return {Promise} - the promise for the http request\n */\n listStarredRepos(cb) {\n let requestOptions = this._getOptionsWithDefaults();\n return this._requestAllPages(this.__getScopedUrl('starred'), requestOptions, cb);\n }\n\n /**\n * List email addresses for a user\n * @see https://developer.github.com/v3/users/emails/#list-email-addresses-for-a-user\n * @param {Requestable.callback} [cb] - will receive the list of emails\n * @return {Promise} - the promise for the http request\n */\n getEmails(cb) {\n return this._request('GET', '/user/emails', null, cb);\n }\n\n /**\n * Have the authenticated user follow this user\n * @see https://developer.github.com/v3/users/followers/#follow-a-user\n * @param {string} username - the user to follow\n * @param {Requestable.callback} [cb] - will receive true if the request succeeds\n * @return {Promise} - the promise for the http request\n */\n follow(username, cb) {\n return this._request('PUT', `/user/following/${this.__user}`, null, cb);\n }\n\n /**\n * Have the currently authenticated user unfollow this user\n * @see https://developer.github.com/v3/users/followers/#follow-a-user\n * @param {string} username - the user to unfollow\n * @param {Requestable.callback} [cb] - receives true if the request succeeds\n * @return {Promise} - the promise for the http request\n */\n unfollow(username, cb) {\n return this._request('DELETE', `/user/following/${this.__user}`, null, cb);\n }\n\n /**\n * Create a new repository for the currently authenticated user\n * @see https://developer.github.com/v3/repos/#create\n * @param {object} options - the repository definition\n * @param {Requestable.callback} [cb] - will receive the API response\n * @return {Promise} - the promise for the http request\n */\n createRepo(options, cb) {\n return this._request('POST', '/user/repos', options, cb);\n }\n}\n\nmodule.exports = User;\n"]} \ No newline at end of file diff --git a/dist/components/Gist.js b/dist/components/Gist.js new file mode 100644 index 00000000..2f47d65b --- /dev/null +++ b/dist/components/Gist.js @@ -0,0 +1,258 @@ +'use strict'; + +var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); + +var _Requestable2 = require('./Requestable'); + +var _Requestable3 = _interopRequireDefault(_Requestable2); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } + +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } /** + * @file + * @copyright 2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc. + * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}. + * Github.js is freely distributable. + */ + +/** + * A Gist can retrieve and modify gists. + */ +var Gist = function (_Requestable) { + _inherits(Gist, _Requestable); + + /** + * Create a Gist. + * @param {string} id - the id of the gist (not required when creating a gist) + * @param {Requestable.auth} [auth] - information required to authenticate to Github + * @param {string} [apiBase=https://api.github.com] - the base Github API URL + */ + function Gist(id, auth, apiBase) { + _classCallCheck(this, Gist); + + var _this = _possibleConstructorReturn(this, (Gist.__proto__ || Object.getPrototypeOf(Gist)).call(this, auth, apiBase)); + + _this.__id = id; + return _this; + } + + /** + * Fetch a gist. + * @see https://developer.github.com/v3/gists/#get-a-single-gist + * @param {Requestable.callback} [cb] - will receive the gist + * @return {Promise} - the Promise for the http request + */ + + + _createClass(Gist, [{ + key: 'read', + value: function read(cb) { + return this._request('GET', '/gists/' + this.__id, null, cb); + } + + /** + * Create a new gist. + * @see https://developer.github.com/v3/gists/#create-a-gist + * @param {Object} gist - the data for the new gist + * @param {Requestable.callback} [cb] - will receive the new gist upon creation + * @return {Promise} - the Promise for the http request + */ + + }, { + key: 'create', + value: function create(gist, cb) { + var _this2 = this; + + return this._request('POST', '/gists', gist, cb).then(function (response) { + _this2.__id = response.data.id; + return response; + }); + } + + /** + * Delete a gist. + * @see https://developer.github.com/v3/gists/#delete-a-gist + * @param {Requestable.callback} [cb] - will receive true if the request succeeds + * @return {Promise} - the Promise for the http request + */ + + }, { + key: 'delete', + value: function _delete(cb) { + return this._request('DELETE', '/gists/' + this.__id, null, cb); + } + + /** + * Fork a gist. + * @see https://developer.github.com/v3/gists/#fork-a-gist + * @param {Requestable.callback} [cb] - the function that will receive the gist + * @return {Promise} - the Promise for the http request + */ + + }, { + key: 'fork', + value: function fork(cb) { + return this._request('POST', '/gists/' + this.__id + '/forks', null, cb); + } + + /** + * Update a gist. + * @see https://developer.github.com/v3/gists/#edit-a-gist + * @param {Object} gist - the new data for the gist + * @param {Requestable.callback} [cb] - the function that receives the API result + * @return {Promise} - the Promise for the http request + */ + + }, { + key: 'update', + value: function update(gist, cb) { + return this._request('PATCH', '/gists/' + this.__id, gist, cb); + } + + /** + * Star a gist. + * @see https://developer.github.com/v3/gists/#star-a-gist + * @param {Requestable.callback} [cb] - will receive true if the request is successful + * @return {Promise} - the Promise for the http request + */ + + }, { + key: 'star', + value: function star(cb) { + return this._request('PUT', '/gists/' + this.__id + '/star', null, cb); + } + + /** + * Unstar a gist. + * @see https://developer.github.com/v3/gists/#unstar-a-gist + * @param {Requestable.callback} [cb] - will receive true if the request is successful + * @return {Promise} - the Promise for the http request + */ + + }, { + key: 'unstar', + value: function unstar(cb) { + return this._request('DELETE', '/gists/' + this.__id + '/star', null, cb); + } + + /** + * Check if a gist is starred by the user. + * @see https://developer.github.com/v3/gists/#check-if-a-gist-is-starred + * @param {Requestable.callback} [cb] - will receive true if the gist is starred and false if the gist is not starred + * @return {Promise} - the Promise for the http request + */ + + }, { + key: 'isStarred', + value: function isStarred(cb) { + return this._request204or404('/gists/' + this.__id + '/star', null, cb); + } + + /** + * List the gist's commits + * @see https://developer.github.com/v3/gists/#list-gist-commits + * @param {Requestable.callback} [cb] - will receive the array of commits + * @return {Promise} - the Promise for the http request + */ + + }, { + key: 'listCommits', + value: function listCommits(cb) { + return this._requestAllPages('/gists/' + this.__id + '/commits', null, cb); + } + + /** + * Fetch one of the gist's revision. + * @see https://developer.github.com/v3/gists/#get-a-specific-revision-of-a-gist + * @param {string} revision - the id of the revision + * @param {Requestable.callback} [cb] - will receive the revision + * @return {Promise} - the Promise for the http request + */ + + }, { + key: 'getRevision', + value: function getRevision(revision, cb) { + return this._request('GET', '/gists/' + this.__id + '/' + revision, null, cb); + } + + /** + * List the gist's comments + * @see https://developer.github.com/v3/gists/comments/#list-comments-on-a-gist + * @param {Requestable.callback} [cb] - will receive the array of comments + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'listComments', + value: function listComments(cb) { + return this._requestAllPages('/gists/' + this.__id + '/comments', null, cb); + } + + /** + * Fetch one of the gist's comments + * @see https://developer.github.com/v3/gists/comments/#get-a-single-comment + * @param {number} comment - the id of the comment + * @param {Requestable.callback} [cb] - will receive the comment + * @return {Promise} - the Promise for the http request + */ + + }, { + key: 'getComment', + value: function getComment(comment, cb) { + return this._request('GET', '/gists/' + this.__id + '/comments/' + comment, null, cb); + } + + /** + * Comment on a gist + * @see https://developer.github.com/v3/gists/comments/#create-a-comment + * @param {string} comment - the comment to add + * @param {Requestable.callback} [cb] - the function that receives the API result + * @return {Promise} - the Promise for the http request + */ + + }, { + key: 'createComment', + value: function createComment(comment, cb) { + return this._request('POST', '/gists/' + this.__id + '/comments', { body: comment }, cb); + } + + /** + * Edit a comment on the gist + * @see https://developer.github.com/v3/gists/comments/#edit-a-comment + * @param {number} comment - the id of the comment + * @param {string} body - the new comment + * @param {Requestable.callback} [cb] - will receive the modified comment + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'editComment', + value: function editComment(comment, body, cb) { + return this._request('PATCH', '/gists/' + this.__id + '/comments/' + comment, { body: body }, cb); + } + + /** + * Delete a comment on the gist. + * @see https://developer.github.com/v3/gists/comments/#delete-a-comment + * @param {number} comment - the id of the comment + * @param {Requestable.callback} [cb] - will receive true if the request succeeds + * @return {Promise} - the Promise for the http request + */ + + }, { + key: 'deleteComment', + value: function deleteComment(comment, cb) { + return this._request('DELETE', '/gists/' + this.__id + '/comments/' + comment, null, cb); + } + }]); + + return Gist; +}(_Requestable3.default); + +module.exports = Gist; +//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["Gist.js"],"names":["Gist","id","auth","apiBase","__id","cb","_request","gist","then","response","data","_request204or404","_requestAllPages","revision","comment","body","module","exports"],"mappings":"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","file":"Gist.js","sourcesContent":["/**\n * @file\n * @copyright  2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license    Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n *             Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\n\n/**\n * A Gist can retrieve and modify gists.\n */\nclass Gist extends Requestable {\n   /**\n    * Create a Gist.\n    * @param {string} id - the id of the gist (not required when creating a gist)\n    * @param {Requestable.auth} [auth] - information required to authenticate to Github\n    * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n    */\n   constructor(id, auth, apiBase) {\n      super(auth, apiBase);\n      this.__id = id;\n   }\n\n   /**\n    * Fetch a gist.\n    * @see https://developer.github.com/v3/gists/#get-a-single-gist\n    * @param {Requestable.callback} [cb] - will receive the gist\n    * @return {Promise} - the Promise for the http request\n    */\n   read(cb) {\n      return this._request('GET', `/gists/${this.__id}`, null, cb);\n   }\n\n   /**\n    * Create a new gist.\n    * @see https://developer.github.com/v3/gists/#create-a-gist\n    * @param {Object} gist - the data for the new gist\n    * @param {Requestable.callback} [cb] - will receive the new gist upon creation\n    * @return {Promise} - the Promise for the http request\n    */\n   create(gist, cb) {\n      return this._request('POST', '/gists', gist, cb)\n         .then((response) => {\n            this.__id = response.data.id;\n            return response;\n         });\n   }\n\n   /**\n    * Delete a gist.\n    * @see https://developer.github.com/v3/gists/#delete-a-gist\n    * @param {Requestable.callback} [cb] - will receive true if the request succeeds\n    * @return {Promise} - the Promise for the http request\n    */\n   delete(cb) {\n      return this._request('DELETE', `/gists/${this.__id}`, null, cb);\n   }\n\n   /**\n    * Fork a gist.\n    * @see https://developer.github.com/v3/gists/#fork-a-gist\n    * @param {Requestable.callback} [cb] - the function that will receive the gist\n    * @return {Promise} - the Promise for the http request\n    */\n   fork(cb) {\n      return this._request('POST', `/gists/${this.__id}/forks`, null, cb);\n   }\n\n   /**\n    * Update a gist.\n    * @see https://developer.github.com/v3/gists/#edit-a-gist\n    * @param {Object} gist - the new data for the gist\n    * @param {Requestable.callback} [cb] - the function that receives the API result\n    * @return {Promise} - the Promise for the http request\n    */\n   update(gist, cb) {\n      return this._request('PATCH', `/gists/${this.__id}`, gist, cb);\n   }\n\n   /**\n    * Star a gist.\n    * @see https://developer.github.com/v3/gists/#star-a-gist\n    * @param {Requestable.callback} [cb] - will receive true if the request is successful\n    * @return {Promise} - the Promise for the http request\n    */\n   star(cb) {\n      return this._request('PUT', `/gists/${this.__id}/star`, null, cb);\n   }\n\n   /**\n    * Unstar a gist.\n    * @see https://developer.github.com/v3/gists/#unstar-a-gist\n    * @param {Requestable.callback} [cb] - will receive true if the request is successful\n    * @return {Promise} - the Promise for the http request\n    */\n   unstar(cb) {\n      return this._request('DELETE', `/gists/${this.__id}/star`, null, cb);\n   }\n\n   /**\n    * Check if a gist is starred by the user.\n    * @see https://developer.github.com/v3/gists/#check-if-a-gist-is-starred\n    * @param {Requestable.callback} [cb] - will receive true if the gist is starred and false if the gist is not starred\n    * @return {Promise} - the Promise for the http request\n    */\n   isStarred(cb) {\n      return this._request204or404(`/gists/${this.__id}/star`, null, cb);\n   }\n\n   /**\n    * List the gist's commits\n    * @see https://developer.github.com/v3/gists/#list-gist-commits\n    * @param {Requestable.callback} [cb] - will receive the array of commits\n    * @return {Promise} - the Promise for the http request\n    */\n   listCommits(cb) {\n      return this._requestAllPages(`/gists/${this.__id}/commits`, null, cb);\n   }\n\n   /**\n    * Fetch one of the gist's revision.\n    * @see https://developer.github.com/v3/gists/#get-a-specific-revision-of-a-gist\n    * @param {string} revision - the id of the revision\n    * @param {Requestable.callback} [cb] - will receive the revision\n    * @return {Promise} - the Promise for the http request\n    */\n   getRevision(revision, cb) {\n      return this._request('GET', `/gists/${this.__id}/${revision}`, null, cb);\n   }\n\n   /**\n    * List the gist's comments\n    * @see https://developer.github.com/v3/gists/comments/#list-comments-on-a-gist\n    * @param {Requestable.callback} [cb] - will receive the array of comments\n    * @return {Promise} - the promise for the http request\n    */\n   listComments(cb) {\n      return this._requestAllPages(`/gists/${this.__id}/comments`, null, cb);\n   }\n\n   /**\n    * Fetch one of the gist's comments\n    * @see https://developer.github.com/v3/gists/comments/#get-a-single-comment\n    * @param {number} comment - the id of the comment\n    * @param {Requestable.callback} [cb] - will receive the comment\n    * @return {Promise} - the Promise for the http request\n    */\n   getComment(comment, cb) {\n      return this._request('GET', `/gists/${this.__id}/comments/${comment}`, null, cb);\n   }\n\n   /**\n    * Comment on a gist\n    * @see https://developer.github.com/v3/gists/comments/#create-a-comment\n    * @param {string} comment - the comment to add\n    * @param {Requestable.callback} [cb] - the function that receives the API result\n    * @return {Promise} - the Promise for the http request\n    */\n   createComment(comment, cb) {\n      return this._request('POST', `/gists/${this.__id}/comments`, {body: comment}, cb);\n   }\n\n   /**\n    * Edit a comment on the gist\n    * @see https://developer.github.com/v3/gists/comments/#edit-a-comment\n    * @param {number} comment - the id of the comment\n    * @param {string} body - the new comment\n    * @param {Requestable.callback} [cb] - will receive the modified comment\n    * @return {Promise} - the promise for the http request\n    */\n   editComment(comment, body, cb) {\n      return this._request('PATCH', `/gists/${this.__id}/comments/${comment}`, {body: body}, cb);\n   }\n\n   /**\n    * Delete a comment on the gist.\n    * @see https://developer.github.com/v3/gists/comments/#delete-a-comment\n    * @param {number} comment - the id of the comment\n    * @param {Requestable.callback} [cb] - will receive true if the request succeeds\n    * @return {Promise} - the Promise for the http request\n    */\n   deleteComment(comment, cb) {\n      return this._request('DELETE', `/gists/${this.__id}/comments/${comment}`, null, cb);\n   }\n}\n\nmodule.exports = Gist;\n"]} +//# sourceMappingURL=Gist.js.map diff --git a/dist/components/Gist.js.map b/dist/components/Gist.js.map new file mode 100644 index 00000000..2c367b9c --- /dev/null +++ b/dist/components/Gist.js.map @@ -0,0 +1 @@ +{"version":3,"names":[],"mappings":"","sources":["Gist.js"],"sourcesContent":["/**\n * @file\n * @copyright 2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n * Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\n\n/**\n * A Gist can retrieve and modify gists.\n */\nclass Gist extends Requestable {\n /**\n * Create a Gist.\n * @param {string} id - the id of the gist (not required when creating a gist)\n * @param {Requestable.auth} [auth] - information required to authenticate to Github\n * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n */\n constructor(id, auth, apiBase) {\n super(auth, apiBase);\n this.__id = id;\n }\n\n /**\n * Fetch a gist.\n * @see https://developer.github.com/v3/gists/#get-a-single-gist\n * @param {Requestable.callback} [cb] - will receive the gist\n * @return {Promise} - the Promise for the http request\n */\n read(cb) {\n return this._request('GET', `/gists/${this.__id}`, null, cb);\n }\n\n /**\n * Create a new gist.\n * @see https://developer.github.com/v3/gists/#create-a-gist\n * @param {Object} gist - the data for the new gist\n * @param {Requestable.callback} [cb] - will receive the new gist upon creation\n * @return {Promise} - the Promise for the http request\n */\n create(gist, cb) {\n return this._request('POST', '/gists', gist, cb)\n .then((response) => {\n this.__id = response.data.id;\n return response;\n });\n }\n\n /**\n * Delete a gist.\n * @see https://developer.github.com/v3/gists/#delete-a-gist\n * @param {Requestable.callback} [cb] - will receive true if the request succeeds\n * @return {Promise} - the Promise for the http request\n */\n delete(cb) {\n return this._request('DELETE', `/gists/${this.__id}`, null, cb);\n }\n\n /**\n * Fork a gist.\n * @see https://developer.github.com/v3/gists/#fork-a-gist\n * @param {Requestable.callback} [cb] - the function that will receive the gist\n * @return {Promise} - the Promise for the http request\n */\n fork(cb) {\n return this._request('POST', `/gists/${this.__id}/forks`, null, cb);\n }\n\n /**\n * Update a gist.\n * @see https://developer.github.com/v3/gists/#edit-a-gist\n * @param {Object} gist - the new data for the gist\n * @param {Requestable.callback} [cb] - the function that receives the API result\n * @return {Promise} - the Promise for the http request\n */\n update(gist, cb) {\n return this._request('PATCH', `/gists/${this.__id}`, gist, cb);\n }\n\n /**\n * Star a gist.\n * @see https://developer.github.com/v3/gists/#star-a-gist\n * @param {Requestable.callback} [cb] - will receive true if the request is successful\n * @return {Promise} - the Promise for the http request\n */\n star(cb) {\n return this._request('PUT', `/gists/${this.__id}/star`, null, cb);\n }\n\n /**\n * Unstar a gist.\n * @see https://developer.github.com/v3/gists/#unstar-a-gist\n * @param {Requestable.callback} [cb] - will receive true if the request is successful\n * @return {Promise} - the Promise for the http request\n */\n unstar(cb) {\n return this._request('DELETE', `/gists/${this.__id}/star`, null, cb);\n }\n\n /**\n * Check if a gist is starred by the user.\n * @see https://developer.github.com/v3/gists/#check-if-a-gist-is-starred\n * @param {Requestable.callback} [cb] - will receive true if the gist is starred and false if the gist is not starred\n * @return {Promise} - the Promise for the http request\n */\n isStarred(cb) {\n return this._request204or404(`/gists/${this.__id}/star`, null, cb);\n }\n\n /**\n * List the gist's commits\n * @see https://developer.github.com/v3/gists/#list-gist-commits\n * @param {Requestable.callback} [cb] - will receive the array of commits\n * @return {Promise} - the Promise for the http request\n */\n listCommits(cb) {\n return this._requestAllPages(`/gists/${this.__id}/commits`, null, cb);\n }\n\n /**\n * Fetch one of the gist's revision.\n * @see https://developer.github.com/v3/gists/#get-a-specific-revision-of-a-gist\n * @param {string} revision - the id of the revision\n * @param {Requestable.callback} [cb] - will receive the revision\n * @return {Promise} - the Promise for the http request\n */\n getRevision(revision, cb) {\n return this._request('GET', `/gists/${this.__id}/${revision}`, null, cb);\n }\n\n /**\n * List the gist's comments\n * @see https://developer.github.com/v3/gists/comments/#list-comments-on-a-gist\n * @param {Requestable.callback} [cb] - will receive the array of comments\n * @return {Promise} - the promise for the http request\n */\n listComments(cb) {\n return this._requestAllPages(`/gists/${this.__id}/comments`, null, cb);\n }\n\n /**\n * Fetch one of the gist's comments\n * @see https://developer.github.com/v3/gists/comments/#get-a-single-comment\n * @param {number} comment - the id of the comment\n * @param {Requestable.callback} [cb] - will receive the comment\n * @return {Promise} - the Promise for the http request\n */\n getComment(comment, cb) {\n return this._request('GET', `/gists/${this.__id}/comments/${comment}`, null, cb);\n }\n\n /**\n * Comment on a gist\n * @see https://developer.github.com/v3/gists/comments/#create-a-comment\n * @param {string} comment - the comment to add\n * @param {Requestable.callback} [cb] - the function that receives the API result\n * @return {Promise} - the Promise for the http request\n */\n createComment(comment, cb) {\n return this._request('POST', `/gists/${this.__id}/comments`, {body: comment}, cb);\n }\n\n /**\n * Edit a comment on the gist\n * @see https://developer.github.com/v3/gists/comments/#edit-a-comment\n * @param {number} comment - the id of the comment\n * @param {string} body - the new comment\n * @param {Requestable.callback} [cb] - will receive the modified comment\n * @return {Promise} - the promise for the http request\n */\n editComment(comment, body, cb) {\n return this._request('PATCH', `/gists/${this.__id}/comments/${comment}`, {body: body}, cb);\n }\n\n /**\n * Delete a comment on the gist.\n * @see https://developer.github.com/v3/gists/comments/#delete-a-comment\n * @param {number} comment - the id of the comment\n * @param {Requestable.callback} [cb] - will receive true if the request succeeds\n * @return {Promise} - the Promise for the http request\n */\n deleteComment(comment, cb) {\n return this._request('DELETE', `/gists/${this.__id}/comments/${comment}`, null, cb);\n }\n}\n\nmodule.exports = Gist;\n"],"file":"Gist.js"} \ No newline at end of file diff --git a/dist/components/GitHub.js b/dist/components/GitHub.js new file mode 100644 index 00000000..44959927 --- /dev/null +++ b/dist/components/GitHub.js @@ -0,0 +1,221 @@ +'use strict'; + +var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); /** + * @file + * @copyright 2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc. + * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}. + * Github.js is freely distributable. + */ +/* eslint valid-jsdoc: ["error", {"requireReturnDescription": false}] */ + +var _Gist = require('./Gist'); + +var _Gist2 = _interopRequireDefault(_Gist); + +var _User = require('./User'); + +var _User2 = _interopRequireDefault(_User); + +var _Issue = require('./Issue'); + +var _Issue2 = _interopRequireDefault(_Issue); + +var _Search = require('./Search'); + +var _Search2 = _interopRequireDefault(_Search); + +var _RateLimit = require('./RateLimit'); + +var _RateLimit2 = _interopRequireDefault(_RateLimit); + +var _Repository = require('./Repository'); + +var _Repository2 = _interopRequireDefault(_Repository); + +var _Organization = require('./Organization'); + +var _Organization2 = _interopRequireDefault(_Organization); + +var _Team = require('./Team'); + +var _Team2 = _interopRequireDefault(_Team); + +var _Markdown = require('./Markdown'); + +var _Markdown2 = _interopRequireDefault(_Markdown); + +var _Project = require('./Project'); + +var _Project2 = _interopRequireDefault(_Project); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +/** + * GitHub encapsulates the functionality to create various API wrapper objects. + */ +var GitHub = function () { + /** + * Create a new GitHub. + * @param {Requestable.auth} [auth] - the credentials to authenticate to Github. If auth is + * not provided requests will be made unauthenticated + * @param {string} [apiBase=https://api.github.com] - the base Github API URL + */ + function GitHub(auth) { + var apiBase = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'https://api.github.com'; + + _classCallCheck(this, GitHub); + + this.__apiBase = apiBase; + this.__auth = auth || {}; + } + + /** + * Create a new Gist wrapper + * @param {number} [id] - the id for the gist, leave undefined when creating a new gist + * @return {Gist} + */ + + + _createClass(GitHub, [{ + key: 'getGist', + value: function getGist(id) { + return new _Gist2.default(id, this.__auth, this.__apiBase); + } + + /** + * Create a new User wrapper + * @param {string} [user] - the name of the user to get information about + * leave undefined for the authenticated user + * @return {User} + */ + + }, { + key: 'getUser', + value: function getUser(user) { + return new _User2.default(user, this.__auth, this.__apiBase); + } + + /** + * Create a new Organization wrapper + * @param {string} organization - the name of the organization + * @return {Organization} + */ + + }, { + key: 'getOrganization', + value: function getOrganization(organization) { + return new _Organization2.default(organization, this.__auth, this.__apiBase); + } + + /** + * create a new Team wrapper + * @param {string} teamId - the name of the team + * @return {team} + */ + + }, { + key: 'getTeam', + value: function getTeam(teamId) { + return new _Team2.default(teamId, this.__auth, this.__apiBase); + } + + /** + * Create a new Repository wrapper + * @param {string} user - the user who owns the respository + * @param {string} repo - the name of the repository + * @return {Repository} + */ + + }, { + key: 'getRepo', + value: function getRepo(user, repo) { + return new _Repository2.default(this._getFullName(user, repo), this.__auth, this.__apiBase); + } + + /** + * Create a new Issue wrapper + * @param {string} user - the user who owns the respository + * @param {string} repo - the name of the repository + * @return {Issue} + */ + + }, { + key: 'getIssues', + value: function getIssues(user, repo) { + return new _Issue2.default(this._getFullName(user, repo), this.__auth, this.__apiBase); + } + + /** + * Create a new Search wrapper + * @param {string} query - the query to search for + * @return {Search} + */ + + }, { + key: 'search', + value: function search(query) { + return new _Search2.default(query, this.__auth, this.__apiBase); + } + + /** + * Create a new RateLimit wrapper + * @return {RateLimit} + */ + + }, { + key: 'getRateLimit', + value: function getRateLimit() { + return new _RateLimit2.default(this.__auth, this.__apiBase); + } + + /** + * Create a new Markdown wrapper + * @return {Markdown} + */ + + }, { + key: 'getMarkdown', + value: function getMarkdown() { + return new _Markdown2.default(this.__auth, this.__apiBase); + } + + /** + * Create a new Project wrapper + * @param {string} id - the id of the project + * @return {Markdown} + */ + + }, { + key: 'getProject', + value: function getProject(id) { + return new _Project2.default(id, this.__auth, this.__apiBase); + } + + /** + * Computes the full repository name + * @param {string} user - the username (or the full name) + * @param {string} repo - the repository name, must not be passed if `user` is the full name + * @return {string} the repository's full name + */ + + }, { + key: '_getFullName', + value: function _getFullName(user, repo) { + var fullname = user; + + if (repo) { + fullname = user + '/' + repo; + } + + return fullname; + } + }]); + + return GitHub; +}(); + +module.exports = GitHub; +//# sourceMappingURL=data:application/json;base64,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 +//# sourceMappingURL=GitHub.js.map diff --git a/dist/components/GitHub.js.map b/dist/components/GitHub.js.map new file mode 100644 index 00000000..8496f609 --- /dev/null +++ b/dist/components/GitHub.js.map @@ -0,0 +1 @@ +{"version":3,"names":[],"mappings":"","sources":["GitHub.js"],"sourcesContent":["/**\n * @file\n * @copyright 2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n * Github.js is freely distributable.\n */\n/* eslint valid-jsdoc: [\"error\", {\"requireReturnDescription\": false}] */\n\nimport Gist from './Gist';\nimport User from './User';\nimport Issue from './Issue';\nimport Search from './Search';\nimport RateLimit from './RateLimit';\nimport Repository from './Repository';\nimport Organization from './Organization';\nimport Team from './Team';\nimport Markdown from './Markdown';\nimport Project from './Project';\n\n/**\n * GitHub encapsulates the functionality to create various API wrapper objects.\n */\nclass GitHub {\n /**\n * Create a new GitHub.\n * @param {Requestable.auth} [auth] - the credentials to authenticate to Github. If auth is\n * not provided requests will be made unauthenticated\n * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n */\n constructor(auth, apiBase = 'https://api.github.com') {\n this.__apiBase = apiBase;\n this.__auth = auth || {};\n }\n\n /**\n * Create a new Gist wrapper\n * @param {number} [id] - the id for the gist, leave undefined when creating a new gist\n * @return {Gist}\n */\n getGist(id) {\n return new Gist(id, this.__auth, this.__apiBase);\n }\n\n /**\n * Create a new User wrapper\n * @param {string} [user] - the name of the user to get information about\n * leave undefined for the authenticated user\n * @return {User}\n */\n getUser(user) {\n return new User(user, this.__auth, this.__apiBase);\n }\n\n /**\n * Create a new Organization wrapper\n * @param {string} organization - the name of the organization\n * @return {Organization}\n */\n getOrganization(organization) {\n return new Organization(organization, this.__auth, this.__apiBase);\n }\n\n /**\n * create a new Team wrapper\n * @param {string} teamId - the name of the team\n * @return {team}\n */\n getTeam(teamId) {\n return new Team(teamId, this.__auth, this.__apiBase);\n }\n\n /**\n * Create a new Repository wrapper\n * @param {string} user - the user who owns the respository\n * @param {string} repo - the name of the repository\n * @return {Repository}\n */\n getRepo(user, repo) {\n return new Repository(this._getFullName(user, repo), this.__auth, this.__apiBase);\n }\n\n /**\n * Create a new Issue wrapper\n * @param {string} user - the user who owns the respository\n * @param {string} repo - the name of the repository\n * @return {Issue}\n */\n getIssues(user, repo) {\n return new Issue(this._getFullName(user, repo), this.__auth, this.__apiBase);\n }\n\n /**\n * Create a new Search wrapper\n * @param {string} query - the query to search for\n * @return {Search}\n */\n search(query) {\n return new Search(query, this.__auth, this.__apiBase);\n }\n\n /**\n * Create a new RateLimit wrapper\n * @return {RateLimit}\n */\n getRateLimit() {\n return new RateLimit(this.__auth, this.__apiBase);\n }\n\n /**\n * Create a new Markdown wrapper\n * @return {Markdown}\n */\n getMarkdown() {\n return new Markdown(this.__auth, this.__apiBase);\n }\n\n /**\n * Create a new Project wrapper\n * @param {string} id - the id of the project\n * @return {Markdown}\n */\n getProject(id) {\n return new Project(id, this.__auth, this.__apiBase);\n }\n\n /**\n * Computes the full repository name\n * @param {string} user - the username (or the full name)\n * @param {string} repo - the repository name, must not be passed if `user` is the full name\n * @return {string} the repository's full name\n */\n _getFullName(user, repo) {\n let fullname = user;\n\n if (repo) {\n fullname = `${user}/${repo}`;\n }\n\n return fullname;\n }\n}\n\nmodule.exports = GitHub;\n"],"file":"GitHub.js"} \ No newline at end of file diff --git a/dist/components/Issue.js b/dist/components/Issue.js new file mode 100644 index 00000000..bf761ae6 --- /dev/null +++ b/dist/components/Issue.js @@ -0,0 +1,335 @@ +'use strict'; + +var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); + +var _Requestable2 = require('./Requestable'); + +var _Requestable3 = _interopRequireDefault(_Requestable2); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } + +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } /** + * @file + * @copyright 2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc. + * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}. + * Github.js is freely distributable. + */ + +/** + * Issue wraps the functionality to get issues for repositories + */ +var Issue = function (_Requestable) { + _inherits(Issue, _Requestable); + + /** + * Create a new Issue + * @param {string} repository - the full name of the repository (`:user/:repo`) to get issues for + * @param {Requestable.auth} [auth] - information required to authenticate to Github + * @param {string} [apiBase=https://api.github.com] - the base Github API URL + */ + function Issue(repository, auth, apiBase) { + _classCallCheck(this, Issue); + + var _this = _possibleConstructorReturn(this, (Issue.__proto__ || Object.getPrototypeOf(Issue)).call(this, auth, apiBase)); + + _this.__repository = repository; + return _this; + } + + /** + * Create a new issue + * @see https://developer.github.com/v3/issues/#create-an-issue + * @param {Object} issueData - the issue to create + * @param {Requestable.callback} [cb] - will receive the created issue + * @return {Promise} - the promise for the http request + */ + + + _createClass(Issue, [{ + key: 'createIssue', + value: function createIssue(issueData, cb) { + return this._request('POST', '/repos/' + this.__repository + '/issues', issueData, cb); + } + + /** + * List the issues for the repository + * @see https://developer.github.com/v3/issues/#list-issues-for-a-repository + * @param {Object} options - filtering options + * @param {Requestable.callback} [cb] - will receive the array of issues + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'listIssues', + value: function listIssues(options, cb) { + return this._requestAllPages('/repos/' + this.__repository + '/issues', options, cb); + } + + /** + * List the events for an issue + * @see https://developer.github.com/v3/issues/events/#list-events-for-an-issue + * @param {number} issue - the issue to get events for + * @param {Requestable.callback} [cb] - will receive the list of events + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'listIssueEvents', + value: function listIssueEvents(issue, cb) { + return this._request('GET', '/repos/' + this.__repository + '/issues/' + issue + '/events', null, cb); + } + + /** + * List comments on an issue + * @see https://developer.github.com/v3/issues/comments/#list-comments-on-an-issue + * @param {number} issue - the id of the issue to get comments from + * @param {Requestable.callback} [cb] - will receive the comments + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'listIssueComments', + value: function listIssueComments(issue, cb) { + return this._request('GET', '/repos/' + this.__repository + '/issues/' + issue + '/comments', null, cb); + } + + /** + * Get a single comment on an issue + * @see https://developer.github.com/v3/issues/comments/#get-a-single-comment + * @param {number} id - the comment id to get + * @param {Requestable.callback} [cb] - will receive the comment + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'getIssueComment', + value: function getIssueComment(id, cb) { + return this._request('GET', '/repos/' + this.__repository + '/issues/comments/' + id, null, cb); + } + + /** + * Comment on an issue + * @see https://developer.github.com/v3/issues/comments/#create-a-comment + * @param {number} issue - the id of the issue to comment on + * @param {string} comment - the comment to add + * @param {Requestable.callback} [cb] - will receive the created comment + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'createIssueComment', + value: function createIssueComment(issue, comment, cb) { + return this._request('POST', '/repos/' + this.__repository + '/issues/' + issue + '/comments', { body: comment }, cb); + } + + /** + * Edit a comment on an issue + * @see https://developer.github.com/v3/issues/comments/#edit-a-comment + * @param {number} id - the comment id to edit + * @param {string} comment - the comment to edit + * @param {Requestable.callback} [cb] - will receive the edited comment + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'editIssueComment', + value: function editIssueComment(id, comment, cb) { + return this._request('PATCH', '/repos/' + this.__repository + '/issues/comments/' + id, { body: comment }, cb); + } + + /** + * Delete a comment on an issue + * @see https://developer.github.com/v3/issues/comments/#delete-a-comment + * @param {number} id - the comment id to delete + * @param {Requestable.callback} [cb] - will receive true if the request is successful + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'deleteIssueComment', + value: function deleteIssueComment(id, cb) { + return this._request('DELETE', '/repos/' + this.__repository + '/issues/comments/' + id, null, cb); + } + + /** + * Edit an issue + * @see https://developer.github.com/v3/issues/#edit-an-issue + * @param {number} issue - the issue number to edit + * @param {Object} issueData - the new issue data + * @param {Requestable.callback} [cb] - will receive the modified issue + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'editIssue', + value: function editIssue(issue, issueData, cb) { + return this._request('PATCH', '/repos/' + this.__repository + '/issues/' + issue, issueData, cb); + } + + /** + * Get a particular issue + * @see https://developer.github.com/v3/issues/#get-a-single-issue + * @param {number} issue - the issue number to fetch + * @param {Requestable.callback} [cb] - will receive the issue + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'getIssue', + value: function getIssue(issue, cb) { + return this._request('GET', '/repos/' + this.__repository + '/issues/' + issue, null, cb); + } + + /** + * List the milestones for the repository + * @see https://developer.github.com/v3/issues/milestones/#list-milestones-for-a-repository + * @param {Object} options - filtering options + * @param {Requestable.callback} [cb] - will receive the array of milestones + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'listMilestones', + value: function listMilestones(options, cb) { + return this._request('GET', '/repos/' + this.__repository + '/milestones', options, cb); + } + + /** + * Get a milestone + * @see https://developer.github.com/v3/issues/milestones/#get-a-single-milestone + * @param {string} milestone - the id of the milestone to fetch + * @param {Requestable.callback} [cb] - will receive the milestone + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'getMilestone', + value: function getMilestone(milestone, cb) { + return this._request('GET', '/repos/' + this.__repository + '/milestones/' + milestone, null, cb); + } + + /** + * Create a new milestone + * @see https://developer.github.com/v3/issues/milestones/#create-a-milestone + * @param {Object} milestoneData - the milestone definition + * @param {Requestable.callback} [cb] - will receive the milestone + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'createMilestone', + value: function createMilestone(milestoneData, cb) { + return this._request('POST', '/repos/' + this.__repository + '/milestones', milestoneData, cb); + } + + /** + * Edit a milestone + * @see https://developer.github.com/v3/issues/milestones/#update-a-milestone + * @param {string} milestone - the id of the milestone to edit + * @param {Object} milestoneData - the updates to make to the milestone + * @param {Requestable.callback} [cb] - will receive the updated milestone + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'editMilestone', + value: function editMilestone(milestone, milestoneData, cb) { + return this._request('PATCH', '/repos/' + this.__repository + '/milestones/' + milestone, milestoneData, cb); + } + + /** + * Delete a milestone (this is distinct from closing a milestone) + * @see https://developer.github.com/v3/issues/milestones/#delete-a-milestone + * @param {string} milestone - the id of the milestone to delete + * @param {Requestable.callback} [cb] - will receive the status + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'deleteMilestone', + value: function deleteMilestone(milestone, cb) { + return this._request('DELETE', '/repos/' + this.__repository + '/milestones/' + milestone, null, cb); + } + + /** + * Create a new label + * @see https://developer.github.com/v3/issues/labels/#create-a-label + * @param {Object} labelData - the label definition + * @param {Requestable.callback} [cb] - will receive the object representing the label + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'createLabel', + value: function createLabel(labelData, cb) { + return this._request('POST', '/repos/' + this.__repository + '/labels', labelData, cb); + } + + /** + * List the labels for the repository + * @see https://developer.github.com/v3/issues/labels/#list-all-labels-for-this-repository + * @param {Object} options - filtering options + * @param {Requestable.callback} [cb] - will receive the array of labels + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'listLabels', + value: function listLabels(options, cb) { + return this._request('GET', '/repos/' + this.__repository + '/labels', options, cb); + } + + /** + * Get a label + * @see https://developer.github.com/v3/issues/labels/#get-a-single-label + * @param {string} label - the name of the label to fetch + * @param {Requestable.callback} [cb] - will receive the label + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'getLabel', + value: function getLabel(label, cb) { + return this._request('GET', '/repos/' + this.__repository + '/labels/' + label, null, cb); + } + + /** + * Edit a label + * @see https://developer.github.com/v3/issues/labels/#update-a-label + * @param {string} label - the name of the label to edit + * @param {Object} labelData - the updates to make to the label + * @param {Requestable.callback} [cb] - will receive the updated label + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'editLabel', + value: function editLabel(label, labelData, cb) { + return this._request('PATCH', '/repos/' + this.__repository + '/labels/' + label, labelData, cb); + } + + /** + * Delete a label + * @see https://developer.github.com/v3/issues/labels/#delete-a-label + * @param {string} label - the name of the label to delete + * @param {Requestable.callback} [cb] - will receive the status + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'deleteLabel', + value: function deleteLabel(label, cb) { + return this._request('DELETE', '/repos/' + this.__repository + '/labels/' + label, null, cb); + } + }]); + + return Issue; +}(_Requestable3.default); + +module.exports = Issue; +//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["Issue.js"],"names":["Issue","repository","auth","apiBase","__repository","issueData","cb","_request","options","_requestAllPages","issue","id","comment","body","milestone","milestoneData","labelData","label","module","exports"],"mappings":"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","file":"Issue.js","sourcesContent":["/**\n * @file\n * @copyright  2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license    Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n *             Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\n\n/**\n * Issue wraps the functionality to get issues for repositories\n */\nclass Issue extends Requestable {\n   /**\n    * Create a new Issue\n    * @param {string} repository - the full name of the repository (`:user/:repo`) to get issues for\n    * @param {Requestable.auth} [auth] - information required to authenticate to Github\n    * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n    */\n   constructor(repository, auth, apiBase) {\n      super(auth, apiBase);\n      this.__repository = repository;\n   }\n\n   /**\n    * Create a new issue\n    * @see https://developer.github.com/v3/issues/#create-an-issue\n    * @param {Object} issueData - the issue to create\n    * @param {Requestable.callback} [cb] - will receive the created issue\n    * @return {Promise} - the promise for the http request\n    */\n   createIssue(issueData, cb) {\n      return this._request('POST', `/repos/${this.__repository}/issues`, issueData, cb);\n   }\n\n   /**\n    * List the issues for the repository\n    * @see https://developer.github.com/v3/issues/#list-issues-for-a-repository\n    * @param {Object} options - filtering options\n    * @param {Requestable.callback} [cb] - will receive the array of issues\n    * @return {Promise} - the promise for the http request\n    */\n   listIssues(options, cb) {\n      return this._requestAllPages(`/repos/${this.__repository}/issues`, options, cb);\n   }\n\n   /**\n    * List the events for an issue\n    * @see https://developer.github.com/v3/issues/events/#list-events-for-an-issue\n    * @param {number} issue - the issue to get events for\n    * @param {Requestable.callback} [cb] - will receive the list of events\n    * @return {Promise} - the promise for the http request\n    */\n   listIssueEvents(issue, cb) {\n      return this._request('GET', `/repos/${this.__repository}/issues/${issue}/events`, null, cb);\n   }\n\n   /**\n    * List comments on an issue\n    * @see https://developer.github.com/v3/issues/comments/#list-comments-on-an-issue\n    * @param {number} issue - the id of the issue to get comments from\n    * @param {Requestable.callback} [cb] - will receive the comments\n    * @return {Promise} - the promise for the http request\n    */\n   listIssueComments(issue, cb) {\n      return this._request('GET', `/repos/${this.__repository}/issues/${issue}/comments`, null, cb);\n   }\n\n   /**\n    * Get a single comment on an issue\n    * @see https://developer.github.com/v3/issues/comments/#get-a-single-comment\n    * @param {number} id - the comment id to get\n    * @param {Requestable.callback} [cb] - will receive the comment\n    * @return {Promise} - the promise for the http request\n    */\n   getIssueComment(id, cb) {\n      return this._request('GET', `/repos/${this.__repository}/issues/comments/${id}`, null, cb);\n   }\n\n   /**\n    * Comment on an issue\n    * @see https://developer.github.com/v3/issues/comments/#create-a-comment\n    * @param {number} issue - the id of the issue to comment on\n    * @param {string} comment - the comment to add\n    * @param {Requestable.callback} [cb] - will receive the created comment\n    * @return {Promise} - the promise for the http request\n    */\n   createIssueComment(issue, comment, cb) {\n      return this._request('POST', `/repos/${this.__repository}/issues/${issue}/comments`, {body: comment}, cb);\n   }\n\n   /**\n    * Edit a comment on an issue\n    * @see https://developer.github.com/v3/issues/comments/#edit-a-comment\n    * @param {number} id - the comment id to edit\n    * @param {string} comment - the comment to edit\n    * @param {Requestable.callback} [cb] - will receive the edited comment\n    * @return {Promise} - the promise for the http request\n    */\n   editIssueComment(id, comment, cb) {\n      return this._request('PATCH', `/repos/${this.__repository}/issues/comments/${id}`, {body: comment}, cb);\n   }\n\n   /**\n    * Delete a comment on an issue\n    * @see https://developer.github.com/v3/issues/comments/#delete-a-comment\n    * @param {number} id - the comment id to delete\n    * @param {Requestable.callback} [cb] - will receive true if the request is successful\n    * @return {Promise} - the promise for the http request\n    */\n   deleteIssueComment(id, cb) {\n      return this._request('DELETE', `/repos/${this.__repository}/issues/comments/${id}`, null, cb);\n   }\n\n   /**\n    * Edit an issue\n    * @see https://developer.github.com/v3/issues/#edit-an-issue\n    * @param {number} issue - the issue number to edit\n    * @param {Object} issueData - the new issue data\n    * @param {Requestable.callback} [cb] - will receive the modified issue\n    * @return {Promise} - the promise for the http request\n    */\n   editIssue(issue, issueData, cb) {\n      return this._request('PATCH', `/repos/${this.__repository}/issues/${issue}`, issueData, cb);\n   }\n\n   /**\n    * Get a particular issue\n    * @see https://developer.github.com/v3/issues/#get-a-single-issue\n    * @param {number} issue - the issue number to fetch\n    * @param {Requestable.callback} [cb] - will receive the issue\n    * @return {Promise} - the promise for the http request\n    */\n   getIssue(issue, cb) {\n      return this._request('GET', `/repos/${this.__repository}/issues/${issue}`, null, cb);\n   }\n\n   /**\n    * List the milestones for the repository\n    * @see https://developer.github.com/v3/issues/milestones/#list-milestones-for-a-repository\n    * @param {Object} options - filtering options\n    * @param {Requestable.callback} [cb] - will receive the array of milestones\n    * @return {Promise} - the promise for the http request\n    */\n   listMilestones(options, cb) {\n      return this._request('GET', `/repos/${this.__repository}/milestones`, options, cb);\n   }\n\n   /**\n    * Get a milestone\n    * @see https://developer.github.com/v3/issues/milestones/#get-a-single-milestone\n    * @param {string} milestone - the id of the milestone to fetch\n    * @param {Requestable.callback} [cb] - will receive the milestone\n    * @return {Promise} - the promise for the http request\n    */\n   getMilestone(milestone, cb) {\n      return this._request('GET', `/repos/${this.__repository}/milestones/${milestone}`, null, cb);\n   }\n\n   /**\n    * Create a new milestone\n    * @see https://developer.github.com/v3/issues/milestones/#create-a-milestone\n    * @param {Object} milestoneData - the milestone definition\n    * @param {Requestable.callback} [cb] - will receive the milestone\n    * @return {Promise} - the promise for the http request\n    */\n   createMilestone(milestoneData, cb) {\n      return this._request('POST', `/repos/${this.__repository}/milestones`, milestoneData, cb);\n   }\n\n   /**\n    * Edit a milestone\n    * @see https://developer.github.com/v3/issues/milestones/#update-a-milestone\n    * @param {string} milestone - the id of the milestone to edit\n    * @param {Object} milestoneData - the updates to make to the milestone\n    * @param {Requestable.callback} [cb] - will receive the updated milestone\n    * @return {Promise} - the promise for the http request\n    */\n   editMilestone(milestone, milestoneData, cb) {\n      return this._request('PATCH', `/repos/${this.__repository}/milestones/${milestone}`, milestoneData, cb);\n   }\n\n   /**\n    * Delete a milestone (this is distinct from closing a milestone)\n    * @see https://developer.github.com/v3/issues/milestones/#delete-a-milestone\n    * @param {string} milestone - the id of the milestone to delete\n    * @param {Requestable.callback} [cb] - will receive the status\n    * @return {Promise} - the promise for the http request\n    */\n   deleteMilestone(milestone, cb) {\n      return this._request('DELETE', `/repos/${this.__repository}/milestones/${milestone}`, null, cb);\n   }\n\n   /**\n    * Create a new label\n    * @see https://developer.github.com/v3/issues/labels/#create-a-label\n    * @param {Object} labelData - the label definition\n    * @param {Requestable.callback} [cb] - will receive the object representing the label\n    * @return {Promise} - the promise for the http request\n    */\n   createLabel(labelData, cb) {\n      return this._request('POST', `/repos/${this.__repository}/labels`, labelData, cb);\n   }\n\n  /**\n   * List the labels for the repository\n   * @see https://developer.github.com/v3/issues/labels/#list-all-labels-for-this-repository\n   * @param {Object} options - filtering options\n   * @param {Requestable.callback} [cb] - will receive the array of labels\n   * @return {Promise} - the promise for the http request\n   */\n   listLabels(options, cb) {\n      return this._request('GET', `/repos/${this.__repository}/labels`, options, cb);\n   }\n\n  /**\n   * Get a label\n   * @see https://developer.github.com/v3/issues/labels/#get-a-single-label\n   * @param {string} label - the name of the label to fetch\n   * @param {Requestable.callback} [cb] - will receive the label\n   * @return {Promise} - the promise for the http request\n   */\n   getLabel(label, cb) {\n      return this._request('GET', `/repos/${this.__repository}/labels/${label}`, null, cb);\n   }\n\n  /**\n   * Edit a label\n   * @see https://developer.github.com/v3/issues/labels/#update-a-label\n   * @param {string} label - the name of the label to edit\n   * @param {Object} labelData - the updates to make to the label\n   * @param {Requestable.callback} [cb] - will receive the updated label\n   * @return {Promise} - the promise for the http request\n   */\n   editLabel(label, labelData, cb) {\n      return this._request('PATCH', `/repos/${this.__repository}/labels/${label}`, labelData, cb);\n   }\n\n  /**\n   * Delete a label\n   * @see https://developer.github.com/v3/issues/labels/#delete-a-label\n   * @param {string} label - the name of the label to delete\n   * @param {Requestable.callback} [cb] - will receive the status\n   * @return {Promise} - the promise for the http request\n   */\n   deleteLabel(label, cb) {\n      return this._request('DELETE', `/repos/${this.__repository}/labels/${label}`, null, cb);\n   }\n}\n\nmodule.exports = Issue;\n"]} +//# sourceMappingURL=Issue.js.map diff --git a/dist/components/Issue.js.map b/dist/components/Issue.js.map new file mode 100644 index 00000000..14fc249b --- /dev/null +++ b/dist/components/Issue.js.map @@ -0,0 +1 @@ +{"version":3,"names":[],"mappings":"","sources":["Issue.js"],"sourcesContent":["/**\n * @file\n * @copyright 2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n * Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\n\n/**\n * Issue wraps the functionality to get issues for repositories\n */\nclass Issue extends Requestable {\n /**\n * Create a new Issue\n * @param {string} repository - the full name of the repository (`:user/:repo`) to get issues for\n * @param {Requestable.auth} [auth] - information required to authenticate to Github\n * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n */\n constructor(repository, auth, apiBase) {\n super(auth, apiBase);\n this.__repository = repository;\n }\n\n /**\n * Create a new issue\n * @see https://developer.github.com/v3/issues/#create-an-issue\n * @param {Object} issueData - the issue to create\n * @param {Requestable.callback} [cb] - will receive the created issue\n * @return {Promise} - the promise for the http request\n */\n createIssue(issueData, cb) {\n return this._request('POST', `/repos/${this.__repository}/issues`, issueData, cb);\n }\n\n /**\n * List the issues for the repository\n * @see https://developer.github.com/v3/issues/#list-issues-for-a-repository\n * @param {Object} options - filtering options\n * @param {Requestable.callback} [cb] - will receive the array of issues\n * @return {Promise} - the promise for the http request\n */\n listIssues(options, cb) {\n return this._requestAllPages(`/repos/${this.__repository}/issues`, options, cb);\n }\n\n /**\n * List the events for an issue\n * @see https://developer.github.com/v3/issues/events/#list-events-for-an-issue\n * @param {number} issue - the issue to get events for\n * @param {Requestable.callback} [cb] - will receive the list of events\n * @return {Promise} - the promise for the http request\n */\n listIssueEvents(issue, cb) {\n return this._request('GET', `/repos/${this.__repository}/issues/${issue}/events`, null, cb);\n }\n\n /**\n * List comments on an issue\n * @see https://developer.github.com/v3/issues/comments/#list-comments-on-an-issue\n * @param {number} issue - the id of the issue to get comments from\n * @param {Requestable.callback} [cb] - will receive the comments\n * @return {Promise} - the promise for the http request\n */\n listIssueComments(issue, cb) {\n return this._request('GET', `/repos/${this.__repository}/issues/${issue}/comments`, null, cb);\n }\n\n /**\n * Get a single comment on an issue\n * @see https://developer.github.com/v3/issues/comments/#get-a-single-comment\n * @param {number} id - the comment id to get\n * @param {Requestable.callback} [cb] - will receive the comment\n * @return {Promise} - the promise for the http request\n */\n getIssueComment(id, cb) {\n return this._request('GET', `/repos/${this.__repository}/issues/comments/${id}`, null, cb);\n }\n\n /**\n * Comment on an issue\n * @see https://developer.github.com/v3/issues/comments/#create-a-comment\n * @param {number} issue - the id of the issue to comment on\n * @param {string} comment - the comment to add\n * @param {Requestable.callback} [cb] - will receive the created comment\n * @return {Promise} - the promise for the http request\n */\n createIssueComment(issue, comment, cb) {\n return this._request('POST', `/repos/${this.__repository}/issues/${issue}/comments`, {body: comment}, cb);\n }\n\n /**\n * Edit a comment on an issue\n * @see https://developer.github.com/v3/issues/comments/#edit-a-comment\n * @param {number} id - the comment id to edit\n * @param {string} comment - the comment to edit\n * @param {Requestable.callback} [cb] - will receive the edited comment\n * @return {Promise} - the promise for the http request\n */\n editIssueComment(id, comment, cb) {\n return this._request('PATCH', `/repos/${this.__repository}/issues/comments/${id}`, {body: comment}, cb);\n }\n\n /**\n * Delete a comment on an issue\n * @see https://developer.github.com/v3/issues/comments/#delete-a-comment\n * @param {number} id - the comment id to delete\n * @param {Requestable.callback} [cb] - will receive true if the request is successful\n * @return {Promise} - the promise for the http request\n */\n deleteIssueComment(id, cb) {\n return this._request('DELETE', `/repos/${this.__repository}/issues/comments/${id}`, null, cb);\n }\n\n /**\n * Edit an issue\n * @see https://developer.github.com/v3/issues/#edit-an-issue\n * @param {number} issue - the issue number to edit\n * @param {Object} issueData - the new issue data\n * @param {Requestable.callback} [cb] - will receive the modified issue\n * @return {Promise} - the promise for the http request\n */\n editIssue(issue, issueData, cb) {\n return this._request('PATCH', `/repos/${this.__repository}/issues/${issue}`, issueData, cb);\n }\n\n /**\n * Get a particular issue\n * @see https://developer.github.com/v3/issues/#get-a-single-issue\n * @param {number} issue - the issue number to fetch\n * @param {Requestable.callback} [cb] - will receive the issue\n * @return {Promise} - the promise for the http request\n */\n getIssue(issue, cb) {\n return this._request('GET', `/repos/${this.__repository}/issues/${issue}`, null, cb);\n }\n\n /**\n * List the milestones for the repository\n * @see https://developer.github.com/v3/issues/milestones/#list-milestones-for-a-repository\n * @param {Object} options - filtering options\n * @param {Requestable.callback} [cb] - will receive the array of milestones\n * @return {Promise} - the promise for the http request\n */\n listMilestones(options, cb) {\n return this._request('GET', `/repos/${this.__repository}/milestones`, options, cb);\n }\n\n /**\n * Get a milestone\n * @see https://developer.github.com/v3/issues/milestones/#get-a-single-milestone\n * @param {string} milestone - the id of the milestone to fetch\n * @param {Requestable.callback} [cb] - will receive the milestone\n * @return {Promise} - the promise for the http request\n */\n getMilestone(milestone, cb) {\n return this._request('GET', `/repos/${this.__repository}/milestones/${milestone}`, null, cb);\n }\n\n /**\n * Create a new milestone\n * @see https://developer.github.com/v3/issues/milestones/#create-a-milestone\n * @param {Object} milestoneData - the milestone definition\n * @param {Requestable.callback} [cb] - will receive the milestone\n * @return {Promise} - the promise for the http request\n */\n createMilestone(milestoneData, cb) {\n return this._request('POST', `/repos/${this.__repository}/milestones`, milestoneData, cb);\n }\n\n /**\n * Edit a milestone\n * @see https://developer.github.com/v3/issues/milestones/#update-a-milestone\n * @param {string} milestone - the id of the milestone to edit\n * @param {Object} milestoneData - the updates to make to the milestone\n * @param {Requestable.callback} [cb] - will receive the updated milestone\n * @return {Promise} - the promise for the http request\n */\n editMilestone(milestone, milestoneData, cb) {\n return this._request('PATCH', `/repos/${this.__repository}/milestones/${milestone}`, milestoneData, cb);\n }\n\n /**\n * Delete a milestone (this is distinct from closing a milestone)\n * @see https://developer.github.com/v3/issues/milestones/#delete-a-milestone\n * @param {string} milestone - the id of the milestone to delete\n * @param {Requestable.callback} [cb] - will receive the status\n * @return {Promise} - the promise for the http request\n */\n deleteMilestone(milestone, cb) {\n return this._request('DELETE', `/repos/${this.__repository}/milestones/${milestone}`, null, cb);\n }\n\n /**\n * Create a new label\n * @see https://developer.github.com/v3/issues/labels/#create-a-label\n * @param {Object} labelData - the label definition\n * @param {Requestable.callback} [cb] - will receive the object representing the label\n * @return {Promise} - the promise for the http request\n */\n createLabel(labelData, cb) {\n return this._request('POST', `/repos/${this.__repository}/labels`, labelData, cb);\n }\n\n /**\n * List the labels for the repository\n * @see https://developer.github.com/v3/issues/labels/#list-all-labels-for-this-repository\n * @param {Object} options - filtering options\n * @param {Requestable.callback} [cb] - will receive the array of labels\n * @return {Promise} - the promise for the http request\n */\n listLabels(options, cb) {\n return this._request('GET', `/repos/${this.__repository}/labels`, options, cb);\n }\n\n /**\n * Get a label\n * @see https://developer.github.com/v3/issues/labels/#get-a-single-label\n * @param {string} label - the name of the label to fetch\n * @param {Requestable.callback} [cb] - will receive the label\n * @return {Promise} - the promise for the http request\n */\n getLabel(label, cb) {\n return this._request('GET', `/repos/${this.__repository}/labels/${label}`, null, cb);\n }\n\n /**\n * Edit a label\n * @see https://developer.github.com/v3/issues/labels/#update-a-label\n * @param {string} label - the name of the label to edit\n * @param {Object} labelData - the updates to make to the label\n * @param {Requestable.callback} [cb] - will receive the updated label\n * @return {Promise} - the promise for the http request\n */\n editLabel(label, labelData, cb) {\n return this._request('PATCH', `/repos/${this.__repository}/labels/${label}`, labelData, cb);\n }\n\n /**\n * Delete a label\n * @see https://developer.github.com/v3/issues/labels/#delete-a-label\n * @param {string} label - the name of the label to delete\n * @param {Requestable.callback} [cb] - will receive the status\n * @return {Promise} - the promise for the http request\n */\n deleteLabel(label, cb) {\n return this._request('DELETE', `/repos/${this.__repository}/labels/${label}`, null, cb);\n }\n}\n\nmodule.exports = Issue;\n"],"file":"Issue.js"} \ No newline at end of file diff --git a/dist/components/Markdown.js b/dist/components/Markdown.js new file mode 100644 index 00000000..710db80a --- /dev/null +++ b/dist/components/Markdown.js @@ -0,0 +1,64 @@ +'use strict'; + +var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); + +var _Requestable2 = require('./Requestable'); + +var _Requestable3 = _interopRequireDefault(_Requestable2); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } + +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } /** + * @file + * @copyright 2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc. + * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}. + * Github.js is freely distributable. + */ + +/** + * Renders html from Markdown text + */ +var Markdown = function (_Requestable) { + _inherits(Markdown, _Requestable); + + /** + * construct a Markdown + * @param {Requestable.auth} auth - the credentials to authenticate to GitHub + * @param {string} [apiBase] - the base Github API URL + * @return {Promise} - the promise for the http request + */ + function Markdown(auth, apiBase) { + _classCallCheck(this, Markdown); + + return _possibleConstructorReturn(this, (Markdown.__proto__ || Object.getPrototypeOf(Markdown)).call(this, auth, apiBase)); + } + + /** + * Render html from Markdown text. + * @see https://developer.github.com/v3/markdown/#render-an-arbitrary-markdown-document + * @param {Object} options - conversion options + * @param {string} [options.text] - the markdown text to convert + * @param {string} [options.mode=markdown] - can be either `markdown` or `gfm` + * @param {string} [options.context] - repository name if mode is gfm + * @param {Requestable.callback} [cb] - will receive the converted html + * @return {Promise} - the promise for the http request + */ + + + _createClass(Markdown, [{ + key: 'render', + value: function render(options, cb) { + return this._request('POST', '/markdown', options, cb); + } + }]); + + return Markdown; +}(_Requestable3.default); + +module.exports = Markdown; +//# sourceMappingURL=data:application/json;base64,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 +//# sourceMappingURL=Markdown.js.map diff --git a/dist/components/Markdown.js.map b/dist/components/Markdown.js.map new file mode 100644 index 00000000..69645238 --- /dev/null +++ b/dist/components/Markdown.js.map @@ -0,0 +1 @@ +{"version":3,"names":[],"mappings":"","sources":["Markdown.js"],"sourcesContent":["/**\n * @file\n * @copyright 2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n * Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\n\n/**\n * Renders html from Markdown text\n */\nclass Markdown extends Requestable {\n /**\n * construct a Markdown\n * @param {Requestable.auth} auth - the credentials to authenticate to GitHub\n * @param {string} [apiBase] - the base Github API URL\n * @return {Promise} - the promise for the http request\n */\n constructor(auth, apiBase) {\n super(auth, apiBase);\n }\n\n /**\n * Render html from Markdown text.\n * @see https://developer.github.com/v3/markdown/#render-an-arbitrary-markdown-document\n * @param {Object} options - conversion options\n * @param {string} [options.text] - the markdown text to convert\n * @param {string} [options.mode=markdown] - can be either `markdown` or `gfm`\n * @param {string} [options.context] - repository name if mode is gfm\n * @param {Requestable.callback} [cb] - will receive the converted html\n * @return {Promise} - the promise for the http request\n */\n render(options, cb) {\n return this._request('POST', '/markdown', options, cb);\n }\n}\n\nmodule.exports = Markdown;\n"],"file":"Markdown.js"} \ No newline at end of file diff --git a/dist/components/Organization.js b/dist/components/Organization.js new file mode 100644 index 00000000..bfccb843 --- /dev/null +++ b/dist/components/Organization.js @@ -0,0 +1,169 @@ +'use strict'; + +var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); + +var _Requestable2 = require('./Requestable'); + +var _Requestable3 = _interopRequireDefault(_Requestable2); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } + +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } /** + * @file + * @copyright 2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc. + * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}. + * Github.js is freely distributable. + */ + +/** + * Organization encapsulates the functionality to create repositories in organizations + */ +var Organization = function (_Requestable) { + _inherits(Organization, _Requestable); + + /** + * Create a new Organization + * @param {string} organization - the name of the organization + * @param {Requestable.auth} [auth] - information required to authenticate to Github + * @param {string} [apiBase=https://api.github.com] - the base Github API URL + */ + function Organization(organization, auth, apiBase) { + _classCallCheck(this, Organization); + + var _this = _possibleConstructorReturn(this, (Organization.__proto__ || Object.getPrototypeOf(Organization)).call(this, auth, apiBase)); + + _this.__name = organization; + return _this; + } + + /** + * Create a repository in an organization + * @see https://developer.github.com/v3/repos/#create + * @param {Object} options - the repository definition + * @param {Requestable.callback} [cb] - will receive the created repository + * @return {Promise} - the promise for the http request + */ + + + _createClass(Organization, [{ + key: 'createRepo', + value: function createRepo(options, cb) { + return this._request('POST', '/orgs/' + this.__name + '/repos', options, cb); + } + + /** + * List the repositories in an organization + * @see https://developer.github.com/v3/repos/#list-organization-repositories + * @param {Requestable.callback} [cb] - will receive the list of repositories + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'getRepos', + value: function getRepos(cb) { + var requestOptions = this._getOptionsWithDefaults({ direction: 'desc' }); + + return this._requestAllPages('/orgs/' + this.__name + '/repos', requestOptions, cb); + } + + /** + * Query if the user is a member or not + * @param {string} username - the user in question + * @param {Requestable.callback} [cb] - will receive true if the user is a member + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'isMember', + value: function isMember(username, cb) { + return this._request204or404('/orgs/' + this.__name + '/members/' + username, null, cb); + } + + /** + * List the users who are members of the company + * @see https://developer.github.com/v3/orgs/members/#members-list + * @param {object} options - filtering options + * @param {string} [options.filter=all] - can be either `2fa_disabled` or `all` + * @param {string} [options.role=all] - can be one of: `all`, `admin`, or `member` + * @param {Requestable.callback} [cb] - will receive the list of users + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'listMembers', + value: function listMembers(options, cb) { + return this._request('GET', '/orgs/' + this.__name + '/members', options, cb); + } + + /** + * List the Teams in the Organization + * @see https://developer.github.com/v3/orgs/teams/#list-teams + * @param {Requestable.callback} [cb] - will receive the list of teams + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'getTeams', + value: function getTeams(cb) { + return this._requestAllPages('/orgs/' + this.__name + '/teams', undefined, cb); + } + + /** + * Create a team + * @see https://developer.github.com/v3/orgs/teams/#create-team + * @param {object} options - Team creation parameters + * @param {string} options.name - The name of the team + * @param {string} [options.description] - Team description + * @param {string} [options.repo_names] - Repos to add the team to + * @param {string} [options.privacy=secret] - The level of privacy the team should have. Can be either one + * of: `secret`, or `closed` + * @param {Requestable.callback} [cb] - will receive the created team + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'createTeam', + value: function createTeam(options, cb) { + return this._request('POST', '/orgs/' + this.__name + '/teams', options, cb); + } + + /** + * Get information about all projects + * @see https://developer.github.com/v3/projects/#list-organization-projects + * @param {Requestable.callback} [cb] - will receive the list of projects + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'listProjects', + value: function listProjects(cb) { + return this._requestAllPages('/orgs/' + this.__name + '/projects', { AcceptHeader: 'inertia-preview' }, cb); + } + + /** + * Create a new project + * @see https://developer.github.com/v3/repos/projects/#create-a-project + * @param {Object} options - the description of the project + * @param {Requestable.callback} cb - will receive the newly created project + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'createProject', + value: function createProject(options, cb) { + options = options || {}; + options.AcceptHeader = 'inertia-preview'; + return this._request('POST', '/orgs/' + this.__name + '/projects', options, cb); + } + }]); + + return Organization; +}(_Requestable3.default); + +module.exports = Organization; +//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["Organization.js"],"names":["Organization","organization","auth","apiBase","__name","options","cb","_request","requestOptions","_getOptionsWithDefaults","direction","_requestAllPages","username","_request204or404","undefined","AcceptHeader","module","exports"],"mappings":";;;;AAOA;;;;;;;;;;+eAPA;;;;;;;AASA;;;IAGMA,Y;;;AACH;;;;;;AAMA,wBAAYC,YAAZ,EAA0BC,IAA1B,EAAgCC,OAAhC,EAAyC;AAAA;;AAAA,4HAChCD,IADgC,EAC1BC,OAD0B;;AAEtC,UAAKC,MAAL,GAAcH,YAAd;AAFsC;AAGxC;;AAED;;;;;;;;;;;+BAOWI,O,EAASC,E,EAAI;AACrB,aAAO,KAAKC,QAAL,CAAc,MAAd,aAA+B,KAAKH,MAApC,aAAoDC,OAApD,EAA6DC,EAA7D,CAAP;AACF;;AAED;;;;;;;;;6BAMSA,E,EAAI;AACV,UAAIE,iBAAiB,KAAKC,uBAAL,CAA6B,EAACC,WAAW,MAAZ,EAA7B,CAArB;;AAEA,aAAO,KAAKC,gBAAL,YAA+B,KAAKP,MAApC,aAAoDI,cAApD,EAAoEF,EAApE,CAAP;AACF;;AAED;;;;;;;;;6BAMSM,Q,EAAUN,E,EAAI;AACpB,aAAO,KAAKO,gBAAL,YAA+B,KAAKT,MAApC,iBAAsDQ,QAAtD,EAAkE,IAAlE,EAAwEN,EAAxE,CAAP;AACF;;AAED;;;;;;;;;;;;gCASYD,O,EAASC,E,EAAI;AACtB,aAAO,KAAKC,QAAL,CAAc,KAAd,aAA8B,KAAKH,MAAnC,eAAqDC,OAArD,EAA8DC,EAA9D,CAAP;AACF;;AAED;;;;;;;;;6BAMSA,E,EAAI;AACV,aAAO,KAAKK,gBAAL,YAA+B,KAAKP,MAApC,aAAoDU,SAApD,EAA+DR,EAA/D,CAAP;AACF;;AAED;;;;;;;;;;;;;;;+BAYWD,O,EAASC,E,EAAI;AACrB,aAAO,KAAKC,QAAL,CAAc,MAAd,aAA+B,KAAKH,MAApC,aAAoDC,OAApD,EAA6DC,EAA7D,CAAP;AACF;;AAED;;;;;;;;;iCAMaA,E,EAAI;AACd,aAAO,KAAKK,gBAAL,YAA+B,KAAKP,MAApC,gBAAuD,EAACW,cAAc,iBAAf,EAAvD,EAA0FT,EAA1F,CAAP;AACF;;AAED;;;;;;;;;;kCAOcD,O,EAASC,E,EAAI;AACxBD,gBAAUA,WAAW,EAArB;AACAA,cAAQU,YAAR,GAAuB,iBAAvB;AACA,aAAO,KAAKR,QAAL,CAAc,MAAd,aAA+B,KAAKH,MAApC,gBAAuDC,OAAvD,EAAgEC,EAAhE,CAAP;AACF;;;;;;AAGJU,OAAOC,OAAP,GAAiBjB,YAAjB","file":"Organization.js","sourcesContent":["/**\n * @file\n * @copyright  2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license    Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n *             Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\n\n/**\n * Organization encapsulates the functionality to create repositories in organizations\n */\nclass Organization extends Requestable {\n   /**\n    * Create a new Organization\n    * @param {string} organization - the name of the organization\n    * @param {Requestable.auth} [auth] - information required to authenticate to Github\n    * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n    */\n   constructor(organization, auth, apiBase) {\n      super(auth, apiBase);\n      this.__name = organization;\n   }\n\n   /**\n    * Create a repository in an organization\n    * @see https://developer.github.com/v3/repos/#create\n    * @param {Object} options - the repository definition\n    * @param {Requestable.callback} [cb] - will receive the created repository\n    * @return {Promise} - the promise for the http request\n    */\n   createRepo(options, cb) {\n      return this._request('POST', `/orgs/${this.__name}/repos`, options, cb);\n   }\n\n   /**\n    * List the repositories in an organization\n    * @see https://developer.github.com/v3/repos/#list-organization-repositories\n    * @param {Requestable.callback} [cb] - will receive the list of repositories\n    * @return {Promise} - the promise for the http request\n    */\n   getRepos(cb) {\n      let requestOptions = this._getOptionsWithDefaults({direction: 'desc'});\n\n      return this._requestAllPages(`/orgs/${this.__name}/repos`, requestOptions, cb);\n   }\n\n   /**\n    * Query if the user is a member or not\n    * @param {string} username - the user in question\n    * @param {Requestable.callback} [cb] - will receive true if the user is a member\n    * @return {Promise} - the promise for the http request\n    */\n   isMember(username, cb) {\n      return this._request204or404(`/orgs/${this.__name}/members/${username}`, null, cb);\n   }\n\n   /**\n    * List the users who are members of the company\n    * @see https://developer.github.com/v3/orgs/members/#members-list\n    * @param {object} options - filtering options\n    * @param {string} [options.filter=all] - can be either `2fa_disabled` or `all`\n    * @param {string} [options.role=all] - can be one of: `all`, `admin`, or `member`\n    * @param {Requestable.callback} [cb] - will receive the list of users\n    * @return {Promise} - the promise for the http request\n    */\n   listMembers(options, cb) {\n      return this._request('GET', `/orgs/${this.__name}/members`, options, cb);\n   }\n\n   /**\n    * List the Teams in the Organization\n    * @see https://developer.github.com/v3/orgs/teams/#list-teams\n    * @param {Requestable.callback} [cb] - will receive the list of teams\n    * @return {Promise} - the promise for the http request\n    */\n   getTeams(cb) {\n      return this._requestAllPages(`/orgs/${this.__name}/teams`, undefined, cb);\n   }\n\n   /**\n    * Create a team\n    * @see https://developer.github.com/v3/orgs/teams/#create-team\n    * @param {object} options - Team creation parameters\n    * @param {string} options.name - The name of the team\n    * @param {string} [options.description] - Team description\n    * @param {string} [options.repo_names] - Repos to add the team to\n    * @param {string} [options.privacy=secret] - The level of privacy the team should have. Can be either one\n    * of: `secret`, or `closed`\n    * @param {Requestable.callback} [cb] - will receive the created team\n    * @return {Promise} - the promise for the http request\n    */\n   createTeam(options, cb) {\n      return this._request('POST', `/orgs/${this.__name}/teams`, options, cb);\n   }\n\n   /**\n    * Get information about all projects\n    * @see https://developer.github.com/v3/projects/#list-organization-projects\n    * @param {Requestable.callback} [cb] - will receive the list of projects\n    * @return {Promise} - the promise for the http request\n    */\n   listProjects(cb) {\n      return this._requestAllPages(`/orgs/${this.__name}/projects`, {AcceptHeader: 'inertia-preview'}, cb);\n   }\n\n   /**\n    * Create a new project\n    * @see https://developer.github.com/v3/repos/projects/#create-a-project\n    * @param {Object} options - the description of the project\n    * @param {Requestable.callback} cb - will receive the newly created project\n    * @return {Promise} - the promise for the http request\n    */\n   createProject(options, cb) {\n      options = options || {};\n      options.AcceptHeader = 'inertia-preview';\n      return this._request('POST', `/orgs/${this.__name}/projects`, options, cb);\n   }\n}\n\nmodule.exports = Organization;\n"]} +//# sourceMappingURL=Organization.js.map diff --git a/dist/components/Organization.js.map b/dist/components/Organization.js.map new file mode 100644 index 00000000..5414f233 --- /dev/null +++ b/dist/components/Organization.js.map @@ -0,0 +1 @@ +{"version":3,"names":[],"mappings":"","sources":["Organization.js"],"sourcesContent":["/**\n * @file\n * @copyright 2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n * Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\n\n/**\n * Organization encapsulates the functionality to create repositories in organizations\n */\nclass Organization extends Requestable {\n /**\n * Create a new Organization\n * @param {string} organization - the name of the organization\n * @param {Requestable.auth} [auth] - information required to authenticate to Github\n * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n */\n constructor(organization, auth, apiBase) {\n super(auth, apiBase);\n this.__name = organization;\n }\n\n /**\n * Create a repository in an organization\n * @see https://developer.github.com/v3/repos/#create\n * @param {Object} options - the repository definition\n * @param {Requestable.callback} [cb] - will receive the created repository\n * @return {Promise} - the promise for the http request\n */\n createRepo(options, cb) {\n return this._request('POST', `/orgs/${this.__name}/repos`, options, cb);\n }\n\n /**\n * List the repositories in an organization\n * @see https://developer.github.com/v3/repos/#list-organization-repositories\n * @param {Requestable.callback} [cb] - will receive the list of repositories\n * @return {Promise} - the promise for the http request\n */\n getRepos(cb) {\n let requestOptions = this._getOptionsWithDefaults({direction: 'desc'});\n\n return this._requestAllPages(`/orgs/${this.__name}/repos`, requestOptions, cb);\n }\n\n /**\n * Query if the user is a member or not\n * @param {string} username - the user in question\n * @param {Requestable.callback} [cb] - will receive true if the user is a member\n * @return {Promise} - the promise for the http request\n */\n isMember(username, cb) {\n return this._request204or404(`/orgs/${this.__name}/members/${username}`, null, cb);\n }\n\n /**\n * List the users who are members of the company\n * @see https://developer.github.com/v3/orgs/members/#members-list\n * @param {object} options - filtering options\n * @param {string} [options.filter=all] - can be either `2fa_disabled` or `all`\n * @param {string} [options.role=all] - can be one of: `all`, `admin`, or `member`\n * @param {Requestable.callback} [cb] - will receive the list of users\n * @return {Promise} - the promise for the http request\n */\n listMembers(options, cb) {\n return this._request('GET', `/orgs/${this.__name}/members`, options, cb);\n }\n\n /**\n * List the Teams in the Organization\n * @see https://developer.github.com/v3/orgs/teams/#list-teams\n * @param {Requestable.callback} [cb] - will receive the list of teams\n * @return {Promise} - the promise for the http request\n */\n getTeams(cb) {\n return this._requestAllPages(`/orgs/${this.__name}/teams`, undefined, cb);\n }\n\n /**\n * Create a team\n * @see https://developer.github.com/v3/orgs/teams/#create-team\n * @param {object} options - Team creation parameters\n * @param {string} options.name - The name of the team\n * @param {string} [options.description] - Team description\n * @param {string} [options.repo_names] - Repos to add the team to\n * @param {string} [options.privacy=secret] - The level of privacy the team should have. Can be either one\n * of: `secret`, or `closed`\n * @param {Requestable.callback} [cb] - will receive the created team\n * @return {Promise} - the promise for the http request\n */\n createTeam(options, cb) {\n return this._request('POST', `/orgs/${this.__name}/teams`, options, cb);\n }\n\n /**\n * Get information about all projects\n * @see https://developer.github.com/v3/projects/#list-organization-projects\n * @param {Requestable.callback} [cb] - will receive the list of projects\n * @return {Promise} - the promise for the http request\n */\n listProjects(cb) {\n return this._requestAllPages(`/orgs/${this.__name}/projects`, {AcceptHeader: 'inertia-preview'}, cb);\n }\n\n /**\n * Create a new project\n * @see https://developer.github.com/v3/repos/projects/#create-a-project\n * @param {Object} options - the description of the project\n * @param {Requestable.callback} cb - will receive the newly created project\n * @return {Promise} - the promise for the http request\n */\n createProject(options, cb) {\n options = options || {};\n options.AcceptHeader = 'inertia-preview';\n return this._request('POST', `/orgs/${this.__name}/projects`, options, cb);\n }\n}\n\nmodule.exports = Organization;\n"],"file":"Organization.js"} \ No newline at end of file diff --git a/dist/components/Project.js b/dist/components/Project.js new file mode 100644 index 00000000..1e0a2563 --- /dev/null +++ b/dist/components/Project.js @@ -0,0 +1,306 @@ +'use strict'; + +var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); + +var _Requestable2 = require('./Requestable'); + +var _Requestable3 = _interopRequireDefault(_Requestable2); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +function _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } } + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } + +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } /** + * @file + * @copyright 2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc. + * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}. + * Github.js is freely distributable. + */ + +/** + * Project encapsulates the functionality to create, query, and modify cards and columns. + */ +var Project = function (_Requestable) { + _inherits(Project, _Requestable); + + /** + * Create a Project. + * @param {string} id - the id of the project + * @param {Requestable.auth} [auth] - information required to authenticate to Github + * @param {string} [apiBase=https://api.github.com] - the base Github API URL + */ + function Project(id, auth, apiBase) { + _classCallCheck(this, Project); + + var _this = _possibleConstructorReturn(this, (Project.__proto__ || Object.getPrototypeOf(Project)).call(this, auth, apiBase, 'inertia-preview')); + + _this.__id = id; + return _this; + } + + /** + * Get information about a project + * @see https://developer.github.com/v3/projects/#get-a-project + * @param {Requestable.callback} cb - will receive the project information + * @return {Promise} - the promise for the http request + */ + + + _createClass(Project, [{ + key: 'getProject', + value: function getProject(cb) { + return this._request('GET', '/projects/' + this.__id, null, cb); + } + + /** + * Edit a project + * @see https://developer.github.com/v3/projects/#update-a-project + * @param {Object} options - the description of the project + * @param {Requestable.callback} cb - will receive the modified project + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'updateProject', + value: function updateProject(options, cb) { + return this._request('PATCH', '/projects/' + this.__id, options, cb); + } + + /** + * Delete a project + * @see https://developer.github.com/v3/projects/#delete-a-project + * @param {Requestable.callback} cb - will receive true if the operation is successful + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'deleteProject', + value: function deleteProject(cb) { + return this._request('DELETE', '/projects/' + this.__id, null, cb); + } + + /** + * Get information about all columns of a project + * @see https://developer.github.com/v3/projects/columns/#list-project-columns + * @param {Requestable.callback} [cb] - will receive the list of columns + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'listProjectColumns', + value: function listProjectColumns(cb) { + return this._requestAllPages('/projects/' + this.__id + '/columns', null, cb); + } + + /** + * Get information about a column + * @see https://developer.github.com/v3/projects/columns/#get-a-project-column + * @param {string} colId - the id of the column + * @param {Requestable.callback} cb - will receive the column information + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'getProjectColumn', + value: function getProjectColumn(colId, cb) { + return this._request('GET', '/projects/columns/' + colId, null, cb); + } + + /** + * Create a new column + * @see https://developer.github.com/v3/projects/columns/#create-a-project-column + * @param {Object} options - the description of the column + * @param {Requestable.callback} cb - will receive the newly created column + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'createProjectColumn', + value: function createProjectColumn(options, cb) { + return this._request('POST', '/projects/' + this.__id + '/columns', options, cb); + } + + /** + * Edit a column + * @see https://developer.github.com/v3/projects/columns/#update-a-project-column + * @param {string} colId - the column id + * @param {Object} options - the description of the column + * @param {Requestable.callback} cb - will receive the modified column + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'updateProjectColumn', + value: function updateProjectColumn(colId, options, cb) { + return this._request('PATCH', '/projects/columns/' + colId, options, cb); + } + + /** + * Delete a column + * @see https://developer.github.com/v3/projects/columns/#delete-a-project-column + * @param {string} colId - the column to be deleted + * @param {Requestable.callback} cb - will receive true if the operation is successful + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'deleteProjectColumn', + value: function deleteProjectColumn(colId, cb) { + return this._request('DELETE', '/projects/columns/' + colId, null, cb); + } + + /** + * Move a column + * @see https://developer.github.com/v3/projects/columns/#move-a-project-column + * @param {string} colId - the column to be moved + * @param {string} position - can be one of first, last, or after:, + * where is the id value of a column in the same project. + * @param {Requestable.callback} cb - will receive true if the operation is successful + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'moveProjectColumn', + value: function moveProjectColumn(colId, position, cb) { + return this._request('POST', '/projects/columns/' + colId + '/moves', { position: position }, cb); + } + + /** + * Get information about all cards of a project + * @see https://developer.github.com/v3/projects/cards/#list-project-cards + * @param {Requestable.callback} [cb] - will receive the list of cards + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'listProjectCards', + value: function listProjectCards(cb) { + var _this2 = this; + + return this.listProjectColumns().then(function (_ref) { + var data = _ref.data; + + return Promise.all(data.map(function (column) { + return _this2._requestAllPages('/projects/columns/' + column.id + '/cards', null); + })); + }).then(function (cardsInColumns) { + var cards = cardsInColumns.reduce(function (prev, _ref2) { + var data = _ref2.data; + + prev.push.apply(prev, _toConsumableArray(data)); + return prev; + }, []); + if (cb) { + cb(null, cards); + } + return cards; + }).catch(function (err) { + if (cb) { + cb(err); + return; + } + throw err; + }); + } + + /** + * Get information about all cards of a column + * @see https://developer.github.com/v3/projects/cards/#list-project-cards + * @param {string} colId - the id of the column + * @param {Requestable.callback} [cb] - will receive the list of cards + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'listColumnCards', + value: function listColumnCards(colId, cb) { + return this._requestAllPages('/projects/columns/' + colId + '/cards', null, cb); + } + + /** + * Get information about a card + * @see https://developer.github.com/v3/projects/cards/#get-a-project-card + * @param {string} cardId - the id of the card + * @param {Requestable.callback} cb - will receive the card information + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'getProjectCard', + value: function getProjectCard(cardId, cb) { + return this._request('GET', '/projects/columns/cards/' + cardId, null, cb); + } + + /** + * Create a new card + * @see https://developer.github.com/v3/projects/cards/#create-a-project-card + * @param {string} colId - the column id + * @param {Object} options - the description of the card + * @param {Requestable.callback} cb - will receive the newly created card + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'createProjectCard', + value: function createProjectCard(colId, options, cb) { + return this._request('POST', '/projects/columns/' + colId + '/cards', options, cb); + } + + /** + * Edit a card + * @see https://developer.github.com/v3/projects/cards/#update-a-project-card + * @param {string} cardId - the card id + * @param {Object} options - the description of the card + * @param {Requestable.callback} cb - will receive the modified card + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'updateProjectCard', + value: function updateProjectCard(cardId, options, cb) { + return this._request('PATCH', '/projects/columns/cards/' + cardId, options, cb); + } + + /** + * Delete a card + * @see https://developer.github.com/v3/projects/cards/#delete-a-project-card + * @param {string} cardId - the card to be deleted + * @param {Requestable.callback} cb - will receive true if the operation is successful + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'deleteProjectCard', + value: function deleteProjectCard(cardId, cb) { + return this._request('DELETE', '/projects/columns/cards/' + cardId, null, cb); + } + + /** + * Move a card + * @see https://developer.github.com/v3/projects/cards/#move-a-project-card + * @param {string} cardId - the card to be moved + * @param {string} position - can be one of top, bottom, or after:, + * where is the id value of a card in the same project. + * @param {string} colId - the id value of a column in the same project. + * @param {Requestable.callback} cb - will receive true if the operation is successful + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'moveProjectCard', + value: function moveProjectCard(cardId, position, colId, cb) { + return this._request('POST', '/projects/columns/cards/' + cardId + '/moves', { position: position, column_id: colId }, // eslint-disable-line camelcase + cb); + } + }]); + + return Project; +}(_Requestable3.default); + +module.exports = Project; +//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["Project.js"],"names":["Project","id","auth","apiBase","__id","cb","_request","options","_requestAllPages","colId","position","listProjectColumns","then","data","Promise","all","map","column","cardsInColumns","cards","reduce","prev","push","catch","err","cardId","column_id","module","exports"],"mappings":"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","file":"Project.js","sourcesContent":["/**\n * @file\n * @copyright  2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license    Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n *             Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\n\n/**\n * Project encapsulates the functionality to create, query, and modify cards and columns.\n */\nclass Project extends Requestable {\n   /**\n    * Create a Project.\n    * @param {string} id - the id of the project\n    * @param {Requestable.auth} [auth] - information required to authenticate to Github\n    * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n    */\n   constructor(id, auth, apiBase) {\n      super(auth, apiBase, 'inertia-preview');\n      this.__id = id;\n   }\n\n   /**\n    * Get information about a project\n    * @see https://developer.github.com/v3/projects/#get-a-project\n    * @param {Requestable.callback} cb - will receive the project information\n    * @return {Promise} - the promise for the http request\n    */\n   getProject(cb) {\n      return this._request('GET', `/projects/${this.__id}`, null, cb);\n   }\n\n   /**\n    * Edit a project\n    * @see https://developer.github.com/v3/projects/#update-a-project\n    * @param {Object} options - the description of the project\n    * @param {Requestable.callback} cb - will receive the modified project\n    * @return {Promise} - the promise for the http request\n    */\n   updateProject(options, cb) {\n      return this._request('PATCH', `/projects/${this.__id}`, options, cb);\n   }\n\n   /**\n    * Delete a project\n    * @see https://developer.github.com/v3/projects/#delete-a-project\n    * @param {Requestable.callback} cb - will receive true if the operation is successful\n    * @return {Promise} - the promise for the http request\n    */\n   deleteProject(cb) {\n      return this._request('DELETE', `/projects/${this.__id}`, null, cb);\n   }\n\n   /**\n    * Get information about all columns of a project\n    * @see https://developer.github.com/v3/projects/columns/#list-project-columns\n    * @param {Requestable.callback} [cb] - will receive the list of columns\n    * @return {Promise} - the promise for the http request\n    */\n   listProjectColumns(cb) {\n      return this._requestAllPages(`/projects/${this.__id}/columns`, null, cb);\n   }\n\n   /**\n    * Get information about a column\n    * @see https://developer.github.com/v3/projects/columns/#get-a-project-column\n    * @param {string} colId - the id of the column\n    * @param {Requestable.callback} cb - will receive the column information\n    * @return {Promise} - the promise for the http request\n    */\n   getProjectColumn(colId, cb) {\n      return this._request('GET', `/projects/columns/${colId}`, null, cb);\n   }\n\n   /**\n    * Create a new column\n    * @see https://developer.github.com/v3/projects/columns/#create-a-project-column\n    * @param {Object} options - the description of the column\n    * @param {Requestable.callback} cb - will receive the newly created column\n    * @return {Promise} - the promise for the http request\n    */\n   createProjectColumn(options, cb) {\n      return this._request('POST', `/projects/${this.__id}/columns`, options, cb);\n   }\n\n   /**\n    * Edit a column\n    * @see https://developer.github.com/v3/projects/columns/#update-a-project-column\n    * @param {string} colId - the column id\n    * @param {Object} options - the description of the column\n    * @param {Requestable.callback} cb - will receive the modified column\n    * @return {Promise} - the promise for the http request\n    */\n   updateProjectColumn(colId, options, cb) {\n      return this._request('PATCH', `/projects/columns/${colId}`, options, cb);\n   }\n\n   /**\n    * Delete a column\n    * @see https://developer.github.com/v3/projects/columns/#delete-a-project-column\n    * @param {string} colId - the column to be deleted\n    * @param {Requestable.callback} cb - will receive true if the operation is successful\n    * @return {Promise} - the promise for the http request\n    */\n   deleteProjectColumn(colId, cb) {\n      return this._request('DELETE', `/projects/columns/${colId}`, null, cb);\n   }\n\n   /**\n    * Move a column\n    * @see https://developer.github.com/v3/projects/columns/#move-a-project-column\n    * @param {string} colId - the column to be moved\n    * @param {string} position - can be one of first, last, or after:<column-id>,\n    * where <column-id> is the id value of a column in the same project.\n    * @param {Requestable.callback} cb - will receive true if the operation is successful\n    * @return {Promise} - the promise for the http request\n    */\n   moveProjectColumn(colId, position, cb) {\n      return this._request(\n         'POST',\n         `/projects/columns/${colId}/moves`,\n         {position: position},\n         cb\n      );\n   }\n\n  /**\n   * Get information about all cards of a project\n   * @see https://developer.github.com/v3/projects/cards/#list-project-cards\n   * @param {Requestable.callback} [cb] - will receive the list of cards\n   * @return {Promise} - the promise for the http request\n   */\n   listProjectCards(cb) {\n      return this.listProjectColumns()\n        .then(({data}) => {\n           return Promise.all(data.map((column) => {\n              return this._requestAllPages(`/projects/columns/${column.id}/cards`, null);\n           }));\n        }).then((cardsInColumns) => {\n           const cards = cardsInColumns.reduce((prev, {data}) => {\n              prev.push(...data);\n              return prev;\n           }, []);\n           if (cb) {\n              cb(null, cards);\n           }\n           return cards;\n        }).catch((err) => {\n           if (cb) {\n              cb(err);\n              return;\n           }\n           throw err;\n        });\n   }\n\n   /**\n   * Get information about all cards of a column\n   * @see https://developer.github.com/v3/projects/cards/#list-project-cards\n   * @param {string} colId - the id of the column\n   * @param {Requestable.callback} [cb] - will receive the list of cards\n   * @return {Promise} - the promise for the http request\n   */\n   listColumnCards(colId, cb) {\n      return this._requestAllPages(`/projects/columns/${colId}/cards`, null, cb);\n   }\n\n   /**\n   * Get information about a card\n   * @see https://developer.github.com/v3/projects/cards/#get-a-project-card\n   * @param {string} cardId - the id of the card\n   * @param {Requestable.callback} cb - will receive the card information\n   * @return {Promise} - the promise for the http request\n   */\n   getProjectCard(cardId, cb) {\n      return this._request('GET', `/projects/columns/cards/${cardId}`, null, cb);\n   }\n\n   /**\n   * Create a new card\n   * @see https://developer.github.com/v3/projects/cards/#create-a-project-card\n   * @param {string} colId - the column id\n   * @param {Object} options - the description of the card\n   * @param {Requestable.callback} cb - will receive the newly created card\n   * @return {Promise} - the promise for the http request\n   */\n   createProjectCard(colId, options, cb) {\n      return this._request('POST', `/projects/columns/${colId}/cards`, options, cb);\n   }\n\n   /**\n   * Edit a card\n   * @see https://developer.github.com/v3/projects/cards/#update-a-project-card\n   * @param {string} cardId - the card id\n   * @param {Object} options - the description of the card\n   * @param {Requestable.callback} cb - will receive the modified card\n   * @return {Promise} - the promise for the http request\n   */\n   updateProjectCard(cardId, options, cb) {\n      return this._request('PATCH', `/projects/columns/cards/${cardId}`, options, cb);\n   }\n\n   /**\n   * Delete a card\n   * @see https://developer.github.com/v3/projects/cards/#delete-a-project-card\n   * @param {string} cardId - the card to be deleted\n   * @param {Requestable.callback} cb - will receive true if the operation is successful\n   * @return {Promise} - the promise for the http request\n   */\n   deleteProjectCard(cardId, cb) {\n      return this._request('DELETE', `/projects/columns/cards/${cardId}`, null, cb);\n   }\n\n   /**\n   * Move a card\n   * @see https://developer.github.com/v3/projects/cards/#move-a-project-card\n   * @param {string} cardId - the card to be moved\n   * @param {string} position - can be one of top, bottom, or after:<card-id>,\n   * where <card-id> is the id value of a card in the same project.\n   * @param {string} colId - the id value of a column in the same project.\n   * @param {Requestable.callback} cb - will receive true if the operation is successful\n   * @return {Promise} - the promise for the http request\n   */\n   moveProjectCard(cardId, position, colId, cb) {\n      return this._request(\n         'POST',\n         `/projects/columns/cards/${cardId}/moves`,\n         {position: position, column_id: colId}, // eslint-disable-line camelcase\n         cb\n      );\n   }\n}\n\nmodule.exports = Project;\n"]} +//# sourceMappingURL=Project.js.map diff --git a/dist/components/Project.js.map b/dist/components/Project.js.map new file mode 100644 index 00000000..88e1d567 --- /dev/null +++ b/dist/components/Project.js.map @@ -0,0 +1 @@ +{"version":3,"names":[],"mappings":"","sources":["Project.js"],"sourcesContent":["/**\n * @file\n * @copyright 2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n * Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\n\n/**\n * Project encapsulates the functionality to create, query, and modify cards and columns.\n */\nclass Project extends Requestable {\n /**\n * Create a Project.\n * @param {string} id - the id of the project\n * @param {Requestable.auth} [auth] - information required to authenticate to Github\n * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n */\n constructor(id, auth, apiBase) {\n super(auth, apiBase, 'inertia-preview');\n this.__id = id;\n }\n\n /**\n * Get information about a project\n * @see https://developer.github.com/v3/projects/#get-a-project\n * @param {Requestable.callback} cb - will receive the project information\n * @return {Promise} - the promise for the http request\n */\n getProject(cb) {\n return this._request('GET', `/projects/${this.__id}`, null, cb);\n }\n\n /**\n * Edit a project\n * @see https://developer.github.com/v3/projects/#update-a-project\n * @param {Object} options - the description of the project\n * @param {Requestable.callback} cb - will receive the modified project\n * @return {Promise} - the promise for the http request\n */\n updateProject(options, cb) {\n return this._request('PATCH', `/projects/${this.__id}`, options, cb);\n }\n\n /**\n * Delete a project\n * @see https://developer.github.com/v3/projects/#delete-a-project\n * @param {Requestable.callback} cb - will receive true if the operation is successful\n * @return {Promise} - the promise for the http request\n */\n deleteProject(cb) {\n return this._request('DELETE', `/projects/${this.__id}`, null, cb);\n }\n\n /**\n * Get information about all columns of a project\n * @see https://developer.github.com/v3/projects/columns/#list-project-columns\n * @param {Requestable.callback} [cb] - will receive the list of columns\n * @return {Promise} - the promise for the http request\n */\n listProjectColumns(cb) {\n return this._requestAllPages(`/projects/${this.__id}/columns`, null, cb);\n }\n\n /**\n * Get information about a column\n * @see https://developer.github.com/v3/projects/columns/#get-a-project-column\n * @param {string} colId - the id of the column\n * @param {Requestable.callback} cb - will receive the column information\n * @return {Promise} - the promise for the http request\n */\n getProjectColumn(colId, cb) {\n return this._request('GET', `/projects/columns/${colId}`, null, cb);\n }\n\n /**\n * Create a new column\n * @see https://developer.github.com/v3/projects/columns/#create-a-project-column\n * @param {Object} options - the description of the column\n * @param {Requestable.callback} cb - will receive the newly created column\n * @return {Promise} - the promise for the http request\n */\n createProjectColumn(options, cb) {\n return this._request('POST', `/projects/${this.__id}/columns`, options, cb);\n }\n\n /**\n * Edit a column\n * @see https://developer.github.com/v3/projects/columns/#update-a-project-column\n * @param {string} colId - the column id\n * @param {Object} options - the description of the column\n * @param {Requestable.callback} cb - will receive the modified column\n * @return {Promise} - the promise for the http request\n */\n updateProjectColumn(colId, options, cb) {\n return this._request('PATCH', `/projects/columns/${colId}`, options, cb);\n }\n\n /**\n * Delete a column\n * @see https://developer.github.com/v3/projects/columns/#delete-a-project-column\n * @param {string} colId - the column to be deleted\n * @param {Requestable.callback} cb - will receive true if the operation is successful\n * @return {Promise} - the promise for the http request\n */\n deleteProjectColumn(colId, cb) {\n return this._request('DELETE', `/projects/columns/${colId}`, null, cb);\n }\n\n /**\n * Move a column\n * @see https://developer.github.com/v3/projects/columns/#move-a-project-column\n * @param {string} colId - the column to be moved\n * @param {string} position - can be one of first, last, or after:,\n * where is the id value of a column in the same project.\n * @param {Requestable.callback} cb - will receive true if the operation is successful\n * @return {Promise} - the promise for the http request\n */\n moveProjectColumn(colId, position, cb) {\n return this._request(\n 'POST',\n `/projects/columns/${colId}/moves`,\n {position: position},\n cb\n );\n }\n\n /**\n * Get information about all cards of a project\n * @see https://developer.github.com/v3/projects/cards/#list-project-cards\n * @param {Requestable.callback} [cb] - will receive the list of cards\n * @return {Promise} - the promise for the http request\n */\n listProjectCards(cb) {\n return this.listProjectColumns()\n .then(({data}) => {\n return Promise.all(data.map((column) => {\n return this._requestAllPages(`/projects/columns/${column.id}/cards`, null);\n }));\n }).then((cardsInColumns) => {\n const cards = cardsInColumns.reduce((prev, {data}) => {\n prev.push(...data);\n return prev;\n }, []);\n if (cb) {\n cb(null, cards);\n }\n return cards;\n }).catch((err) => {\n if (cb) {\n cb(err);\n return;\n }\n throw err;\n });\n }\n\n /**\n * Get information about all cards of a column\n * @see https://developer.github.com/v3/projects/cards/#list-project-cards\n * @param {string} colId - the id of the column\n * @param {Requestable.callback} [cb] - will receive the list of cards\n * @return {Promise} - the promise for the http request\n */\n listColumnCards(colId, cb) {\n return this._requestAllPages(`/projects/columns/${colId}/cards`, null, cb);\n }\n\n /**\n * Get information about a card\n * @see https://developer.github.com/v3/projects/cards/#get-a-project-card\n * @param {string} cardId - the id of the card\n * @param {Requestable.callback} cb - will receive the card information\n * @return {Promise} - the promise for the http request\n */\n getProjectCard(cardId, cb) {\n return this._request('GET', `/projects/columns/cards/${cardId}`, null, cb);\n }\n\n /**\n * Create a new card\n * @see https://developer.github.com/v3/projects/cards/#create-a-project-card\n * @param {string} colId - the column id\n * @param {Object} options - the description of the card\n * @param {Requestable.callback} cb - will receive the newly created card\n * @return {Promise} - the promise for the http request\n */\n createProjectCard(colId, options, cb) {\n return this._request('POST', `/projects/columns/${colId}/cards`, options, cb);\n }\n\n /**\n * Edit a card\n * @see https://developer.github.com/v3/projects/cards/#update-a-project-card\n * @param {string} cardId - the card id\n * @param {Object} options - the description of the card\n * @param {Requestable.callback} cb - will receive the modified card\n * @return {Promise} - the promise for the http request\n */\n updateProjectCard(cardId, options, cb) {\n return this._request('PATCH', `/projects/columns/cards/${cardId}`, options, cb);\n }\n\n /**\n * Delete a card\n * @see https://developer.github.com/v3/projects/cards/#delete-a-project-card\n * @param {string} cardId - the card to be deleted\n * @param {Requestable.callback} cb - will receive true if the operation is successful\n * @return {Promise} - the promise for the http request\n */\n deleteProjectCard(cardId, cb) {\n return this._request('DELETE', `/projects/columns/cards/${cardId}`, null, cb);\n }\n\n /**\n * Move a card\n * @see https://developer.github.com/v3/projects/cards/#move-a-project-card\n * @param {string} cardId - the card to be moved\n * @param {string} position - can be one of top, bottom, or after:,\n * where is the id value of a card in the same project.\n * @param {string} colId - the id value of a column in the same project.\n * @param {Requestable.callback} cb - will receive true if the operation is successful\n * @return {Promise} - the promise for the http request\n */\n moveProjectCard(cardId, position, colId, cb) {\n return this._request(\n 'POST',\n `/projects/columns/cards/${cardId}/moves`,\n {position: position, column_id: colId}, // eslint-disable-line camelcase\n cb\n );\n }\n}\n\nmodule.exports = Project;\n"],"file":"Project.js"} \ No newline at end of file diff --git a/dist/components/RateLimit.js b/dist/components/RateLimit.js new file mode 100644 index 00000000..847f2dae --- /dev/null +++ b/dist/components/RateLimit.js @@ -0,0 +1,60 @@ +'use strict'; + +var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); + +var _Requestable2 = require('./Requestable'); + +var _Requestable3 = _interopRequireDefault(_Requestable2); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } + +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } /** + * @file + * @copyright 2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc. + * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}. + * Github.js is freely distributable. + */ + +/** + * RateLimit allows users to query their rate-limit status + */ +var RateLimit = function (_Requestable) { + _inherits(RateLimit, _Requestable); + + /** + * construct a RateLimit + * @param {Requestable.auth} auth - the credentials to authenticate to GitHub + * @param {string} [apiBase] - the base Github API URL + * @return {Promise} - the promise for the http request + */ + function RateLimit(auth, apiBase) { + _classCallCheck(this, RateLimit); + + return _possibleConstructorReturn(this, (RateLimit.__proto__ || Object.getPrototypeOf(RateLimit)).call(this, auth, apiBase)); + } + + /** + * Query the current rate limit + * @see https://developer.github.com/v3/rate_limit/ + * @param {Requestable.callback} [cb] - will receive the rate-limit data + * @return {Promise} - the promise for the http request + */ + + + _createClass(RateLimit, [{ + key: 'getRateLimit', + value: function getRateLimit(cb) { + return this._request('GET', '/rate_limit', null, cb); + } + }]); + + return RateLimit; +}(_Requestable3.default); + +module.exports = RateLimit; +//# sourceMappingURL=data:application/json;base64,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 +//# sourceMappingURL=RateLimit.js.map diff --git a/dist/components/RateLimit.js.map b/dist/components/RateLimit.js.map new file mode 100644 index 00000000..8ae70e98 --- /dev/null +++ b/dist/components/RateLimit.js.map @@ -0,0 +1 @@ +{"version":3,"names":[],"mappings":"","sources":["RateLimit.js"],"sourcesContent":["/**\n * @file\n * @copyright 2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n * Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\n\n/**\n * RateLimit allows users to query their rate-limit status\n */\nclass RateLimit extends Requestable {\n /**\n * construct a RateLimit\n * @param {Requestable.auth} auth - the credentials to authenticate to GitHub\n * @param {string} [apiBase] - the base Github API URL\n * @return {Promise} - the promise for the http request\n */\n constructor(auth, apiBase) {\n super(auth, apiBase);\n }\n\n /**\n * Query the current rate limit\n * @see https://developer.github.com/v3/rate_limit/\n * @param {Requestable.callback} [cb] - will receive the rate-limit data\n * @return {Promise} - the promise for the http request\n */\n getRateLimit(cb) {\n return this._request('GET', '/rate_limit', null, cb);\n }\n}\n\nmodule.exports = RateLimit;\n"],"file":"RateLimit.js"} \ No newline at end of file diff --git a/dist/components/Repository.js b/dist/components/Repository.js new file mode 100644 index 00000000..e7522ebd --- /dev/null +++ b/dist/components/Repository.js @@ -0,0 +1,1089 @@ +'use strict'; + +var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; + +var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); + +var _Requestable2 = require('./Requestable'); + +var _Requestable3 = _interopRequireDefault(_Requestable2); + +var _utf = require('utf8'); + +var _utf2 = _interopRequireDefault(_utf); + +var _jsBase = require('js-base64'); + +var _debug = require('debug'); + +var _debug2 = _interopRequireDefault(_debug); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } + +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } /** + * @file + * @copyright 2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc. + * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}. + * Github.js is freely distributable. + */ + +var log = (0, _debug2.default)('github:repository'); + +/** + * Respository encapsulates the functionality to create, query, and modify files. + */ + +var Repository = function (_Requestable) { + _inherits(Repository, _Requestable); + + /** + * Create a Repository. + * @param {string} fullname - the full name of the repository + * @param {Requestable.auth} [auth] - information required to authenticate to Github + * @param {string} [apiBase=https://api.github.com] - the base Github API URL + */ + function Repository(fullname, auth, apiBase) { + _classCallCheck(this, Repository); + + var _this = _possibleConstructorReturn(this, (Repository.__proto__ || Object.getPrototypeOf(Repository)).call(this, auth, apiBase)); + + _this.__fullname = fullname; + _this.__currentTree = { + branch: null, + sha: null + }; + return _this; + } + + /** + * Get a reference + * @see https://developer.github.com/v3/git/refs/#get-a-reference + * @param {string} ref - the reference to get + * @param {Requestable.callback} [cb] - will receive the reference's refSpec or a list of refSpecs that match `ref` + * @return {Promise} - the promise for the http request + */ + + + _createClass(Repository, [{ + key: 'getRef', + value: function getRef(ref, cb) { + return this._request('GET', '/repos/' + this.__fullname + '/git/refs/' + ref, null, cb); + } + + /** + * Create a reference + * @see https://developer.github.com/v3/git/refs/#create-a-reference + * @param {Object} options - the object describing the ref + * @param {Requestable.callback} [cb] - will receive the ref + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'createRef', + value: function createRef(options, cb) { + return this._request('POST', '/repos/' + this.__fullname + '/git/refs', options, cb); + } + + /** + * Delete a reference + * @see https://developer.github.com/v3/git/refs/#delete-a-reference + * @param {string} ref - the name of the ref to delte + * @param {Requestable.callback} [cb] - will receive true if the request is successful + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'deleteRef', + value: function deleteRef(ref, cb) { + return this._request('DELETE', '/repos/' + this.__fullname + '/git/refs/' + ref, null, cb); + } + + /** + * Delete a repository + * @see https://developer.github.com/v3/repos/#delete-a-repository + * @param {Requestable.callback} [cb] - will receive true if the request is successful + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'deleteRepo', + value: function deleteRepo(cb) { + return this._request('DELETE', '/repos/' + this.__fullname, null, cb); + } + + /** + * List the tags on a repository + * @see https://developer.github.com/v3/repos/#list-tags + * @param {Requestable.callback} [cb] - will receive the tag data + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'listTags', + value: function listTags(cb) { + return this._request('GET', '/repos/' + this.__fullname + '/tags', null, cb); + } + + /** + * List the open pull requests on the repository + * @see https://developer.github.com/v3/pulls/#list-pull-requests + * @param {Object} options - options to filter the search + * @param {Requestable.callback} [cb] - will receive the list of PRs + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'listPullRequests', + value: function listPullRequests(options, cb) { + options = options || {}; + return this._request('GET', '/repos/' + this.__fullname + '/pulls', options, cb); + } + + /** + * Get information about a specific pull request + * @see https://developer.github.com/v3/pulls/#get-a-single-pull-request + * @param {number} number - the PR you wish to fetch + * @param {Requestable.callback} [cb] - will receive the PR from the API + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'getPullRequest', + value: function getPullRequest(number, cb) { + return this._request('GET', '/repos/' + this.__fullname + '/pulls/' + number, null, cb); + } + + /** + * List the files of a specific pull request + * @see https://developer.github.com/v3/pulls/#list-pull-requests-files + * @param {number|string} number - the PR you wish to fetch + * @param {Requestable.callback} [cb] - will receive the list of files from the API + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'listPullRequestFiles', + value: function listPullRequestFiles(number, cb) { + return this._request('GET', '/repos/' + this.__fullname + '/pulls/' + number + '/files', null, cb); + } + + /** + * Compare two branches/commits/repositories + * @see https://developer.github.com/v3/repos/commits/#compare-two-commits + * @param {string} base - the base commit + * @param {string} head - the head commit + * @param {Requestable.callback} cb - will receive the comparison + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'compareBranches', + value: function compareBranches(base, head, cb) { + return this._request('GET', '/repos/' + this.__fullname + '/compare/' + base + '...' + head, null, cb); + } + + /** + * List all the branches for the repository + * @see https://developer.github.com/v3/repos/#list-branches + * @param {Requestable.callback} cb - will receive the list of branches + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'listBranches', + value: function listBranches(cb) { + return this._request('GET', '/repos/' + this.__fullname + '/branches', null, cb); + } + + /** + * Get a raw blob from the repository + * @see https://developer.github.com/v3/git/blobs/#get-a-blob + * @param {string} sha - the sha of the blob to fetch + * @param {Requestable.callback} cb - will receive the blob from the API + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'getBlob', + value: function getBlob(sha, cb) { + return this._request('GET', '/repos/' + this.__fullname + '/git/blobs/' + sha, null, cb, 'raw'); + } + + /** + * Get a single branch + * @see https://developer.github.com/v3/repos/branches/#get-branch + * @param {string} branch - the name of the branch to fetch + * @param {Requestable.callback} cb - will receive the branch from the API + * @returns {Promise} - the promise for the http request + */ + + }, { + key: 'getBranch', + value: function getBranch(branch, cb) { + return this._request('GET', '/repos/' + this.__fullname + '/branches/' + branch, null, cb); + } + + /** + * Get a commit from the repository + * @see https://developer.github.com/v3/repos/commits/#get-a-single-commit + * @param {string} sha - the sha for the commit to fetch + * @param {Requestable.callback} cb - will receive the commit data + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'getCommit', + value: function getCommit(sha, cb) { + return this._request('GET', '/repos/' + this.__fullname + '/git/commits/' + sha, null, cb); + } + + /** + * List the commits on a repository, optionally filtering by path, author or time range + * @see https://developer.github.com/v3/repos/commits/#list-commits-on-a-repository + * @param {Object} [options] - the filtering options for commits + * @param {string} [options.sha] - the SHA or branch to start from + * @param {string} [options.path] - the path to search on + * @param {string} [options.author] - the commit author + * @param {(Date|string)} [options.since] - only commits after this date will be returned + * @param {(Date|string)} [options.until] - only commits before this date will be returned + * @param {Requestable.callback} cb - will receive the list of commits found matching the criteria + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'listCommits', + value: function listCommits(options, cb) { + options = options || {}; + + options.since = this._dateToISO(options.since); + options.until = this._dateToISO(options.until); + + return this._request('GET', '/repos/' + this.__fullname + '/commits', options, cb); + } + + /** + * Gets a single commit information for a repository + * @see https://developer.github.com/v3/repos/commits/#get-a-single-commit + * @param {string} ref - the reference for the commit-ish + * @param {Requestable.callback} cb - will receive the commit information + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'getSingleCommit', + value: function getSingleCommit(ref, cb) { + ref = ref || ''; + return this._request('GET', '/repos/' + this.__fullname + '/commits/' + ref, null, cb); + } + + /** + * Get tha sha for a particular object in the repository. This is a convenience function + * @see https://developer.github.com/v3/repos/contents/#get-contents + * @param {string} [branch] - the branch to look in, or the repository's default branch if omitted + * @param {string} path - the path of the file or directory + * @param {Requestable.callback} cb - will receive a description of the requested object, including a `SHA` property + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'getSha', + value: function getSha(branch, path, cb) { + branch = branch ? '?ref=' + branch : ''; + return this._request('GET', '/repos/' + this.__fullname + '/contents/' + path + branch, null, cb); + } + + /** + * List the commit statuses for a particular sha, branch, or tag + * @see https://developer.github.com/v3/repos/statuses/#list-statuses-for-a-specific-ref + * @param {string} sha - the sha, branch, or tag to get statuses for + * @param {Requestable.callback} cb - will receive the list of statuses + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'listStatuses', + value: function listStatuses(sha, cb) { + return this._request('GET', '/repos/' + this.__fullname + '/commits/' + sha + '/statuses', null, cb); + } + + /** + * Get a description of a git tree + * @see https://developer.github.com/v3/git/trees/#get-a-tree + * @param {string} treeSHA - the SHA of the tree to fetch + * @param {Requestable.callback} cb - will receive the callback data + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'getTree', + value: function getTree(treeSHA, cb) { + return this._request('GET', '/repos/' + this.__fullname + '/git/trees/' + treeSHA, null, cb); + } + + /** + * Create a blob + * @see https://developer.github.com/v3/git/blobs/#create-a-blob + * @param {(string|Buffer|Blob)} content - the content to add to the repository + * @param {Requestable.callback} cb - will receive the details of the created blob + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'createBlob', + value: function createBlob(content, cb) { + var postBody = this._getContentObject(content); + + log('sending content', postBody); + return this._request('POST', '/repos/' + this.__fullname + '/git/blobs', postBody, cb); + } + + /** + * Get the object that represents the provided content + * @param {string|Buffer|Blob} content - the content to send to the server + * @return {Object} the representation of `content` for the GitHub API + */ + + }, { + key: '_getContentObject', + value: function _getContentObject(content) { + if (typeof content === 'string') { + log('contet is a string'); + return { + content: _utf2.default.encode(content), + encoding: 'utf-8' + }; + } else if (typeof Buffer !== 'undefined' && content instanceof Buffer) { + log('We appear to be in Node'); + return { + content: content.toString('base64'), + encoding: 'base64' + }; + } else if (typeof Blob !== 'undefined' && content instanceof Blob) { + log('We appear to be in the browser'); + return { + content: _jsBase.Base64.encode(content), + encoding: 'base64' + }; + } else { + // eslint-disable-line + log('Not sure what this content is: ' + (typeof content === 'undefined' ? 'undefined' : _typeof(content)) + ', ' + JSON.stringify(content)); + throw new Error('Unknown content passed to postBlob. Must be string or Buffer (node) or Blob (web)'); + } + } + + /** + * Update a tree in Git + * @see https://developer.github.com/v3/git/trees/#create-a-tree + * @param {string} baseTreeSHA - the SHA of the tree to update + * @param {string} path - the path for the new file + * @param {string} blobSHA - the SHA for the blob to put at `path` + * @param {Requestable.callback} cb - will receive the new tree that is created + * @return {Promise} - the promise for the http request + * @deprecated use {@link Repository#createTree} instead + */ + + }, { + key: 'updateTree', + value: function updateTree(baseTreeSHA, path, blobSHA, cb) { + var newTree = { + base_tree: baseTreeSHA, // eslint-disable-line + tree: [{ + path: path, + sha: blobSHA, + mode: '100644', + type: 'blob' + }] + }; + + return this._request('POST', '/repos/' + this.__fullname + '/git/trees', newTree, cb); + } + + /** + * Create a new tree in git + * @see https://developer.github.com/v3/git/trees/#create-a-tree + * @param {Object} tree - the tree to create + * @param {string} baseSHA - the root sha of the tree + * @param {Requestable.callback} cb - will receive the new tree that is created + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'createTree', + value: function createTree(tree, baseSHA, cb) { + return this._request('POST', '/repos/' + this.__fullname + '/git/trees', { + tree: tree, + base_tree: baseSHA }, cb); + } + + /** + * Add a commit to the repository + * @see https://developer.github.com/v3/git/commits/#create-a-commit + * @param {string} parent - the SHA of the parent commit + * @param {string} tree - the SHA of the tree for this commit + * @param {string} message - the commit message + * @param {Requestable.callback} cb - will receive the commit that is created + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'commit', + value: function commit(parent, tree, message, cb) { + var _this2 = this; + + var data = { + message: message, + tree: tree, + parents: [parent] + }; + + return this._request('POST', '/repos/' + this.__fullname + '/git/commits', data, cb).then(function (response) { + _this2.__currentTree.sha = response.data.sha; // Update latest commit + return response; + }); + } + + /** + * Update a ref + * @see https://developer.github.com/v3/git/refs/#update-a-reference + * @param {string} ref - the ref to update + * @param {string} commitSHA - the SHA to point the reference to + * @param {boolean} force - indicates whether to force or ensure a fast-forward update + * @param {Requestable.callback} cb - will receive the updated ref back + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'updateHead', + value: function updateHead(ref, commitSHA, force, cb) { + return this._request('PATCH', '/repos/' + this.__fullname + '/git/refs/' + ref, { + sha: commitSHA, + force: force + }, cb); + } + + /** + * Update commit status + * @see https://developer.github.com/v3/repos/statuses/ + * @param {string} commitSHA - the SHA of the commit that should be updated + * @param {object} options - Commit status parameters + * @param {string} options.state - The state of the status. Can be one of: pending, success, error, or failure. + * @param {string} [options.target_url] - The target URL to associate with this status. + * @param {string} [options.description] - A short description of the status. + * @param {string} [options.context] - A string label to differentiate this status among CI systems. + * @param {Requestable.callback} cb - will receive the updated commit back + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'updateStatus', + value: function updateStatus(commitSHA, options, cb) { + return this._request('POST', '/repos/' + this.__fullname + '/statuses/' + commitSHA, options, cb); + } + + /** + * Update repository information + * @see https://developer.github.com/v3/repos/#edit + * @param {object} options - New parameters that will be set to the repository + * @param {string} options.name - Name of the repository + * @param {string} [options.description] - A short description of the repository + * @param {string} [options.homepage] - A URL with more information about the repository + * @param {boolean} [options.private] - Either true to make the repository private, or false to make it public. + * @param {boolean} [options.has_issues] - Either true to enable issues for this repository, false to disable them. + * @param {boolean} [options.has_wiki] - Either true to enable the wiki for this repository, false to disable it. + * @param {boolean} [options.has_downloads] - Either true to enable downloads, false to disable them. + * @param {string} [options.default_branch] - Updates the default branch for this repository. + * @param {Requestable.callback} cb - will receive the updated repository back + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'updateRepository', + value: function updateRepository(options, cb) { + return this._request('PATCH', '/repos/' + this.__fullname, options, cb); + } + + /** + * Get information about the repository + * @see https://developer.github.com/v3/repos/#get + * @param {Requestable.callback} cb - will receive the information about the repository + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'getDetails', + value: function getDetails(cb) { + return this._request('GET', '/repos/' + this.__fullname, null, cb); + } + + /** + * List the contributors to the repository + * @see https://developer.github.com/v3/repos/#list-contributors + * @param {Requestable.callback} cb - will receive the list of contributors + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'getContributors', + value: function getContributors(cb) { + return this._request('GET', '/repos/' + this.__fullname + '/contributors', null, cb); + } + + /** + * List the contributor stats to the repository + * @see https://developer.github.com/v3/repos/#list-contributors + * @param {Requestable.callback} cb - will receive the list of contributors + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'getContributorStats', + value: function getContributorStats(cb) { + return this._request('GET', '/repos/' + this.__fullname + '/stats/contributors', null, cb); + } + + /** + * List the users who are collaborators on the repository. The currently authenticated user must have + * push access to use this method + * @see https://developer.github.com/v3/repos/collaborators/#list-collaborators + * @param {Requestable.callback} cb - will receive the list of collaborators + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'getCollaborators', + value: function getCollaborators(cb) { + return this._request('GET', '/repos/' + this.__fullname + '/collaborators', null, cb); + } + + /** + * Check if a user is a collaborator on the repository + * @see https://developer.github.com/v3/repos/collaborators/#check-if-a-user-is-a-collaborator + * @param {string} username - the user to check + * @param {Requestable.callback} cb - will receive true if the user is a collaborator and false if they are not + * @return {Promise} - the promise for the http request {Boolean} [description] + */ + + }, { + key: 'isCollaborator', + value: function isCollaborator(username, cb) { + return this._request('GET', '/repos/' + this.__fullname + '/collaborators/' + username, null, cb); + } + + /** + * Get the contents of a repository + * @see https://developer.github.com/v3/repos/contents/#get-contents + * @param {string} ref - the ref to check + * @param {string} path - the path containing the content to fetch + * @param {boolean} raw - `true` if the results should be returned raw instead of GitHub's normalized format + * @param {Requestable.callback} cb - will receive the fetched data + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'getContents', + value: function getContents(ref, path, raw, cb) { + path = path ? '' + encodeURI(path) : ''; + return this._request('GET', '/repos/' + this.__fullname + '/contents/' + path, { + ref: ref + }, cb, raw); + } + + /** + * Get the README of a repository + * @see https://developer.github.com/v3/repos/contents/#get-the-readme + * @param {string} ref - the ref to check + * @param {boolean} raw - `true` if the results should be returned raw instead of GitHub's normalized format + * @param {Requestable.callback} cb - will receive the fetched data + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'getReadme', + value: function getReadme(ref, raw, cb) { + return this._request('GET', '/repos/' + this.__fullname + '/readme', { + ref: ref + }, cb, raw); + } + + /** + * Fork a repository + * @see https://developer.github.com/v3/repos/forks/#create-a-fork + * @param {Requestable.callback} cb - will receive the information about the newly created fork + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'fork', + value: function fork(cb) { + return this._request('POST', '/repos/' + this.__fullname + '/forks', null, cb); + } + + /** + * List a repository's forks + * @see https://developer.github.com/v3/repos/forks/#list-forks + * @param {Requestable.callback} cb - will receive the list of repositories forked from this one + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'listForks', + value: function listForks(cb) { + return this._request('GET', '/repos/' + this.__fullname + '/forks', null, cb); + } + + /** + * Create a new branch from an existing branch. + * @param {string} [oldBranch=master] - the name of the existing branch + * @param {string} newBranch - the name of the new branch + * @param {Requestable.callback} cb - will receive the commit data for the head of the new branch + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'createBranch', + value: function createBranch(oldBranch, newBranch, cb) { + var _this3 = this; + + if (typeof newBranch === 'function') { + cb = newBranch; + newBranch = oldBranch; + oldBranch = 'master'; + } + + return this.getRef('heads/' + oldBranch).then(function (response) { + var sha = response.data.object.sha; + return _this3.createRef({ + sha: sha, + ref: 'refs/heads/' + newBranch + }, cb); + }); + } + + /** + * Create a new pull request + * @see https://developer.github.com/v3/pulls/#create-a-pull-request + * @param {Object} options - the pull request description + * @param {Requestable.callback} cb - will receive the new pull request + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'createPullRequest', + value: function createPullRequest(options, cb) { + return this._request('POST', '/repos/' + this.__fullname + '/pulls', options, cb); + } + + /** + * Update a pull request + * @see https://developer.github.com/v3/pulls/#update-a-pull-request + * @param {number|string} number - the number of the pull request to update + * @param {Object} options - the pull request description + * @param {Requestable.callback} [cb] - will receive the pull request information + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'updatePullRequest', + value: function updatePullRequest(number, options, cb) { + return this._request('PATCH', '/repos/' + this.__fullname + '/pulls/' + number, options, cb); + } + + /** + * List the hooks for the repository + * @see https://developer.github.com/v3/repos/hooks/#list-hooks + * @param {Requestable.callback} cb - will receive the list of hooks + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'listHooks', + value: function listHooks(cb) { + return this._request('GET', '/repos/' + this.__fullname + '/hooks', null, cb); + } + + /** + * Get a hook for the repository + * @see https://developer.github.com/v3/repos/hooks/#get-single-hook + * @param {number} id - the id of the webook + * @param {Requestable.callback} cb - will receive the details of the webook + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'getHook', + value: function getHook(id, cb) { + return this._request('GET', '/repos/' + this.__fullname + '/hooks/' + id, null, cb); + } + + /** + * Add a new hook to the repository + * @see https://developer.github.com/v3/repos/hooks/#create-a-hook + * @param {Object} options - the configuration describing the new hook + * @param {Requestable.callback} cb - will receive the new webhook + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'createHook', + value: function createHook(options, cb) { + return this._request('POST', '/repos/' + this.__fullname + '/hooks', options, cb); + } + + /** + * Edit an existing webhook + * @see https://developer.github.com/v3/repos/hooks/#edit-a-hook + * @param {number} id - the id of the webhook + * @param {Object} options - the new description of the webhook + * @param {Requestable.callback} cb - will receive the updated webhook + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'updateHook', + value: function updateHook(id, options, cb) { + return this._request('PATCH', '/repos/' + this.__fullname + '/hooks/' + id, options, cb); + } + + /** + * Delete a webhook + * @see https://developer.github.com/v3/repos/hooks/#delete-a-hook + * @param {number} id - the id of the webhook to be deleted + * @param {Requestable.callback} cb - will receive true if the call is successful + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'deleteHook', + value: function deleteHook(id, cb) { + return this._request('DELETE', '/repos/' + this.__fullname + '/hooks/' + id, null, cb); + } + + /** + * List the deploy keys for the repository + * @see https://developer.github.com/v3/repos/keys/#list-deploy-keys + * @param {Requestable.callback} cb - will receive the list of deploy keys + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'listKeys', + value: function listKeys(cb) { + return this._request('GET', '/repos/' + this.__fullname + '/keys', null, cb); + } + + /** + * Get a deploy key for the repository + * @see https://developer.github.com/v3/repos/keys/#get-a-deploy-key + * @param {number} id - the id of the deploy key + * @param {Requestable.callback} cb - will receive the details of the deploy key + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'getKey', + value: function getKey(id, cb) { + return this._request('GET', '/repos/' + this.__fullname + '/keys/' + id, null, cb); + } + + /** + * Add a new deploy key to the repository + * @see https://developer.github.com/v3/repos/keys/#add-a-new-deploy-key + * @param {Object} options - the configuration describing the new deploy key + * @param {Requestable.callback} cb - will receive the new deploy key + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'createKey', + value: function createKey(options, cb) { + return this._request('POST', '/repos/' + this.__fullname + '/keys', options, cb); + } + + /** + * Delete a deploy key + * @see https://developer.github.com/v3/repos/keys/#remove-a-deploy-key + * @param {number} id - the id of the deploy key to be deleted + * @param {Requestable.callback} cb - will receive true if the call is successful + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'deleteKey', + value: function deleteKey(id, cb) { + return this._request('DELETE', '/repos/' + this.__fullname + '/keys/' + id, null, cb); + } + + /** + * Delete a file from a branch + * @see https://developer.github.com/v3/repos/contents/#delete-a-file + * @param {string} branch - the branch to delete from, or the default branch if not specified + * @param {string} path - the path of the file to remove + * @param {Requestable.callback} cb - will receive the commit in which the delete occurred + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'deleteFile', + value: function deleteFile(branch, path, cb) { + var _this4 = this; + + return this.getSha(branch, path).then(function (response) { + var deleteCommit = { + message: 'Delete the file at \'' + path + '\'', + sha: response.data.sha, + branch: branch + }; + return _this4._request('DELETE', '/repos/' + _this4.__fullname + '/contents/' + path, deleteCommit, cb); + }); + } + + /** + * Change all references in a repo from oldPath to new_path + * @param {string} branch - the branch to carry out the reference change, or the default branch if not specified + * @param {string} oldPath - original path + * @param {string} newPath - new reference path + * @param {Requestable.callback} cb - will receive the commit in which the move occurred + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'move', + value: function move(branch, oldPath, newPath, cb) { + var _this5 = this; + + var oldSha = void 0; + return this.getRef('heads/' + branch).then(function (_ref) { + var object = _ref.data.object; + return _this5.getTree(object.sha + '?recursive=true'); + }).then(function (_ref2) { + var _ref2$data = _ref2.data, + tree = _ref2$data.tree, + sha = _ref2$data.sha; + + oldSha = sha; + var newTree = tree.map(function (ref) { + if (ref.path === oldPath) { + ref.path = newPath; + } + if (ref.type === 'tree') { + delete ref.sha; + } + return ref; + }); + return _this5.createTree(newTree); + }).then(function (_ref3) { + var tree = _ref3.data; + return _this5.commit(oldSha, tree.sha, 'Renamed \'' + oldPath + '\' to \'' + newPath + '\''); + }).then(function (_ref4) { + var commit = _ref4.data; + return _this5.updateHead('heads/' + branch, commit.sha, true, cb); + }); + } + + /** + * Write a file to the repository + * @see https://developer.github.com/v3/repos/contents/#update-a-file + * @param {string} branch - the name of the branch + * @param {string} path - the path for the file + * @param {string} content - the contents of the file + * @param {string} message - the commit message + * @param {Object} [options] - commit options + * @param {Object} [options.author] - the author of the commit + * @param {Object} [options.commiter] - the committer + * @param {boolean} [options.encode] - true if the content should be base64 encoded + * @param {Requestable.callback} cb - will receive the new commit + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'writeFile', + value: function writeFile(branch, path, content, message, options, cb) { + var _this6 = this; + + if (typeof options === 'function') { + cb = options; + options = {}; + } + var filePath = path ? encodeURI(path) : ''; + var shouldEncode = options.encode !== false; + var commit = { + branch: branch, + message: message, + author: options.author, + committer: options.committer, + content: shouldEncode ? _jsBase.Base64.encode(content) : content + }; + + return this.getSha(branch, filePath).then(function (response) { + commit.sha = response.data.sha; + return _this6._request('PUT', '/repos/' + _this6.__fullname + '/contents/' + filePath, commit, cb); + }, function () { + return _this6._request('PUT', '/repos/' + _this6.__fullname + '/contents/' + filePath, commit, cb); + }); + } + + /** + * Check if a repository is starred by you + * @see https://developer.github.com/v3/activity/starring/#check-if-you-are-starring-a-repository + * @param {Requestable.callback} cb - will receive true if the repository is starred and false if the repository + * is not starred + * @return {Promise} - the promise for the http request {Boolean} [description] + */ + + }, { + key: 'isStarred', + value: function isStarred(cb) { + return this._request204or404('/user/starred/' + this.__fullname, null, cb); + } + + /** + * Star a repository + * @see https://developer.github.com/v3/activity/starring/#star-a-repository + * @param {Requestable.callback} cb - will receive true if the repository is starred + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'star', + value: function star(cb) { + return this._request('PUT', '/user/starred/' + this.__fullname, null, cb); + } + + /** + * Unstar a repository + * @see https://developer.github.com/v3/activity/starring/#unstar-a-repository + * @param {Requestable.callback} cb - will receive true if the repository is unstarred + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'unstar', + value: function unstar(cb) { + return this._request('DELETE', '/user/starred/' + this.__fullname, null, cb); + } + + /** + * Create a new release + * @see https://developer.github.com/v3/repos/releases/#create-a-release + * @param {Object} options - the description of the release + * @param {Requestable.callback} cb - will receive the newly created release + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'createRelease', + value: function createRelease(options, cb) { + return this._request('POST', '/repos/' + this.__fullname + '/releases', options, cb); + } + + /** + * Edit a release + * @see https://developer.github.com/v3/repos/releases/#edit-a-release + * @param {string} id - the id of the release + * @param {Object} options - the description of the release + * @param {Requestable.callback} cb - will receive the modified release + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'updateRelease', + value: function updateRelease(id, options, cb) { + return this._request('PATCH', '/repos/' + this.__fullname + '/releases/' + id, options, cb); + } + + /** + * Get information about all releases + * @see https://developer.github.com/v3/repos/releases/#list-releases-for-a-repository + * @param {Requestable.callback} cb - will receive the release information + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'listReleases', + value: function listReleases(cb) { + return this._request('GET', '/repos/' + this.__fullname + '/releases', null, cb); + } + + /** + * Get information about a release + * @see https://developer.github.com/v3/repos/releases/#get-a-single-release + * @param {string} id - the id of the release + * @param {Requestable.callback} cb - will receive the release information + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'getRelease', + value: function getRelease(id, cb) { + return this._request('GET', '/repos/' + this.__fullname + '/releases/' + id, null, cb); + } + + /** + * Delete a release + * @see https://developer.github.com/v3/repos/releases/#delete-a-release + * @param {string} id - the release to be deleted + * @param {Requestable.callback} cb - will receive true if the operation is successful + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'deleteRelease', + value: function deleteRelease(id, cb) { + return this._request('DELETE', '/repos/' + this.__fullname + '/releases/' + id, null, cb); + } + + /** + * Merge a pull request + * @see https://developer.github.com/v3/pulls/#merge-a-pull-request-merge-button + * @param {number|string} number - the number of the pull request to merge + * @param {Object} options - the merge options for the pull request + * @param {Requestable.callback} [cb] - will receive the merge information if the operation is successful + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'mergePullRequest', + value: function mergePullRequest(number, options, cb) { + return this._request('PUT', '/repos/' + this.__fullname + '/pulls/' + number + '/merge', options, cb); + } + + /** + * Get information about all projects + * @see https://developer.github.com/v3/projects/#list-repository-projects + * @param {Requestable.callback} [cb] - will receive the list of projects + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'listProjects', + value: function listProjects(cb) { + return this._requestAllPages('/repos/' + this.__fullname + '/projects', { AcceptHeader: 'inertia-preview' }, cb); + } + + /** + * Create a new project + * @see https://developer.github.com/v3/projects/#create-a-repository-project + * @param {Object} options - the description of the project + * @param {Requestable.callback} cb - will receive the newly created project + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'createProject', + value: function createProject(options, cb) { + options = options || {}; + options.AcceptHeader = 'inertia-preview'; + return this._request('POST', '/repos/' + this.__fullname + '/projects', options, cb); + } + }]); + + return Repository; +}(_Requestable3.default); + +module.exports = Repository; +//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["Repository.js"],"names":["log","Repository","fullname","auth","apiBase","__fullname","__currentTree","branch","sha","ref","cb","_request","options","number","base","head","since","_dateToISO","until","path","treeSHA","content","postBody","_getContentObject","encode","encoding","Buffer","toString","Blob","JSON","stringify","Error","baseTreeSHA","blobSHA","newTree","base_tree","tree","mode","type","baseSHA","parent","message","data","parents","then","response","commitSHA","force","username","raw","encodeURI","oldBranch","newBranch","getRef","object","createRef","id","getSha","deleteCommit","oldPath","newPath","oldSha","getTree","map","createTree","commit","updateHead","filePath","shouldEncode","author","committer","_request204or404","_requestAllPages","AcceptHeader","module","exports"],"mappings":"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","file":"Repository.js","sourcesContent":["/**\n * @file\n * @copyright  2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license    Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n *             Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\nimport Utf8 from 'utf8';\nimport {\n   Base64,\n} from 'js-base64';\nimport debug from 'debug';\nconst log = debug('github:repository');\n\n/**\n * Respository encapsulates the functionality to create, query, and modify files.\n */\nclass Repository extends Requestable {\n   /**\n    * Create a Repository.\n    * @param {string} fullname - the full name of the repository\n    * @param {Requestable.auth} [auth] - information required to authenticate to Github\n    * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n    */\n   constructor(fullname, auth, apiBase) {\n      super(auth, apiBase);\n      this.__fullname = fullname;\n      this.__currentTree = {\n         branch: null,\n         sha: null,\n      };\n   }\n\n   /**\n    * Get a reference\n    * @see https://developer.github.com/v3/git/refs/#get-a-reference\n    * @param {string} ref - the reference to get\n    * @param {Requestable.callback} [cb] - will receive the reference's refSpec or a list of refSpecs that match `ref`\n    * @return {Promise} - the promise for the http request\n    */\n   getRef(ref, cb) {\n      return this._request('GET', `/repos/${this.__fullname}/git/refs/${ref}`, null, cb);\n   }\n\n   /**\n    * Create a reference\n    * @see https://developer.github.com/v3/git/refs/#create-a-reference\n    * @param {Object} options - the object describing the ref\n    * @param {Requestable.callback} [cb] - will receive the ref\n    * @return {Promise} - the promise for the http request\n    */\n   createRef(options, cb) {\n      return this._request('POST', `/repos/${this.__fullname}/git/refs`, options, cb);\n   }\n\n   /**\n    * Delete a reference\n    * @see https://developer.github.com/v3/git/refs/#delete-a-reference\n    * @param {string} ref - the name of the ref to delte\n    * @param {Requestable.callback} [cb] - will receive true if the request is successful\n    * @return {Promise} - the promise for the http request\n    */\n   deleteRef(ref, cb) {\n      return this._request('DELETE', `/repos/${this.__fullname}/git/refs/${ref}`, null, cb);\n   }\n\n   /**\n    * Delete a repository\n    * @see https://developer.github.com/v3/repos/#delete-a-repository\n    * @param {Requestable.callback} [cb] - will receive true if the request is successful\n    * @return {Promise} - the promise for the http request\n    */\n   deleteRepo(cb) {\n      return this._request('DELETE', `/repos/${this.__fullname}`, null, cb);\n   }\n\n   /**\n    * List the tags on a repository\n    * @see https://developer.github.com/v3/repos/#list-tags\n    * @param {Requestable.callback} [cb] - will receive the tag data\n    * @return {Promise} - the promise for the http request\n    */\n   listTags(cb) {\n      return this._request('GET', `/repos/${this.__fullname}/tags`, null, cb);\n   }\n\n   /**\n    * List the open pull requests on the repository\n    * @see https://developer.github.com/v3/pulls/#list-pull-requests\n    * @param {Object} options - options to filter the search\n    * @param {Requestable.callback} [cb] - will receive the list of PRs\n    * @return {Promise} - the promise for the http request\n    */\n   listPullRequests(options, cb) {\n      options = options || {};\n      return this._request('GET', `/repos/${this.__fullname}/pulls`, options, cb);\n   }\n\n   /**\n    * Get information about a specific pull request\n    * @see https://developer.github.com/v3/pulls/#get-a-single-pull-request\n    * @param {number} number - the PR you wish to fetch\n    * @param {Requestable.callback} [cb] - will receive the PR from the API\n    * @return {Promise} - the promise for the http request\n    */\n   getPullRequest(number, cb) {\n      return this._request('GET', `/repos/${this.__fullname}/pulls/${number}`, null, cb);\n   }\n\n   /**\n    * List the files of a specific pull request\n    * @see https://developer.github.com/v3/pulls/#list-pull-requests-files\n    * @param {number|string} number - the PR you wish to fetch\n    * @param {Requestable.callback} [cb] - will receive the list of files from the API\n    * @return {Promise} - the promise for the http request\n    */\n   listPullRequestFiles(number, cb) {\n      return this._request('GET', `/repos/${this.__fullname}/pulls/${number}/files`, null, cb);\n   }\n\n   /**\n    * Compare two branches/commits/repositories\n    * @see https://developer.github.com/v3/repos/commits/#compare-two-commits\n    * @param {string} base - the base commit\n    * @param {string} head - the head commit\n    * @param {Requestable.callback} cb - will receive the comparison\n    * @return {Promise} - the promise for the http request\n    */\n   compareBranches(base, head, cb) {\n      return this._request('GET', `/repos/${this.__fullname}/compare/${base}...${head}`, null, cb);\n   }\n\n   /**\n    * List all the branches for the repository\n    * @see https://developer.github.com/v3/repos/#list-branches\n    * @param {Requestable.callback} cb - will receive the list of branches\n    * @return {Promise} - the promise for the http request\n    */\n   listBranches(cb) {\n      return this._request('GET', `/repos/${this.__fullname}/branches`, null, cb);\n   }\n\n   /**\n    * Get a raw blob from the repository\n    * @see https://developer.github.com/v3/git/blobs/#get-a-blob\n    * @param {string} sha - the sha of the blob to fetch\n    * @param {Requestable.callback} cb - will receive the blob from the API\n    * @return {Promise} - the promise for the http request\n    */\n   getBlob(sha, cb) {\n      return this._request('GET', `/repos/${this.__fullname}/git/blobs/${sha}`, null, cb, 'raw');\n   }\n\n   /**\n    * Get a single branch\n    * @see https://developer.github.com/v3/repos/branches/#get-branch\n    * @param {string} branch - the name of the branch to fetch\n    * @param {Requestable.callback} cb - will receive the branch from the API\n    * @returns {Promise} - the promise for the http request\n    */\n   getBranch(branch, cb) {\n      return this._request('GET', `/repos/${this.__fullname}/branches/${branch}`, null, cb);\n   }\n\n   /**\n    * Get a commit from the repository\n    * @see https://developer.github.com/v3/repos/commits/#get-a-single-commit\n    * @param {string} sha - the sha for the commit to fetch\n    * @param {Requestable.callback} cb - will receive the commit data\n    * @return {Promise} - the promise for the http request\n    */\n   getCommit(sha, cb) {\n      return this._request('GET', `/repos/${this.__fullname}/git/commits/${sha}`, null, cb);\n   }\n\n   /**\n    * List the commits on a repository, optionally filtering by path, author or time range\n    * @see https://developer.github.com/v3/repos/commits/#list-commits-on-a-repository\n    * @param {Object} [options] - the filtering options for commits\n    * @param {string} [options.sha] - the SHA or branch to start from\n    * @param {string} [options.path] - the path to search on\n    * @param {string} [options.author] - the commit author\n    * @param {(Date|string)} [options.since] - only commits after this date will be returned\n    * @param {(Date|string)} [options.until] - only commits before this date will be returned\n    * @param {Requestable.callback} cb - will receive the list of commits found matching the criteria\n    * @return {Promise} - the promise for the http request\n    */\n   listCommits(options, cb) {\n      options = options || {};\n\n      options.since = this._dateToISO(options.since);\n      options.until = this._dateToISO(options.until);\n\n      return this._request('GET', `/repos/${this.__fullname}/commits`, options, cb);\n   }\n\n    /**\n     * Gets a single commit information for a repository\n     * @see https://developer.github.com/v3/repos/commits/#get-a-single-commit\n     * @param {string} ref - the reference for the commit-ish\n     * @param {Requestable.callback} cb - will receive the commit information\n     * @return {Promise} - the promise for the http request\n     */\n   getSingleCommit(ref, cb) {\n      ref = ref || '';\n      return this._request('GET', `/repos/${this.__fullname}/commits/${ref}`, null, cb);\n   }\n\n   /**\n    * Get tha sha for a particular object in the repository. This is a convenience function\n    * @see https://developer.github.com/v3/repos/contents/#get-contents\n    * @param {string} [branch] - the branch to look in, or the repository's default branch if omitted\n    * @param {string} path - the path of the file or directory\n    * @param {Requestable.callback} cb - will receive a description of the requested object, including a `SHA` property\n    * @return {Promise} - the promise for the http request\n    */\n   getSha(branch, path, cb) {\n      branch = branch ? `?ref=${branch}` : '';\n      return this._request('GET', `/repos/${this.__fullname}/contents/${path}${branch}`, null, cb);\n   }\n\n   /**\n    * List the commit statuses for a particular sha, branch, or tag\n    * @see https://developer.github.com/v3/repos/statuses/#list-statuses-for-a-specific-ref\n    * @param {string} sha - the sha, branch, or tag to get statuses for\n    * @param {Requestable.callback} cb - will receive the list of statuses\n    * @return {Promise} - the promise for the http request\n    */\n   listStatuses(sha, cb) {\n      return this._request('GET', `/repos/${this.__fullname}/commits/${sha}/statuses`, null, cb);\n   }\n\n   /**\n    * Get a description of a git tree\n    * @see https://developer.github.com/v3/git/trees/#get-a-tree\n    * @param {string} treeSHA - the SHA of the tree to fetch\n    * @param {Requestable.callback} cb - will receive the callback data\n    * @return {Promise} - the promise for the http request\n    */\n   getTree(treeSHA, cb) {\n      return this._request('GET', `/repos/${this.__fullname}/git/trees/${treeSHA}`, null, cb);\n   }\n\n   /**\n    * Create a blob\n    * @see https://developer.github.com/v3/git/blobs/#create-a-blob\n    * @param {(string|Buffer|Blob)} content - the content to add to the repository\n    * @param {Requestable.callback} cb - will receive the details of the created blob\n    * @return {Promise} - the promise for the http request\n    */\n   createBlob(content, cb) {\n      let postBody = this._getContentObject(content);\n\n      log('sending content', postBody);\n      return this._request('POST', `/repos/${this.__fullname}/git/blobs`, postBody, cb);\n   }\n\n   /**\n    * Get the object that represents the provided content\n    * @param {string|Buffer|Blob} content - the content to send to the server\n    * @return {Object} the representation of `content` for the GitHub API\n    */\n   _getContentObject(content) {\n      if (typeof content === 'string') {\n         log('contet is a string');\n         return {\n            content: Utf8.encode(content),\n            encoding: 'utf-8',\n         };\n\n      } else if (typeof Buffer !== 'undefined' && content instanceof Buffer) {\n         log('We appear to be in Node');\n         return {\n            content: content.toString('base64'),\n            encoding: 'base64',\n         };\n\n      } else if (typeof Blob !== 'undefined' && content instanceof Blob) {\n         log('We appear to be in the browser');\n         return {\n            content: Base64.encode(content),\n            encoding: 'base64',\n         };\n\n      } else { // eslint-disable-line\n         log(`Not sure what this content is: ${typeof content}, ${JSON.stringify(content)}`);\n         throw new Error('Unknown content passed to postBlob. Must be string or Buffer (node) or Blob (web)');\n      }\n   }\n\n   /**\n    * Update a tree in Git\n    * @see https://developer.github.com/v3/git/trees/#create-a-tree\n    * @param {string} baseTreeSHA - the SHA of the tree to update\n    * @param {string} path - the path for the new file\n    * @param {string} blobSHA - the SHA for the blob to put at `path`\n    * @param {Requestable.callback} cb - will receive the new tree that is created\n    * @return {Promise} - the promise for the http request\n    * @deprecated use {@link Repository#createTree} instead\n    */\n   updateTree(baseTreeSHA, path, blobSHA, cb) {\n      let newTree = {\n         base_tree: baseTreeSHA, // eslint-disable-line\n         tree: [{\n            path: path,\n            sha: blobSHA,\n            mode: '100644',\n            type: 'blob',\n         }],\n      };\n\n      return this._request('POST', `/repos/${this.__fullname}/git/trees`, newTree, cb);\n   }\n\n   /**\n    * Create a new tree in git\n    * @see https://developer.github.com/v3/git/trees/#create-a-tree\n    * @param {Object} tree - the tree to create\n    * @param {string} baseSHA - the root sha of the tree\n    * @param {Requestable.callback} cb - will receive the new tree that is created\n    * @return {Promise} - the promise for the http request\n    */\n   createTree(tree, baseSHA, cb) {\n      return this._request('POST', `/repos/${this.__fullname}/git/trees`, {\n         tree,\n         base_tree: baseSHA, // eslint-disable-line camelcase\n      }, cb);\n   }\n\n   /**\n    * Add a commit to the repository\n    * @see https://developer.github.com/v3/git/commits/#create-a-commit\n    * @param {string} parent - the SHA of the parent commit\n    * @param {string} tree - the SHA of the tree for this commit\n    * @param {string} message - the commit message\n    * @param {Requestable.callback} cb - will receive the commit that is created\n    * @return {Promise} - the promise for the http request\n    */\n   commit(parent, tree, message, cb) {\n      let data = {\n         message,\n         tree,\n         parents: [parent],\n      };\n\n      return this._request('POST', `/repos/${this.__fullname}/git/commits`, data, cb)\n         .then((response) => {\n            this.__currentTree.sha = response.data.sha; // Update latest commit\n            return response;\n         });\n   }\n\n   /**\n    * Update a ref\n    * @see https://developer.github.com/v3/git/refs/#update-a-reference\n    * @param {string} ref - the ref to update\n    * @param {string} commitSHA - the SHA to point the reference to\n    * @param {boolean} force - indicates whether to force or ensure a fast-forward update\n    * @param {Requestable.callback} cb - will receive the updated ref back\n    * @return {Promise} - the promise for the http request\n    */\n   updateHead(ref, commitSHA, force, cb) {\n      return this._request('PATCH', `/repos/${this.__fullname}/git/refs/${ref}`, {\n         sha: commitSHA,\n         force: force,\n      }, cb);\n   }\n\n   /**\n    * Update commit status\n    * @see https://developer.github.com/v3/repos/statuses/\n    * @param {string} commitSHA - the SHA of the commit that should be updated\n    * @param {object} options - Commit status parameters\n    * @param {string} options.state - The state of the status. Can be one of: pending, success, error, or failure.\n    * @param {string} [options.target_url] - The target URL to associate with this status.\n    * @param {string} [options.description] - A short description of the status.\n    * @param {string} [options.context] - A string label to differentiate this status among CI systems.\n    * @param {Requestable.callback} cb - will receive the updated commit back\n    * @return {Promise} - the promise for the http request\n    */\n   updateStatus(commitSHA, options, cb) {\n      return this._request('POST', `/repos/${this.__fullname}/statuses/${commitSHA}`, options, cb);\n   }\n\n   /**\n    * Update repository information\n    * @see https://developer.github.com/v3/repos/#edit\n    * @param {object} options - New parameters that will be set to the repository\n    * @param {string} options.name - Name of the repository\n    * @param {string} [options.description] - A short description of the repository\n    * @param {string} [options.homepage] - A URL with more information about the repository\n    * @param {boolean} [options.private] - Either true to make the repository private, or false to make it public.\n    * @param {boolean} [options.has_issues] - Either true to enable issues for this repository, false to disable them.\n    * @param {boolean} [options.has_wiki] - Either true to enable the wiki for this repository, false to disable it.\n    * @param {boolean} [options.has_downloads] - Either true to enable downloads, false to disable them.\n    * @param {string} [options.default_branch] - Updates the default branch for this repository.\n    * @param {Requestable.callback} cb - will receive the updated repository back\n    * @return {Promise} - the promise for the http request\n    */\n   updateRepository(options, cb) {\n      return this._request('PATCH', `/repos/${this.__fullname}`, options, cb);\n   }\n\n  /**\n    * Get information about the repository\n    * @see https://developer.github.com/v3/repos/#get\n    * @param {Requestable.callback} cb - will receive the information about the repository\n    * @return {Promise} - the promise for the http request\n    */\n   getDetails(cb) {\n      return this._request('GET', `/repos/${this.__fullname}`, null, cb);\n   }\n\n   /**\n    * List the contributors to the repository\n    * @see https://developer.github.com/v3/repos/#list-contributors\n    * @param {Requestable.callback} cb - will receive the list of contributors\n    * @return {Promise} - the promise for the http request\n    */\n   getContributors(cb) {\n      return this._request('GET', `/repos/${this.__fullname}/contributors`, null, cb);\n   }\n\n   /**\n    * List the contributor stats to the repository\n    * @see https://developer.github.com/v3/repos/#list-contributors\n    * @param {Requestable.callback} cb - will receive the list of contributors\n    * @return {Promise} - the promise for the http request\n    */\n   getContributorStats(cb) {\n      return this._request('GET', `/repos/${this.__fullname}/stats/contributors`, null, cb);\n   }\n\n   /**\n    * List the users who are collaborators on the repository. The currently authenticated user must have\n    * push access to use this method\n    * @see https://developer.github.com/v3/repos/collaborators/#list-collaborators\n    * @param {Requestable.callback} cb - will receive the list of collaborators\n    * @return {Promise} - the promise for the http request\n    */\n   getCollaborators(cb) {\n      return this._request('GET', `/repos/${this.__fullname}/collaborators`, null, cb);\n   }\n\n   /**\n    * Check if a user is a collaborator on the repository\n    * @see https://developer.github.com/v3/repos/collaborators/#check-if-a-user-is-a-collaborator\n    * @param {string} username - the user to check\n    * @param {Requestable.callback} cb - will receive true if the user is a collaborator and false if they are not\n    * @return {Promise} - the promise for the http request {Boolean} [description]\n    */\n   isCollaborator(username, cb) {\n      return this._request('GET', `/repos/${this.__fullname}/collaborators/${username}`, null, cb);\n   }\n\n   /**\n    * Get the contents of a repository\n    * @see https://developer.github.com/v3/repos/contents/#get-contents\n    * @param {string} ref - the ref to check\n    * @param {string} path - the path containing the content to fetch\n    * @param {boolean} raw - `true` if the results should be returned raw instead of GitHub's normalized format\n    * @param {Requestable.callback} cb - will receive the fetched data\n    * @return {Promise} - the promise for the http request\n    */\n   getContents(ref, path, raw, cb) {\n      path = path ? `${encodeURI(path)}` : '';\n      return this._request('GET', `/repos/${this.__fullname}/contents/${path}`, {\n         ref,\n      }, cb, raw);\n   }\n\n   /**\n    * Get the README of a repository\n    * @see https://developer.github.com/v3/repos/contents/#get-the-readme\n    * @param {string} ref - the ref to check\n    * @param {boolean} raw - `true` if the results should be returned raw instead of GitHub's normalized format\n    * @param {Requestable.callback} cb - will receive the fetched data\n    * @return {Promise} - the promise for the http request\n    */\n   getReadme(ref, raw, cb) {\n      return this._request('GET', `/repos/${this.__fullname}/readme`, {\n         ref,\n      }, cb, raw);\n   }\n\n   /**\n    * Fork a repository\n    * @see https://developer.github.com/v3/repos/forks/#create-a-fork\n    * @param {Requestable.callback} cb - will receive the information about the newly created fork\n    * @return {Promise} - the promise for the http request\n    */\n   fork(cb) {\n      return this._request('POST', `/repos/${this.__fullname}/forks`, null, cb);\n   }\n\n   /**\n    * List a repository's forks\n    * @see https://developer.github.com/v3/repos/forks/#list-forks\n    * @param {Requestable.callback} cb - will receive the list of repositories forked from this one\n    * @return {Promise} - the promise for the http request\n    */\n   listForks(cb) {\n      return this._request('GET', `/repos/${this.__fullname}/forks`, null, cb);\n   }\n\n   /**\n    * Create a new branch from an existing branch.\n    * @param {string} [oldBranch=master] - the name of the existing branch\n    * @param {string} newBranch - the name of the new branch\n    * @param {Requestable.callback} cb - will receive the commit data for the head of the new branch\n    * @return {Promise} - the promise for the http request\n    */\n   createBranch(oldBranch, newBranch, cb) {\n      if (typeof newBranch === 'function') {\n         cb = newBranch;\n         newBranch = oldBranch;\n         oldBranch = 'master';\n      }\n\n      return this.getRef(`heads/${oldBranch}`)\n         .then((response) => {\n            let sha = response.data.object.sha;\n            return this.createRef({\n               sha,\n               ref: `refs/heads/${newBranch}`,\n            }, cb);\n         });\n   }\n\n   /**\n    * Create a new pull request\n    * @see https://developer.github.com/v3/pulls/#create-a-pull-request\n    * @param {Object} options - the pull request description\n    * @param {Requestable.callback} cb - will receive the new pull request\n    * @return {Promise} - the promise for the http request\n    */\n   createPullRequest(options, cb) {\n      return this._request('POST', `/repos/${this.__fullname}/pulls`, options, cb);\n   }\n\n   /**\n    * Update a pull request\n    * @see https://developer.github.com/v3/pulls/#update-a-pull-request\n    * @param {number|string} number - the number of the pull request to update\n    * @param {Object} options - the pull request description\n    * @param {Requestable.callback} [cb] - will receive the pull request information\n    * @return {Promise} - the promise for the http request\n    */\n   updatePullRequest(number, options, cb) {\n      return this._request('PATCH', `/repos/${this.__fullname}/pulls/${number}`, options, cb);\n   }\n\n   /**\n    * List the hooks for the repository\n    * @see https://developer.github.com/v3/repos/hooks/#list-hooks\n    * @param {Requestable.callback} cb - will receive the list of hooks\n    * @return {Promise} - the promise for the http request\n    */\n   listHooks(cb) {\n      return this._request('GET', `/repos/${this.__fullname}/hooks`, null, cb);\n   }\n\n   /**\n    * Get a hook for the repository\n    * @see https://developer.github.com/v3/repos/hooks/#get-single-hook\n    * @param {number} id - the id of the webook\n    * @param {Requestable.callback} cb - will receive the details of the webook\n    * @return {Promise} - the promise for the http request\n    */\n   getHook(id, cb) {\n      return this._request('GET', `/repos/${this.__fullname}/hooks/${id}`, null, cb);\n   }\n\n   /**\n    * Add a new hook to the repository\n    * @see https://developer.github.com/v3/repos/hooks/#create-a-hook\n    * @param {Object} options - the configuration describing the new hook\n    * @param {Requestable.callback} cb - will receive the new webhook\n    * @return {Promise} - the promise for the http request\n    */\n   createHook(options, cb) {\n      return this._request('POST', `/repos/${this.__fullname}/hooks`, options, cb);\n   }\n\n   /**\n    * Edit an existing webhook\n    * @see https://developer.github.com/v3/repos/hooks/#edit-a-hook\n    * @param {number} id - the id of the webhook\n    * @param {Object} options - the new description of the webhook\n    * @param {Requestable.callback} cb - will receive the updated webhook\n    * @return {Promise} - the promise for the http request\n    */\n   updateHook(id, options, cb) {\n      return this._request('PATCH', `/repos/${this.__fullname}/hooks/${id}`, options, cb);\n   }\n\n   /**\n    * Delete a webhook\n    * @see https://developer.github.com/v3/repos/hooks/#delete-a-hook\n    * @param {number} id - the id of the webhook to be deleted\n    * @param {Requestable.callback} cb - will receive true if the call is successful\n    * @return {Promise} - the promise for the http request\n    */\n   deleteHook(id, cb) {\n      return this._request('DELETE', `/repos/${this.__fullname}/hooks/${id}`, null, cb);\n   }\n\n   /**\n    * List the deploy keys for the repository\n    * @see https://developer.github.com/v3/repos/keys/#list-deploy-keys\n    * @param {Requestable.callback} cb - will receive the list of deploy keys\n    * @return {Promise} - the promise for the http request\n    */\n   listKeys(cb) {\n      return this._request('GET', `/repos/${this.__fullname}/keys`, null, cb);\n   }\n\n   /**\n    * Get a deploy key for the repository\n    * @see https://developer.github.com/v3/repos/keys/#get-a-deploy-key\n    * @param {number} id - the id of the deploy key\n    * @param {Requestable.callback} cb - will receive the details of the deploy key\n    * @return {Promise} - the promise for the http request\n    */\n   getKey(id, cb) {\n      return this._request('GET', `/repos/${this.__fullname}/keys/${id}`, null, cb);\n   }\n\n   /**\n    * Add a new deploy key to the repository\n    * @see https://developer.github.com/v3/repos/keys/#add-a-new-deploy-key\n    * @param {Object} options - the configuration describing the new deploy key\n    * @param {Requestable.callback} cb - will receive the new deploy key\n    * @return {Promise} - the promise for the http request\n    */\n   createKey(options, cb) {\n      return this._request('POST', `/repos/${this.__fullname}/keys`, options, cb);\n   }\n\n   /**\n    * Delete a deploy key\n    * @see https://developer.github.com/v3/repos/keys/#remove-a-deploy-key\n    * @param {number} id - the id of the deploy key to be deleted\n    * @param {Requestable.callback} cb - will receive true if the call is successful\n    * @return {Promise} - the promise for the http request\n    */\n   deleteKey(id, cb) {\n      return this._request('DELETE', `/repos/${this.__fullname}/keys/${id}`, null, cb);\n   }\n\n   /**\n    * Delete a file from a branch\n    * @see https://developer.github.com/v3/repos/contents/#delete-a-file\n    * @param {string} branch - the branch to delete from, or the default branch if not specified\n    * @param {string} path - the path of the file to remove\n    * @param {Requestable.callback} cb - will receive the commit in which the delete occurred\n    * @return {Promise} - the promise for the http request\n    */\n   deleteFile(branch, path, cb) {\n      return this.getSha(branch, path)\n         .then((response) => {\n            const deleteCommit = {\n               message: `Delete the file at '${path}'`,\n               sha: response.data.sha,\n               branch,\n            };\n            return this._request('DELETE', `/repos/${this.__fullname}/contents/${path}`, deleteCommit, cb);\n         });\n   }\n\n   /**\n    * Change all references in a repo from oldPath to new_path\n    * @param {string} branch - the branch to carry out the reference change, or the default branch if not specified\n    * @param {string} oldPath - original path\n    * @param {string} newPath - new reference path\n    * @param {Requestable.callback} cb - will receive the commit in which the move occurred\n    * @return {Promise} - the promise for the http request\n    */\n   move(branch, oldPath, newPath, cb) {\n      let oldSha;\n      return this.getRef(`heads/${branch}`)\n         .then(({data: {object}}) => this.getTree(`${object.sha}?recursive=true`))\n         .then(({data: {tree, sha}}) => {\n            oldSha = sha;\n            let newTree = tree.map((ref) => {\n               if (ref.path === oldPath) {\n                  ref.path = newPath;\n               }\n               if (ref.type === 'tree') {\n                  delete ref.sha;\n               }\n               return ref;\n            });\n            return this.createTree(newTree);\n         })\n         .then(({data: tree}) => this.commit(oldSha, tree.sha, `Renamed '${oldPath}' to '${newPath}'`))\n         .then(({data: commit}) => this.updateHead(`heads/${branch}`, commit.sha, true, cb));\n   }\n\n   /**\n    * Write a file to the repository\n    * @see https://developer.github.com/v3/repos/contents/#update-a-file\n    * @param {string} branch - the name of the branch\n    * @param {string} path - the path for the file\n    * @param {string} content - the contents of the file\n    * @param {string} message - the commit message\n    * @param {Object} [options] - commit options\n    * @param {Object} [options.author] - the author of the commit\n    * @param {Object} [options.commiter] - the committer\n    * @param {boolean} [options.encode] - true if the content should be base64 encoded\n    * @param {Requestable.callback} cb - will receive the new commit\n    * @return {Promise} - the promise for the http request\n    */\n   writeFile(branch, path, content, message, options, cb) {\n      if (typeof options === 'function') {\n         cb = options;\n         options = {};\n      }\n      let filePath = path ? encodeURI(path) : '';\n      let shouldEncode = options.encode !== false;\n      let commit = {\n         branch,\n         message,\n         author: options.author,\n         committer: options.committer,\n         content: shouldEncode ? Base64.encode(content) : content,\n      };\n\n      return this.getSha(branch, filePath)\n         .then((response) => {\n            commit.sha = response.data.sha;\n            return this._request('PUT', `/repos/${this.__fullname}/contents/${filePath}`, commit, cb);\n         }, () => {\n            return this._request('PUT', `/repos/${this.__fullname}/contents/${filePath}`, commit, cb);\n         });\n   }\n\n   /**\n    * Check if a repository is starred by you\n    * @see https://developer.github.com/v3/activity/starring/#check-if-you-are-starring-a-repository\n    * @param {Requestable.callback} cb - will receive true if the repository is starred and false if the repository\n    *                                  is not starred\n    * @return {Promise} - the promise for the http request {Boolean} [description]\n    */\n   isStarred(cb) {\n      return this._request204or404(`/user/starred/${this.__fullname}`, null, cb);\n   }\n\n   /**\n    * Star a repository\n    * @see https://developer.github.com/v3/activity/starring/#star-a-repository\n    * @param {Requestable.callback} cb - will receive true if the repository is starred\n    * @return {Promise} - the promise for the http request\n    */\n   star(cb) {\n      return this._request('PUT', `/user/starred/${this.__fullname}`, null, cb);\n   }\n\n   /**\n    * Unstar a repository\n    * @see https://developer.github.com/v3/activity/starring/#unstar-a-repository\n    * @param {Requestable.callback} cb - will receive true if the repository is unstarred\n    * @return {Promise} - the promise for the http request\n    */\n   unstar(cb) {\n      return this._request('DELETE', `/user/starred/${this.__fullname}`, null, cb);\n   }\n\n   /**\n    * Create a new release\n    * @see https://developer.github.com/v3/repos/releases/#create-a-release\n    * @param {Object} options - the description of the release\n    * @param {Requestable.callback} cb - will receive the newly created release\n    * @return {Promise} - the promise for the http request\n    */\n   createRelease(options, cb) {\n      return this._request('POST', `/repos/${this.__fullname}/releases`, options, cb);\n   }\n\n   /**\n    * Edit a release\n    * @see https://developer.github.com/v3/repos/releases/#edit-a-release\n    * @param {string} id - the id of the release\n    * @param {Object} options - the description of the release\n    * @param {Requestable.callback} cb - will receive the modified release\n    * @return {Promise} - the promise for the http request\n    */\n   updateRelease(id, options, cb) {\n      return this._request('PATCH', `/repos/${this.__fullname}/releases/${id}`, options, cb);\n   }\n\n   /**\n    * Get information about all releases\n    * @see https://developer.github.com/v3/repos/releases/#list-releases-for-a-repository\n    * @param {Requestable.callback} cb - will receive the release information\n    * @return {Promise} - the promise for the http request\n    */\n   listReleases(cb) {\n      return this._request('GET', `/repos/${this.__fullname}/releases`, null, cb);\n   }\n\n   /**\n    * Get information about a release\n    * @see https://developer.github.com/v3/repos/releases/#get-a-single-release\n    * @param {string} id - the id of the release\n    * @param {Requestable.callback} cb - will receive the release information\n    * @return {Promise} - the promise for the http request\n    */\n   getRelease(id, cb) {\n      return this._request('GET', `/repos/${this.__fullname}/releases/${id}`, null, cb);\n   }\n\n   /**\n    * Delete a release\n    * @see https://developer.github.com/v3/repos/releases/#delete-a-release\n    * @param {string} id - the release to be deleted\n    * @param {Requestable.callback} cb - will receive true if the operation is successful\n    * @return {Promise} - the promise for the http request\n    */\n   deleteRelease(id, cb) {\n      return this._request('DELETE', `/repos/${this.__fullname}/releases/${id}`, null, cb);\n   }\n\n   /**\n    * Merge a pull request\n    * @see https://developer.github.com/v3/pulls/#merge-a-pull-request-merge-button\n    * @param {number|string} number - the number of the pull request to merge\n    * @param {Object} options - the merge options for the pull request\n    * @param {Requestable.callback} [cb] - will receive the merge information if the operation is successful\n    * @return {Promise} - the promise for the http request\n    */\n   mergePullRequest(number, options, cb) {\n      return this._request('PUT', `/repos/${this.__fullname}/pulls/${number}/merge`, options, cb);\n   }\n\n   /**\n    * Get information about all projects\n    * @see https://developer.github.com/v3/projects/#list-repository-projects\n    * @param {Requestable.callback} [cb] - will receive the list of projects\n    * @return {Promise} - the promise for the http request\n    */\n   listProjects(cb) {\n      return this._requestAllPages(`/repos/${this.__fullname}/projects`, {AcceptHeader: 'inertia-preview'}, cb);\n   }\n\n   /**\n    * Create a new project\n    * @see https://developer.github.com/v3/projects/#create-a-repository-project\n    * @param {Object} options - the description of the project\n    * @param {Requestable.callback} cb - will receive the newly created project\n    * @return {Promise} - the promise for the http request\n    */\n   createProject(options, cb) {\n      options = options || {};\n      options.AcceptHeader = 'inertia-preview';\n      return this._request('POST', `/repos/${this.__fullname}/projects`, options, cb);\n   }\n\n}\n\nmodule.exports = Repository;\n"]} +//# sourceMappingURL=Repository.js.map diff --git a/dist/components/Repository.js.map b/dist/components/Repository.js.map new file mode 100644 index 00000000..8f5f146b --- /dev/null +++ b/dist/components/Repository.js.map @@ -0,0 +1 @@ +{"version":3,"names":[],"mappings":"","sources":["Repository.js"],"sourcesContent":["/**\n * @file\n * @copyright 2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n * Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\nimport Utf8 from 'utf8';\nimport {\n Base64,\n} from 'js-base64';\nimport debug from 'debug';\nconst log = debug('github:repository');\n\n/**\n * Respository encapsulates the functionality to create, query, and modify files.\n */\nclass Repository extends Requestable {\n /**\n * Create a Repository.\n * @param {string} fullname - the full name of the repository\n * @param {Requestable.auth} [auth] - information required to authenticate to Github\n * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n */\n constructor(fullname, auth, apiBase) {\n super(auth, apiBase);\n this.__fullname = fullname;\n this.__currentTree = {\n branch: null,\n sha: null,\n };\n }\n\n /**\n * Get a reference\n * @see https://developer.github.com/v3/git/refs/#get-a-reference\n * @param {string} ref - the reference to get\n * @param {Requestable.callback} [cb] - will receive the reference's refSpec or a list of refSpecs that match `ref`\n * @return {Promise} - the promise for the http request\n */\n getRef(ref, cb) {\n return this._request('GET', `/repos/${this.__fullname}/git/refs/${ref}`, null, cb);\n }\n\n /**\n * Create a reference\n * @see https://developer.github.com/v3/git/refs/#create-a-reference\n * @param {Object} options - the object describing the ref\n * @param {Requestable.callback} [cb] - will receive the ref\n * @return {Promise} - the promise for the http request\n */\n createRef(options, cb) {\n return this._request('POST', `/repos/${this.__fullname}/git/refs`, options, cb);\n }\n\n /**\n * Delete a reference\n * @see https://developer.github.com/v3/git/refs/#delete-a-reference\n * @param {string} ref - the name of the ref to delte\n * @param {Requestable.callback} [cb] - will receive true if the request is successful\n * @return {Promise} - the promise for the http request\n */\n deleteRef(ref, cb) {\n return this._request('DELETE', `/repos/${this.__fullname}/git/refs/${ref}`, null, cb);\n }\n\n /**\n * Delete a repository\n * @see https://developer.github.com/v3/repos/#delete-a-repository\n * @param {Requestable.callback} [cb] - will receive true if the request is successful\n * @return {Promise} - the promise for the http request\n */\n deleteRepo(cb) {\n return this._request('DELETE', `/repos/${this.__fullname}`, null, cb);\n }\n\n /**\n * List the tags on a repository\n * @see https://developer.github.com/v3/repos/#list-tags\n * @param {Requestable.callback} [cb] - will receive the tag data\n * @return {Promise} - the promise for the http request\n */\n listTags(cb) {\n return this._request('GET', `/repos/${this.__fullname}/tags`, null, cb);\n }\n\n /**\n * List the open pull requests on the repository\n * @see https://developer.github.com/v3/pulls/#list-pull-requests\n * @param {Object} options - options to filter the search\n * @param {Requestable.callback} [cb] - will receive the list of PRs\n * @return {Promise} - the promise for the http request\n */\n listPullRequests(options, cb) {\n options = options || {};\n return this._request('GET', `/repos/${this.__fullname}/pulls`, options, cb);\n }\n\n /**\n * Get information about a specific pull request\n * @see https://developer.github.com/v3/pulls/#get-a-single-pull-request\n * @param {number} number - the PR you wish to fetch\n * @param {Requestable.callback} [cb] - will receive the PR from the API\n * @return {Promise} - the promise for the http request\n */\n getPullRequest(number, cb) {\n return this._request('GET', `/repos/${this.__fullname}/pulls/${number}`, null, cb);\n }\n\n /**\n * List the files of a specific pull request\n * @see https://developer.github.com/v3/pulls/#list-pull-requests-files\n * @param {number|string} number - the PR you wish to fetch\n * @param {Requestable.callback} [cb] - will receive the list of files from the API\n * @return {Promise} - the promise for the http request\n */\n listPullRequestFiles(number, cb) {\n return this._request('GET', `/repos/${this.__fullname}/pulls/${number}/files`, null, cb);\n }\n\n /**\n * Compare two branches/commits/repositories\n * @see https://developer.github.com/v3/repos/commits/#compare-two-commits\n * @param {string} base - the base commit\n * @param {string} head - the head commit\n * @param {Requestable.callback} cb - will receive the comparison\n * @return {Promise} - the promise for the http request\n */\n compareBranches(base, head, cb) {\n return this._request('GET', `/repos/${this.__fullname}/compare/${base}...${head}`, null, cb);\n }\n\n /**\n * List all the branches for the repository\n * @see https://developer.github.com/v3/repos/#list-branches\n * @param {Requestable.callback} cb - will receive the list of branches\n * @return {Promise} - the promise for the http request\n */\n listBranches(cb) {\n return this._request('GET', `/repos/${this.__fullname}/branches`, null, cb);\n }\n\n /**\n * Get a raw blob from the repository\n * @see https://developer.github.com/v3/git/blobs/#get-a-blob\n * @param {string} sha - the sha of the blob to fetch\n * @param {Requestable.callback} cb - will receive the blob from the API\n * @return {Promise} - the promise for the http request\n */\n getBlob(sha, cb) {\n return this._request('GET', `/repos/${this.__fullname}/git/blobs/${sha}`, null, cb, 'raw');\n }\n\n /**\n * Get a single branch\n * @see https://developer.github.com/v3/repos/branches/#get-branch\n * @param {string} branch - the name of the branch to fetch\n * @param {Requestable.callback} cb - will receive the branch from the API\n * @returns {Promise} - the promise for the http request\n */\n getBranch(branch, cb) {\n return this._request('GET', `/repos/${this.__fullname}/branches/${branch}`, null, cb);\n }\n\n /**\n * Get a commit from the repository\n * @see https://developer.github.com/v3/repos/commits/#get-a-single-commit\n * @param {string} sha - the sha for the commit to fetch\n * @param {Requestable.callback} cb - will receive the commit data\n * @return {Promise} - the promise for the http request\n */\n getCommit(sha, cb) {\n return this._request('GET', `/repos/${this.__fullname}/git/commits/${sha}`, null, cb);\n }\n\n /**\n * List the commits on a repository, optionally filtering by path, author or time range\n * @see https://developer.github.com/v3/repos/commits/#list-commits-on-a-repository\n * @param {Object} [options] - the filtering options for commits\n * @param {string} [options.sha] - the SHA or branch to start from\n * @param {string} [options.path] - the path to search on\n * @param {string} [options.author] - the commit author\n * @param {(Date|string)} [options.since] - only commits after this date will be returned\n * @param {(Date|string)} [options.until] - only commits before this date will be returned\n * @param {Requestable.callback} cb - will receive the list of commits found matching the criteria\n * @return {Promise} - the promise for the http request\n */\n listCommits(options, cb) {\n options = options || {};\n\n options.since = this._dateToISO(options.since);\n options.until = this._dateToISO(options.until);\n\n return this._request('GET', `/repos/${this.__fullname}/commits`, options, cb);\n }\n\n /**\n * Gets a single commit information for a repository\n * @see https://developer.github.com/v3/repos/commits/#get-a-single-commit\n * @param {string} ref - the reference for the commit-ish\n * @param {Requestable.callback} cb - will receive the commit information\n * @return {Promise} - the promise for the http request\n */\n getSingleCommit(ref, cb) {\n ref = ref || '';\n return this._request('GET', `/repos/${this.__fullname}/commits/${ref}`, null, cb);\n }\n\n /**\n * Get tha sha for a particular object in the repository. This is a convenience function\n * @see https://developer.github.com/v3/repos/contents/#get-contents\n * @param {string} [branch] - the branch to look in, or the repository's default branch if omitted\n * @param {string} path - the path of the file or directory\n * @param {Requestable.callback} cb - will receive a description of the requested object, including a `SHA` property\n * @return {Promise} - the promise for the http request\n */\n getSha(branch, path, cb) {\n branch = branch ? `?ref=${branch}` : '';\n return this._request('GET', `/repos/${this.__fullname}/contents/${path}${branch}`, null, cb);\n }\n\n /**\n * List the commit statuses for a particular sha, branch, or tag\n * @see https://developer.github.com/v3/repos/statuses/#list-statuses-for-a-specific-ref\n * @param {string} sha - the sha, branch, or tag to get statuses for\n * @param {Requestable.callback} cb - will receive the list of statuses\n * @return {Promise} - the promise for the http request\n */\n listStatuses(sha, cb) {\n return this._request('GET', `/repos/${this.__fullname}/commits/${sha}/statuses`, null, cb);\n }\n\n /**\n * Get a description of a git tree\n * @see https://developer.github.com/v3/git/trees/#get-a-tree\n * @param {string} treeSHA - the SHA of the tree to fetch\n * @param {Requestable.callback} cb - will receive the callback data\n * @return {Promise} - the promise for the http request\n */\n getTree(treeSHA, cb) {\n return this._request('GET', `/repos/${this.__fullname}/git/trees/${treeSHA}`, null, cb);\n }\n\n /**\n * Create a blob\n * @see https://developer.github.com/v3/git/blobs/#create-a-blob\n * @param {(string|Buffer|Blob)} content - the content to add to the repository\n * @param {Requestable.callback} cb - will receive the details of the created blob\n * @return {Promise} - the promise for the http request\n */\n createBlob(content, cb) {\n let postBody = this._getContentObject(content);\n\n log('sending content', postBody);\n return this._request('POST', `/repos/${this.__fullname}/git/blobs`, postBody, cb);\n }\n\n /**\n * Get the object that represents the provided content\n * @param {string|Buffer|Blob} content - the content to send to the server\n * @return {Object} the representation of `content` for the GitHub API\n */\n _getContentObject(content) {\n if (typeof content === 'string') {\n log('contet is a string');\n return {\n content: Utf8.encode(content),\n encoding: 'utf-8',\n };\n\n } else if (typeof Buffer !== 'undefined' && content instanceof Buffer) {\n log('We appear to be in Node');\n return {\n content: content.toString('base64'),\n encoding: 'base64',\n };\n\n } else if (typeof Blob !== 'undefined' && content instanceof Blob) {\n log('We appear to be in the browser');\n return {\n content: Base64.encode(content),\n encoding: 'base64',\n };\n\n } else { // eslint-disable-line\n log(`Not sure what this content is: ${typeof content}, ${JSON.stringify(content)}`);\n throw new Error('Unknown content passed to postBlob. Must be string or Buffer (node) or Blob (web)');\n }\n }\n\n /**\n * Update a tree in Git\n * @see https://developer.github.com/v3/git/trees/#create-a-tree\n * @param {string} baseTreeSHA - the SHA of the tree to update\n * @param {string} path - the path for the new file\n * @param {string} blobSHA - the SHA for the blob to put at `path`\n * @param {Requestable.callback} cb - will receive the new tree that is created\n * @return {Promise} - the promise for the http request\n * @deprecated use {@link Repository#createTree} instead\n */\n updateTree(baseTreeSHA, path, blobSHA, cb) {\n let newTree = {\n base_tree: baseTreeSHA, // eslint-disable-line\n tree: [{\n path: path,\n sha: blobSHA,\n mode: '100644',\n type: 'blob',\n }],\n };\n\n return this._request('POST', `/repos/${this.__fullname}/git/trees`, newTree, cb);\n }\n\n /**\n * Create a new tree in git\n * @see https://developer.github.com/v3/git/trees/#create-a-tree\n * @param {Object} tree - the tree to create\n * @param {string} baseSHA - the root sha of the tree\n * @param {Requestable.callback} cb - will receive the new tree that is created\n * @return {Promise} - the promise for the http request\n */\n createTree(tree, baseSHA, cb) {\n return this._request('POST', `/repos/${this.__fullname}/git/trees`, {\n tree,\n base_tree: baseSHA, // eslint-disable-line camelcase\n }, cb);\n }\n\n /**\n * Add a commit to the repository\n * @see https://developer.github.com/v3/git/commits/#create-a-commit\n * @param {string} parent - the SHA of the parent commit\n * @param {string} tree - the SHA of the tree for this commit\n * @param {string} message - the commit message\n * @param {Requestable.callback} cb - will receive the commit that is created\n * @return {Promise} - the promise for the http request\n */\n commit(parent, tree, message, cb) {\n let data = {\n message,\n tree,\n parents: [parent],\n };\n\n return this._request('POST', `/repos/${this.__fullname}/git/commits`, data, cb)\n .then((response) => {\n this.__currentTree.sha = response.data.sha; // Update latest commit\n return response;\n });\n }\n\n /**\n * Update a ref\n * @see https://developer.github.com/v3/git/refs/#update-a-reference\n * @param {string} ref - the ref to update\n * @param {string} commitSHA - the SHA to point the reference to\n * @param {boolean} force - indicates whether to force or ensure a fast-forward update\n * @param {Requestable.callback} cb - will receive the updated ref back\n * @return {Promise} - the promise for the http request\n */\n updateHead(ref, commitSHA, force, cb) {\n return this._request('PATCH', `/repos/${this.__fullname}/git/refs/${ref}`, {\n sha: commitSHA,\n force: force,\n }, cb);\n }\n\n /**\n * Update commit status\n * @see https://developer.github.com/v3/repos/statuses/\n * @param {string} commitSHA - the SHA of the commit that should be updated\n * @param {object} options - Commit status parameters\n * @param {string} options.state - The state of the status. Can be one of: pending, success, error, or failure.\n * @param {string} [options.target_url] - The target URL to associate with this status.\n * @param {string} [options.description] - A short description of the status.\n * @param {string} [options.context] - A string label to differentiate this status among CI systems.\n * @param {Requestable.callback} cb - will receive the updated commit back\n * @return {Promise} - the promise for the http request\n */\n updateStatus(commitSHA, options, cb) {\n return this._request('POST', `/repos/${this.__fullname}/statuses/${commitSHA}`, options, cb);\n }\n\n /**\n * Update repository information\n * @see https://developer.github.com/v3/repos/#edit\n * @param {object} options - New parameters that will be set to the repository\n * @param {string} options.name - Name of the repository\n * @param {string} [options.description] - A short description of the repository\n * @param {string} [options.homepage] - A URL with more information about the repository\n * @param {boolean} [options.private] - Either true to make the repository private, or false to make it public.\n * @param {boolean} [options.has_issues] - Either true to enable issues for this repository, false to disable them.\n * @param {boolean} [options.has_wiki] - Either true to enable the wiki for this repository, false to disable it.\n * @param {boolean} [options.has_downloads] - Either true to enable downloads, false to disable them.\n * @param {string} [options.default_branch] - Updates the default branch for this repository.\n * @param {Requestable.callback} cb - will receive the updated repository back\n * @return {Promise} - the promise for the http request\n */\n updateRepository(options, cb) {\n return this._request('PATCH', `/repos/${this.__fullname}`, options, cb);\n }\n\n /**\n * Get information about the repository\n * @see https://developer.github.com/v3/repos/#get\n * @param {Requestable.callback} cb - will receive the information about the repository\n * @return {Promise} - the promise for the http request\n */\n getDetails(cb) {\n return this._request('GET', `/repos/${this.__fullname}`, null, cb);\n }\n\n /**\n * List the contributors to the repository\n * @see https://developer.github.com/v3/repos/#list-contributors\n * @param {Requestable.callback} cb - will receive the list of contributors\n * @return {Promise} - the promise for the http request\n */\n getContributors(cb) {\n return this._request('GET', `/repos/${this.__fullname}/contributors`, null, cb);\n }\n\n /**\n * List the contributor stats to the repository\n * @see https://developer.github.com/v3/repos/#list-contributors\n * @param {Requestable.callback} cb - will receive the list of contributors\n * @return {Promise} - the promise for the http request\n */\n getContributorStats(cb) {\n return this._request('GET', `/repos/${this.__fullname}/stats/contributors`, null, cb);\n }\n\n /**\n * List the users who are collaborators on the repository. The currently authenticated user must have\n * push access to use this method\n * @see https://developer.github.com/v3/repos/collaborators/#list-collaborators\n * @param {Requestable.callback} cb - will receive the list of collaborators\n * @return {Promise} - the promise for the http request\n */\n getCollaborators(cb) {\n return this._request('GET', `/repos/${this.__fullname}/collaborators`, null, cb);\n }\n\n /**\n * Check if a user is a collaborator on the repository\n * @see https://developer.github.com/v3/repos/collaborators/#check-if-a-user-is-a-collaborator\n * @param {string} username - the user to check\n * @param {Requestable.callback} cb - will receive true if the user is a collaborator and false if they are not\n * @return {Promise} - the promise for the http request {Boolean} [description]\n */\n isCollaborator(username, cb) {\n return this._request('GET', `/repos/${this.__fullname}/collaborators/${username}`, null, cb);\n }\n\n /**\n * Get the contents of a repository\n * @see https://developer.github.com/v3/repos/contents/#get-contents\n * @param {string} ref - the ref to check\n * @param {string} path - the path containing the content to fetch\n * @param {boolean} raw - `true` if the results should be returned raw instead of GitHub's normalized format\n * @param {Requestable.callback} cb - will receive the fetched data\n * @return {Promise} - the promise for the http request\n */\n getContents(ref, path, raw, cb) {\n path = path ? `${encodeURI(path)}` : '';\n return this._request('GET', `/repos/${this.__fullname}/contents/${path}`, {\n ref,\n }, cb, raw);\n }\n\n /**\n * Get the README of a repository\n * @see https://developer.github.com/v3/repos/contents/#get-the-readme\n * @param {string} ref - the ref to check\n * @param {boolean} raw - `true` if the results should be returned raw instead of GitHub's normalized format\n * @param {Requestable.callback} cb - will receive the fetched data\n * @return {Promise} - the promise for the http request\n */\n getReadme(ref, raw, cb) {\n return this._request('GET', `/repos/${this.__fullname}/readme`, {\n ref,\n }, cb, raw);\n }\n\n /**\n * Fork a repository\n * @see https://developer.github.com/v3/repos/forks/#create-a-fork\n * @param {Requestable.callback} cb - will receive the information about the newly created fork\n * @return {Promise} - the promise for the http request\n */\n fork(cb) {\n return this._request('POST', `/repos/${this.__fullname}/forks`, null, cb);\n }\n\n /**\n * List a repository's forks\n * @see https://developer.github.com/v3/repos/forks/#list-forks\n * @param {Requestable.callback} cb - will receive the list of repositories forked from this one\n * @return {Promise} - the promise for the http request\n */\n listForks(cb) {\n return this._request('GET', `/repos/${this.__fullname}/forks`, null, cb);\n }\n\n /**\n * Create a new branch from an existing branch.\n * @param {string} [oldBranch=master] - the name of the existing branch\n * @param {string} newBranch - the name of the new branch\n * @param {Requestable.callback} cb - will receive the commit data for the head of the new branch\n * @return {Promise} - the promise for the http request\n */\n createBranch(oldBranch, newBranch, cb) {\n if (typeof newBranch === 'function') {\n cb = newBranch;\n newBranch = oldBranch;\n oldBranch = 'master';\n }\n\n return this.getRef(`heads/${oldBranch}`)\n .then((response) => {\n let sha = response.data.object.sha;\n return this.createRef({\n sha,\n ref: `refs/heads/${newBranch}`,\n }, cb);\n });\n }\n\n /**\n * Create a new pull request\n * @see https://developer.github.com/v3/pulls/#create-a-pull-request\n * @param {Object} options - the pull request description\n * @param {Requestable.callback} cb - will receive the new pull request\n * @return {Promise} - the promise for the http request\n */\n createPullRequest(options, cb) {\n return this._request('POST', `/repos/${this.__fullname}/pulls`, options, cb);\n }\n\n /**\n * Update a pull request\n * @see https://developer.github.com/v3/pulls/#update-a-pull-request\n * @param {number|string} number - the number of the pull request to update\n * @param {Object} options - the pull request description\n * @param {Requestable.callback} [cb] - will receive the pull request information\n * @return {Promise} - the promise for the http request\n */\n updatePullRequest(number, options, cb) {\n return this._request('PATCH', `/repos/${this.__fullname}/pulls/${number}`, options, cb);\n }\n\n /**\n * List the hooks for the repository\n * @see https://developer.github.com/v3/repos/hooks/#list-hooks\n * @param {Requestable.callback} cb - will receive the list of hooks\n * @return {Promise} - the promise for the http request\n */\n listHooks(cb) {\n return this._request('GET', `/repos/${this.__fullname}/hooks`, null, cb);\n }\n\n /**\n * Get a hook for the repository\n * @see https://developer.github.com/v3/repos/hooks/#get-single-hook\n * @param {number} id - the id of the webook\n * @param {Requestable.callback} cb - will receive the details of the webook\n * @return {Promise} - the promise for the http request\n */\n getHook(id, cb) {\n return this._request('GET', `/repos/${this.__fullname}/hooks/${id}`, null, cb);\n }\n\n /**\n * Add a new hook to the repository\n * @see https://developer.github.com/v3/repos/hooks/#create-a-hook\n * @param {Object} options - the configuration describing the new hook\n * @param {Requestable.callback} cb - will receive the new webhook\n * @return {Promise} - the promise for the http request\n */\n createHook(options, cb) {\n return this._request('POST', `/repos/${this.__fullname}/hooks`, options, cb);\n }\n\n /**\n * Edit an existing webhook\n * @see https://developer.github.com/v3/repos/hooks/#edit-a-hook\n * @param {number} id - the id of the webhook\n * @param {Object} options - the new description of the webhook\n * @param {Requestable.callback} cb - will receive the updated webhook\n * @return {Promise} - the promise for the http request\n */\n updateHook(id, options, cb) {\n return this._request('PATCH', `/repos/${this.__fullname}/hooks/${id}`, options, cb);\n }\n\n /**\n * Delete a webhook\n * @see https://developer.github.com/v3/repos/hooks/#delete-a-hook\n * @param {number} id - the id of the webhook to be deleted\n * @param {Requestable.callback} cb - will receive true if the call is successful\n * @return {Promise} - the promise for the http request\n */\n deleteHook(id, cb) {\n return this._request('DELETE', `/repos/${this.__fullname}/hooks/${id}`, null, cb);\n }\n\n /**\n * List the deploy keys for the repository\n * @see https://developer.github.com/v3/repos/keys/#list-deploy-keys\n * @param {Requestable.callback} cb - will receive the list of deploy keys\n * @return {Promise} - the promise for the http request\n */\n listKeys(cb) {\n return this._request('GET', `/repos/${this.__fullname}/keys`, null, cb);\n }\n\n /**\n * Get a deploy key for the repository\n * @see https://developer.github.com/v3/repos/keys/#get-a-deploy-key\n * @param {number} id - the id of the deploy key\n * @param {Requestable.callback} cb - will receive the details of the deploy key\n * @return {Promise} - the promise for the http request\n */\n getKey(id, cb) {\n return this._request('GET', `/repos/${this.__fullname}/keys/${id}`, null, cb);\n }\n\n /**\n * Add a new deploy key to the repository\n * @see https://developer.github.com/v3/repos/keys/#add-a-new-deploy-key\n * @param {Object} options - the configuration describing the new deploy key\n * @param {Requestable.callback} cb - will receive the new deploy key\n * @return {Promise} - the promise for the http request\n */\n createKey(options, cb) {\n return this._request('POST', `/repos/${this.__fullname}/keys`, options, cb);\n }\n\n /**\n * Delete a deploy key\n * @see https://developer.github.com/v3/repos/keys/#remove-a-deploy-key\n * @param {number} id - the id of the deploy key to be deleted\n * @param {Requestable.callback} cb - will receive true if the call is successful\n * @return {Promise} - the promise for the http request\n */\n deleteKey(id, cb) {\n return this._request('DELETE', `/repos/${this.__fullname}/keys/${id}`, null, cb);\n }\n\n /**\n * Delete a file from a branch\n * @see https://developer.github.com/v3/repos/contents/#delete-a-file\n * @param {string} branch - the branch to delete from, or the default branch if not specified\n * @param {string} path - the path of the file to remove\n * @param {Requestable.callback} cb - will receive the commit in which the delete occurred\n * @return {Promise} - the promise for the http request\n */\n deleteFile(branch, path, cb) {\n return this.getSha(branch, path)\n .then((response) => {\n const deleteCommit = {\n message: `Delete the file at '${path}'`,\n sha: response.data.sha,\n branch,\n };\n return this._request('DELETE', `/repos/${this.__fullname}/contents/${path}`, deleteCommit, cb);\n });\n }\n\n /**\n * Change all references in a repo from oldPath to new_path\n * @param {string} branch - the branch to carry out the reference change, or the default branch if not specified\n * @param {string} oldPath - original path\n * @param {string} newPath - new reference path\n * @param {Requestable.callback} cb - will receive the commit in which the move occurred\n * @return {Promise} - the promise for the http request\n */\n move(branch, oldPath, newPath, cb) {\n let oldSha;\n return this.getRef(`heads/${branch}`)\n .then(({data: {object}}) => this.getTree(`${object.sha}?recursive=true`))\n .then(({data: {tree, sha}}) => {\n oldSha = sha;\n let newTree = tree.map((ref) => {\n if (ref.path === oldPath) {\n ref.path = newPath;\n }\n if (ref.type === 'tree') {\n delete ref.sha;\n }\n return ref;\n });\n return this.createTree(newTree);\n })\n .then(({data: tree}) => this.commit(oldSha, tree.sha, `Renamed '${oldPath}' to '${newPath}'`))\n .then(({data: commit}) => this.updateHead(`heads/${branch}`, commit.sha, true, cb));\n }\n\n /**\n * Write a file to the repository\n * @see https://developer.github.com/v3/repos/contents/#update-a-file\n * @param {string} branch - the name of the branch\n * @param {string} path - the path for the file\n * @param {string} content - the contents of the file\n * @param {string} message - the commit message\n * @param {Object} [options] - commit options\n * @param {Object} [options.author] - the author of the commit\n * @param {Object} [options.commiter] - the committer\n * @param {boolean} [options.encode] - true if the content should be base64 encoded\n * @param {Requestable.callback} cb - will receive the new commit\n * @return {Promise} - the promise for the http request\n */\n writeFile(branch, path, content, message, options, cb) {\n if (typeof options === 'function') {\n cb = options;\n options = {};\n }\n let filePath = path ? encodeURI(path) : '';\n let shouldEncode = options.encode !== false;\n let commit = {\n branch,\n message,\n author: options.author,\n committer: options.committer,\n content: shouldEncode ? Base64.encode(content) : content,\n };\n\n return this.getSha(branch, filePath)\n .then((response) => {\n commit.sha = response.data.sha;\n return this._request('PUT', `/repos/${this.__fullname}/contents/${filePath}`, commit, cb);\n }, () => {\n return this._request('PUT', `/repos/${this.__fullname}/contents/${filePath}`, commit, cb);\n });\n }\n\n /**\n * Check if a repository is starred by you\n * @see https://developer.github.com/v3/activity/starring/#check-if-you-are-starring-a-repository\n * @param {Requestable.callback} cb - will receive true if the repository is starred and false if the repository\n * is not starred\n * @return {Promise} - the promise for the http request {Boolean} [description]\n */\n isStarred(cb) {\n return this._request204or404(`/user/starred/${this.__fullname}`, null, cb);\n }\n\n /**\n * Star a repository\n * @see https://developer.github.com/v3/activity/starring/#star-a-repository\n * @param {Requestable.callback} cb - will receive true if the repository is starred\n * @return {Promise} - the promise for the http request\n */\n star(cb) {\n return this._request('PUT', `/user/starred/${this.__fullname}`, null, cb);\n }\n\n /**\n * Unstar a repository\n * @see https://developer.github.com/v3/activity/starring/#unstar-a-repository\n * @param {Requestable.callback} cb - will receive true if the repository is unstarred\n * @return {Promise} - the promise for the http request\n */\n unstar(cb) {\n return this._request('DELETE', `/user/starred/${this.__fullname}`, null, cb);\n }\n\n /**\n * Create a new release\n * @see https://developer.github.com/v3/repos/releases/#create-a-release\n * @param {Object} options - the description of the release\n * @param {Requestable.callback} cb - will receive the newly created release\n * @return {Promise} - the promise for the http request\n */\n createRelease(options, cb) {\n return this._request('POST', `/repos/${this.__fullname}/releases`, options, cb);\n }\n\n /**\n * Edit a release\n * @see https://developer.github.com/v3/repos/releases/#edit-a-release\n * @param {string} id - the id of the release\n * @param {Object} options - the description of the release\n * @param {Requestable.callback} cb - will receive the modified release\n * @return {Promise} - the promise for the http request\n */\n updateRelease(id, options, cb) {\n return this._request('PATCH', `/repos/${this.__fullname}/releases/${id}`, options, cb);\n }\n\n /**\n * Get information about all releases\n * @see https://developer.github.com/v3/repos/releases/#list-releases-for-a-repository\n * @param {Requestable.callback} cb - will receive the release information\n * @return {Promise} - the promise for the http request\n */\n listReleases(cb) {\n return this._request('GET', `/repos/${this.__fullname}/releases`, null, cb);\n }\n\n /**\n * Get information about a release\n * @see https://developer.github.com/v3/repos/releases/#get-a-single-release\n * @param {string} id - the id of the release\n * @param {Requestable.callback} cb - will receive the release information\n * @return {Promise} - the promise for the http request\n */\n getRelease(id, cb) {\n return this._request('GET', `/repos/${this.__fullname}/releases/${id}`, null, cb);\n }\n\n /**\n * Delete a release\n * @see https://developer.github.com/v3/repos/releases/#delete-a-release\n * @param {string} id - the release to be deleted\n * @param {Requestable.callback} cb - will receive true if the operation is successful\n * @return {Promise} - the promise for the http request\n */\n deleteRelease(id, cb) {\n return this._request('DELETE', `/repos/${this.__fullname}/releases/${id}`, null, cb);\n }\n\n /**\n * Merge a pull request\n * @see https://developer.github.com/v3/pulls/#merge-a-pull-request-merge-button\n * @param {number|string} number - the number of the pull request to merge\n * @param {Object} options - the merge options for the pull request\n * @param {Requestable.callback} [cb] - will receive the merge information if the operation is successful\n * @return {Promise} - the promise for the http request\n */\n mergePullRequest(number, options, cb) {\n return this._request('PUT', `/repos/${this.__fullname}/pulls/${number}/merge`, options, cb);\n }\n\n /**\n * Get information about all projects\n * @see https://developer.github.com/v3/projects/#list-repository-projects\n * @param {Requestable.callback} [cb] - will receive the list of projects\n * @return {Promise} - the promise for the http request\n */\n listProjects(cb) {\n return this._requestAllPages(`/repos/${this.__fullname}/projects`, {AcceptHeader: 'inertia-preview'}, cb);\n }\n\n /**\n * Create a new project\n * @see https://developer.github.com/v3/projects/#create-a-repository-project\n * @param {Object} options - the description of the project\n * @param {Requestable.callback} cb - will receive the newly created project\n * @return {Promise} - the promise for the http request\n */\n createProject(options, cb) {\n options = options || {};\n options.AcceptHeader = 'inertia-preview';\n return this._request('POST', `/repos/${this.__fullname}/projects`, options, cb);\n }\n\n}\n\nmodule.exports = Repository;\n"],"file":"Repository.js"} \ No newline at end of file diff --git a/dist/components/Requestable.js b/dist/components/Requestable.js new file mode 100644 index 00000000..7a1aa416 --- /dev/null +++ b/dist/components/Requestable.js @@ -0,0 +1,388 @@ +'use strict'; + +var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; + +var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); + +var _axios = require('axios'); + +var _axios2 = _interopRequireDefault(_axios); + +var _debug = require('debug'); + +var _debug2 = _interopRequireDefault(_debug); + +var _jsBase = require('js-base64'); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +function _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } } + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } + +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } /** + * @file + * @copyright 2016 Yahoo Inc. + * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}. + * Github.js is freely distributable. + */ + +var log = (0, _debug2.default)('github:request'); + +/** + * The error structure returned when a network call fails + */ + +var ResponseError = function (_Error) { + _inherits(ResponseError, _Error); + + /** + * Construct a new ResponseError + * @param {string} message - an message to return instead of the the default error message + * @param {string} path - the requested path + * @param {Object} response - the object returned by Axios + */ + function ResponseError(message, path, response) { + _classCallCheck(this, ResponseError); + + var _this = _possibleConstructorReturn(this, (ResponseError.__proto__ || Object.getPrototypeOf(ResponseError)).call(this, message)); + + _this.path = path; + _this.request = response.config; + _this.response = (response || {}).response || response; + _this.status = response.status; + return _this; + } + + return ResponseError; +}(Error); + +/** + * Requestable wraps the logic for making http requests to the API + */ + + +var Requestable = function () { + /** + * Either a username and password or an oauth token for Github + * @typedef {Object} Requestable.auth + * @prop {string} [username] - the Github username + * @prop {string} [password] - the user's password + * @prop {token} [token] - an OAuth token + */ + /** + * Initialize the http internals. + * @param {Requestable.auth} [auth] - the credentials to authenticate to Github. If auth is + * not provided request will be made unauthenticated + * @param {string} [apiBase=https://api.github.com] - the base Github API URL + * @param {string} [AcceptHeader=v3] - the accept header for the requests + */ + function Requestable(auth, apiBase, AcceptHeader) { + _classCallCheck(this, Requestable); + + this.__apiBase = apiBase || 'https://api.github.com'; + this.__auth = { + token: auth.token, + username: auth.username, + password: auth.password + }; + this.__AcceptHeader = AcceptHeader || 'v3'; + + if (auth.token) { + this.__authorizationHeader = 'token ' + auth.token; + } else if (auth.username && auth.password) { + this.__authorizationHeader = 'Basic ' + _jsBase.Base64.encode(auth.username + ':' + auth.password); + } + } + + /** + * Compute the URL to use to make a request. + * @private + * @param {string} path - either a URL relative to the API base or an absolute URL + * @return {string} - the URL to use + */ + + + _createClass(Requestable, [{ + key: '__getURL', + value: function __getURL(path) { + var url = path; + + if (path.indexOf('//') === -1) { + url = this.__apiBase + path; + } + + var newCacheBuster = 'timestamp=' + new Date().getTime(); + return url.replace(/(timestamp=\d+)/, newCacheBuster); + } + + /** + * Compute the headers required for an API request. + * @private + * @param {boolean} raw - if the request should be treated as JSON or as a raw request + * @param {string} AcceptHeader - the accept header for the request + * @return {Object} - the headers to use in the request + */ + + }, { + key: '__getRequestHeaders', + value: function __getRequestHeaders(raw, AcceptHeader) { + var headers = { + 'Content-Type': 'application/json;charset=UTF-8', + 'Accept': 'application/vnd.github.' + (AcceptHeader || this.__AcceptHeader) + }; + + if (raw) { + headers.Accept += '.raw'; + } + headers.Accept += '+json'; + + if (this.__authorizationHeader) { + headers.Authorization = this.__authorizationHeader; + } + + return headers; + } + + /** + * Sets the default options for API requests + * @protected + * @param {Object} [requestOptions={}] - the current options for the request + * @return {Object} - the options to pass to the request + */ + + }, { + key: '_getOptionsWithDefaults', + value: function _getOptionsWithDefaults() { + var requestOptions = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {}; + + if (!(requestOptions.visibility || requestOptions.affiliation)) { + requestOptions.type = requestOptions.type || 'all'; + } + requestOptions.sort = requestOptions.sort || 'updated'; + requestOptions.per_page = requestOptions.per_page || '100'; // eslint-disable-line + + return requestOptions; + } + + /** + * if a `Date` is passed to this function it will be converted to an ISO string + * @param {*} date - the object to attempt to cooerce into an ISO date string + * @return {string} - the ISO representation of `date` or whatever was passed in if it was not a date + */ + + }, { + key: '_dateToISO', + value: function _dateToISO(date) { + if (date && date instanceof Date) { + date = date.toISOString(); + } + + return date; + } + + /** + * A function that receives the result of the API request. + * @callback Requestable.callback + * @param {Requestable.Error} error - the error returned by the API or `null` + * @param {(Object|true)} result - the data returned by the API or `true` if the API returns `204 No Content` + * @param {Object} request - the raw {@linkcode https://github.com/mzabriskie/axios#response-schema Response} + */ + /** + * Make a request. + * @param {string} method - the method for the request (GET, PUT, POST, DELETE) + * @param {string} path - the path for the request + * @param {*} [data] - the data to send to the server. For HTTP methods that don't have a body the data + * will be sent as query parameters + * @param {Requestable.callback} [cb] - the callback for the request + * @param {boolean} [raw=false] - if the request should be sent as raw. If this is a falsy value then the + * request will be made as JSON + * @return {Promise} - the Promise for the http request + */ + + }, { + key: '_request', + value: function _request(method, path, data, cb, raw) { + var url = this.__getURL(path); + + var AcceptHeader = (data || {}).AcceptHeader; + if (AcceptHeader) { + delete data.AcceptHeader; + } + var headers = this.__getRequestHeaders(raw, AcceptHeader); + + var queryParams = {}; + + var shouldUseDataAsParams = data && (typeof data === 'undefined' ? 'undefined' : _typeof(data)) === 'object' && methodHasNoBody(method); + if (shouldUseDataAsParams) { + queryParams = data; + data = undefined; + } + + var config = { + url: url, + method: method, + headers: headers, + params: queryParams, + data: data, + responseType: raw ? 'text' : 'json' + }; + + log(config.method + ' to ' + config.url); + var requestPromise = (0, _axios2.default)(config).catch(callbackErrorOrThrow(cb, path)); + + if (cb) { + requestPromise.then(function (response) { + if (response.data && Object.keys(response.data).length > 0) { + // When data has results + cb(null, response.data, response); + } else if (config.method !== 'GET' && Object.keys(response.data).length < 1) { + // True when successful submit a request and receive a empty object + cb(null, response.status < 300, response); + } else { + cb(null, response.data, response); + } + }); + } + + return requestPromise; + } + + /** + * Make a request to an endpoint the returns 204 when true and 404 when false + * @param {string} path - the path to request + * @param {Object} data - any query parameters for the request + * @param {Requestable.callback} cb - the callback that will receive `true` or `false` + * @param {method} [method=GET] - HTTP Method to use + * @return {Promise} - the promise for the http request + */ + + }, { + key: '_request204or404', + value: function _request204or404(path, data, cb) { + var method = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 'GET'; + + return this._request(method, path, data).then(function success(response) { + if (cb) { + cb(null, true, response); + } + return true; + }, function failure(response) { + if (response.response.status === 404) { + if (cb) { + cb(null, false, response); + } + return false; + } + + if (cb) { + cb(response); + } + throw response; + }); + } + + /** + * Make a request and fetch all the available data. Github will paginate responses so for queries + * that might span multiple pages this method is preferred to {@link Requestable#request} + * @param {string} path - the path to request + * @param {Object} options - the query parameters to include + * @param {Requestable.callback} [cb] - the function to receive the data. The returned data will always be an array. + * @param {Object[]} results - the partial results. This argument is intended for interal use only. + * @return {Promise} - a promise which will resolve when all pages have been fetched + * @deprecated This will be folded into {@link Requestable#_request} in the 2.0 release. + */ + + }, { + key: '_requestAllPages', + value: function _requestAllPages(path, options, cb, results) { + var _this2 = this; + + results = results || []; + + return this._request('GET', path, options).then(function (response) { + var _results; + + var thisGroup = void 0; + if (response.data instanceof Array) { + thisGroup = response.data; + } else if (response.data.items instanceof Array) { + thisGroup = response.data.items; + } else { + var message = 'cannot figure out how to append ' + response.data + ' to the result set'; + throw new ResponseError(message, path, response); + } + (_results = results).push.apply(_results, _toConsumableArray(thisGroup)); + + var nextUrl = getNextPage(response.headers.link); + if (nextUrl && typeof options.page !== 'number') { + log('getting next page: ' + nextUrl); + return _this2._requestAllPages(nextUrl, options, cb, results); + } + + if (cb) { + cb(null, results, response); + } + + response.data = results; + return response; + }).catch(callbackErrorOrThrow(cb, path)); + } + }]); + + return Requestable; +}(); + +module.exports = Requestable; + +// ////////////////////////// // +// Private helper functions // +// ////////////////////////// // +var METHODS_WITH_NO_BODY = ['GET', 'HEAD', 'DELETE']; +function methodHasNoBody(method) { + return METHODS_WITH_NO_BODY.indexOf(method) !== -1; +} + +function getNextPage() { + var linksHeader = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : ''; + + var links = linksHeader.split(/\s*,\s*/); // splits and strips the urls + return links.reduce(function (nextUrl, link) { + if (link.search(/rel="next"/) !== -1) { + return (link.match(/<(.*)>/) || [])[1]; + } + + return nextUrl; + }, undefined); +} + +function callbackErrorOrThrow(cb, path) { + return function handler(object) { + var error = void 0; + if (object.hasOwnProperty('config')) { + var _object$response = object.response, + status = _object$response.status, + statusText = _object$response.statusText, + _object$config = object.config, + method = _object$config.method, + url = _object$config.url; + + var message = status + ' error making request ' + method + ' ' + url + ': "' + statusText + '"'; + error = new ResponseError(message, path, object); + log(message + ' ' + JSON.stringify(object.data)); + } else { + error = object; + } + if (cb) { + log('going to error callback'); + cb(error); + } else { + log('throwing error'); + throw error; + } + }; +} +//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["Requestable.js"],"names":["log","ResponseError","message","path","response","request","config","status","Error","Requestable","auth","apiBase","AcceptHeader","__apiBase","__auth","token","username","password","__AcceptHeader","__authorizationHeader","encode","url","indexOf","newCacheBuster","Date","getTime","replace","raw","headers","Accept","Authorization","requestOptions","visibility","affiliation","type","sort","per_page","date","toISOString","method","data","cb","__getURL","__getRequestHeaders","queryParams","shouldUseDataAsParams","methodHasNoBody","undefined","params","responseType","requestPromise","catch","callbackErrorOrThrow","then","Object","keys","length","_request","success","failure","options","results","thisGroup","Array","items","push","nextUrl","getNextPage","link","page","_requestAllPages","module","exports","METHODS_WITH_NO_BODY","linksHeader","links","split","reduce","search","match","handler","object","error","hasOwnProperty","statusText","JSON","stringify"],"mappings":"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","file":"Requestable.js","sourcesContent":["/**\n * @file\n * @copyright  2016 Yahoo Inc.\n * @license    Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n *             Github.js is freely distributable.\n */\n\nimport axios from 'axios';\nimport debug from 'debug';\nimport {Base64} from 'js-base64';\n\nconst log = debug('github:request');\n\n/**\n * The error structure returned when a network call fails\n */\nclass ResponseError extends Error {\n   /**\n    * Construct a new ResponseError\n    * @param {string} message - an message to return instead of the the default error message\n    * @param {string} path - the requested path\n    * @param {Object} response - the object returned by Axios\n    */\n   constructor(message, path, response) {\n      super(message);\n      this.path = path;\n      this.request = response.config;\n      this.response = (response || {}).response || response;\n      this.status = response.status;\n   }\n}\n\n/**\n * Requestable wraps the logic for making http requests to the API\n */\nclass Requestable {\n   /**\n    * Either a username and password or an oauth token for Github\n    * @typedef {Object} Requestable.auth\n    * @prop {string} [username] - the Github username\n    * @prop {string} [password] - the user's password\n    * @prop {token} [token] - an OAuth token\n    */\n   /**\n    * Initialize the http internals.\n    * @param {Requestable.auth} [auth] - the credentials to authenticate to Github. If auth is\n    *                                  not provided request will be made unauthenticated\n    * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n    * @param {string} [AcceptHeader=v3] - the accept header for the requests\n    */\n   constructor(auth, apiBase, AcceptHeader) {\n      this.__apiBase = apiBase || 'https://api.github.com';\n      this.__auth = {\n         token: auth.token,\n         username: auth.username,\n         password: auth.password,\n      };\n      this.__AcceptHeader = AcceptHeader || 'v3';\n\n      if (auth.token) {\n         this.__authorizationHeader = 'token ' + auth.token;\n      } else if (auth.username && auth.password) {\n         this.__authorizationHeader = 'Basic ' + Base64.encode(auth.username + ':' + auth.password);\n      }\n   }\n\n   /**\n    * Compute the URL to use to make a request.\n    * @private\n    * @param {string} path - either a URL relative to the API base or an absolute URL\n    * @return {string} - the URL to use\n    */\n   __getURL(path) {\n      let url = path;\n\n      if (path.indexOf('//') === -1) {\n         url = this.__apiBase + path;\n      }\n\n      let newCacheBuster = 'timestamp=' + new Date().getTime();\n      return url.replace(/(timestamp=\\d+)/, newCacheBuster);\n   }\n\n   /**\n    * Compute the headers required for an API request.\n    * @private\n    * @param {boolean} raw - if the request should be treated as JSON or as a raw request\n    * @param {string} AcceptHeader - the accept header for the request\n    * @return {Object} - the headers to use in the request\n    */\n   __getRequestHeaders(raw, AcceptHeader) {\n      let headers = {\n         'Content-Type': 'application/json;charset=UTF-8',\n         'Accept': 'application/vnd.github.' + (AcceptHeader || this.__AcceptHeader),\n      };\n\n      if (raw) {\n         headers.Accept += '.raw';\n      }\n      headers.Accept += '+json';\n\n      if (this.__authorizationHeader) {\n         headers.Authorization = this.__authorizationHeader;\n      }\n\n      return headers;\n   }\n\n   /**\n    * Sets the default options for API requests\n    * @protected\n    * @param {Object} [requestOptions={}] - the current options for the request\n    * @return {Object} - the options to pass to the request\n    */\n   _getOptionsWithDefaults(requestOptions = {}) {\n      if (!(requestOptions.visibility || requestOptions.affiliation)) {\n         requestOptions.type = requestOptions.type || 'all';\n      }\n      requestOptions.sort = requestOptions.sort || 'updated';\n      requestOptions.per_page = requestOptions.per_page || '100'; // eslint-disable-line\n\n      return requestOptions;\n   }\n\n   /**\n    * if a `Date` is passed to this function it will be converted to an ISO string\n    * @param {*} date - the object to attempt to cooerce into an ISO date string\n    * @return {string} - the ISO representation of `date` or whatever was passed in if it was not a date\n    */\n   _dateToISO(date) {\n      if (date && (date instanceof Date)) {\n         date = date.toISOString();\n      }\n\n      return date;\n   }\n\n   /**\n    * A function that receives the result of the API request.\n    * @callback Requestable.callback\n    * @param {Requestable.Error} error - the error returned by the API or `null`\n    * @param {(Object|true)} result - the data returned by the API or `true` if the API returns `204 No Content`\n    * @param {Object} request - the raw {@linkcode https://github.com/mzabriskie/axios#response-schema Response}\n    */\n   /**\n    * Make a request.\n    * @param {string} method - the method for the request (GET, PUT, POST, DELETE)\n    * @param {string} path - the path for the request\n    * @param {*} [data] - the data to send to the server. For HTTP methods that don't have a body the data\n    *                   will be sent as query parameters\n    * @param {Requestable.callback} [cb] - the callback for the request\n    * @param {boolean} [raw=false] - if the request should be sent as raw. If this is a falsy value then the\n    *                              request will be made as JSON\n    * @return {Promise} - the Promise for the http request\n    */\n   _request(method, path, data, cb, raw) {\n      const url = this.__getURL(path);\n\n      const AcceptHeader = (data || {}).AcceptHeader;\n      if (AcceptHeader) {\n         delete data.AcceptHeader;\n      }\n      const headers = this.__getRequestHeaders(raw, AcceptHeader);\n\n      let queryParams = {};\n\n      const shouldUseDataAsParams = data && (typeof data === 'object') && methodHasNoBody(method);\n      if (shouldUseDataAsParams) {\n         queryParams = data;\n         data = undefined;\n      }\n\n      const config = {\n         url: url,\n         method: method,\n         headers: headers,\n         params: queryParams,\n         data: data,\n         responseType: raw ? 'text' : 'json',\n      };\n\n      log(`${config.method} to ${config.url}`);\n      const requestPromise = axios(config).catch(callbackErrorOrThrow(cb, path));\n\n      if (cb) {\n         requestPromise.then((response) => {\n            if (response.data && Object.keys(response.data).length > 0) {\n               // When data has results\n               cb(null, response.data, response);\n            } else if (config.method !== 'GET' && Object.keys(response.data).length < 1) {\n               // True when successful submit a request and receive a empty object\n               cb(null, (response.status < 300), response);\n            } else {\n               cb(null, response.data, response);\n            }\n         });\n      }\n\n      return requestPromise;\n   }\n\n   /**\n    * Make a request to an endpoint the returns 204 when true and 404 when false\n    * @param {string} path - the path to request\n    * @param {Object} data - any query parameters for the request\n    * @param {Requestable.callback} cb - the callback that will receive `true` or `false`\n    * @param {method} [method=GET] - HTTP Method to use\n    * @return {Promise} - the promise for the http request\n    */\n   _request204or404(path, data, cb, method = 'GET') {\n      return this._request(method, path, data)\n         .then(function success(response) {\n            if (cb) {\n               cb(null, true, response);\n            }\n            return true;\n         }, function failure(response) {\n            if (response.response.status === 404) {\n               if (cb) {\n                  cb(null, false, response);\n               }\n               return false;\n            }\n\n            if (cb) {\n               cb(response);\n            }\n            throw response;\n         });\n   }\n\n   /**\n    * Make a request and fetch all the available data. Github will paginate responses so for queries\n    * that might span multiple pages this method is preferred to {@link Requestable#request}\n    * @param {string} path - the path to request\n    * @param {Object} options - the query parameters to include\n    * @param {Requestable.callback} [cb] - the function to receive the data. The returned data will always be an array.\n    * @param {Object[]} results - the partial results. This argument is intended for interal use only.\n    * @return {Promise} - a promise which will resolve when all pages have been fetched\n    * @deprecated This will be folded into {@link Requestable#_request} in the 2.0 release.\n    */\n   _requestAllPages(path, options, cb, results) {\n      results = results || [];\n\n      return this._request('GET', path, options)\n         .then((response) => {\n            let thisGroup;\n            if (response.data instanceof Array) {\n               thisGroup = response.data;\n            } else if (response.data.items instanceof Array) {\n               thisGroup = response.data.items;\n            } else {\n               let message = `cannot figure out how to append ${response.data} to the result set`;\n               throw new ResponseError(message, path, response);\n            }\n            results.push(...thisGroup);\n\n            const nextUrl = getNextPage(response.headers.link);\n            if (nextUrl && typeof options.page !== 'number') {\n               log(`getting next page: ${nextUrl}`);\n               return this._requestAllPages(nextUrl, options, cb, results);\n            }\n\n            if (cb) {\n               cb(null, results, response);\n            }\n\n            response.data = results;\n            return response;\n         }).catch(callbackErrorOrThrow(cb, path));\n   }\n}\n\nmodule.exports = Requestable;\n\n// ////////////////////////// //\n//  Private helper functions  //\n// ////////////////////////// //\nconst METHODS_WITH_NO_BODY = ['GET', 'HEAD', 'DELETE'];\nfunction methodHasNoBody(method) {\n   return METHODS_WITH_NO_BODY.indexOf(method) !== -1;\n}\n\nfunction getNextPage(linksHeader = '') {\n   const links = linksHeader.split(/\\s*,\\s*/); // splits and strips the urls\n   return links.reduce(function(nextUrl, link) {\n      if (link.search(/rel=\"next\"/) !== -1) {\n         return (link.match(/<(.*)>/) || [])[1];\n      }\n\n      return nextUrl;\n   }, undefined);\n}\n\nfunction callbackErrorOrThrow(cb, path) {\n   return function handler(object) {\n      let error;\n      if (object.hasOwnProperty('config')) {\n         const {response: {status, statusText}, config: {method, url}} = object;\n         let message = (`${status} error making request ${method} ${url}: \"${statusText}\"`);\n         error = new ResponseError(message, path, object);\n         log(`${message} ${JSON.stringify(object.data)}`);\n      } else {\n         error = object;\n      }\n      if (cb) {\n         log('going to error callback');\n         cb(error);\n      } else {\n         log('throwing error');\n         throw error;\n      }\n   };\n}\n"]} +//# sourceMappingURL=Requestable.js.map diff --git a/dist/components/Requestable.js.map b/dist/components/Requestable.js.map new file mode 100644 index 00000000..652e9540 --- /dev/null +++ b/dist/components/Requestable.js.map @@ -0,0 +1 @@ +{"version":3,"names":[],"mappings":"","sources":["Requestable.js"],"sourcesContent":["/**\n * @file\n * @copyright 2016 Yahoo Inc.\n * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n * Github.js is freely distributable.\n */\n\nimport axios from 'axios';\nimport debug from 'debug';\nimport {Base64} from 'js-base64';\n\nconst log = debug('github:request');\n\n/**\n * The error structure returned when a network call fails\n */\nclass ResponseError extends Error {\n /**\n * Construct a new ResponseError\n * @param {string} message - an message to return instead of the the default error message\n * @param {string} path - the requested path\n * @param {Object} response - the object returned by Axios\n */\n constructor(message, path, response) {\n super(message);\n this.path = path;\n this.request = response.config;\n this.response = (response || {}).response || response;\n this.status = response.status;\n }\n}\n\n/**\n * Requestable wraps the logic for making http requests to the API\n */\nclass Requestable {\n /**\n * Either a username and password or an oauth token for Github\n * @typedef {Object} Requestable.auth\n * @prop {string} [username] - the Github username\n * @prop {string} [password] - the user's password\n * @prop {token} [token] - an OAuth token\n */\n /**\n * Initialize the http internals.\n * @param {Requestable.auth} [auth] - the credentials to authenticate to Github. If auth is\n * not provided request will be made unauthenticated\n * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n * @param {string} [AcceptHeader=v3] - the accept header for the requests\n */\n constructor(auth, apiBase, AcceptHeader) {\n this.__apiBase = apiBase || 'https://api.github.com';\n this.__auth = {\n token: auth.token,\n username: auth.username,\n password: auth.password,\n };\n this.__AcceptHeader = AcceptHeader || 'v3';\n\n if (auth.token) {\n this.__authorizationHeader = 'token ' + auth.token;\n } else if (auth.username && auth.password) {\n this.__authorizationHeader = 'Basic ' + Base64.encode(auth.username + ':' + auth.password);\n }\n }\n\n /**\n * Compute the URL to use to make a request.\n * @private\n * @param {string} path - either a URL relative to the API base or an absolute URL\n * @return {string} - the URL to use\n */\n __getURL(path) {\n let url = path;\n\n if (path.indexOf('//') === -1) {\n url = this.__apiBase + path;\n }\n\n let newCacheBuster = 'timestamp=' + new Date().getTime();\n return url.replace(/(timestamp=\\d+)/, newCacheBuster);\n }\n\n /**\n * Compute the headers required for an API request.\n * @private\n * @param {boolean} raw - if the request should be treated as JSON or as a raw request\n * @param {string} AcceptHeader - the accept header for the request\n * @return {Object} - the headers to use in the request\n */\n __getRequestHeaders(raw, AcceptHeader) {\n let headers = {\n 'Content-Type': 'application/json;charset=UTF-8',\n 'Accept': 'application/vnd.github.' + (AcceptHeader || this.__AcceptHeader),\n };\n\n if (raw) {\n headers.Accept += '.raw';\n }\n headers.Accept += '+json';\n\n if (this.__authorizationHeader) {\n headers.Authorization = this.__authorizationHeader;\n }\n\n return headers;\n }\n\n /**\n * Sets the default options for API requests\n * @protected\n * @param {Object} [requestOptions={}] - the current options for the request\n * @return {Object} - the options to pass to the request\n */\n _getOptionsWithDefaults(requestOptions = {}) {\n if (!(requestOptions.visibility || requestOptions.affiliation)) {\n requestOptions.type = requestOptions.type || 'all';\n }\n requestOptions.sort = requestOptions.sort || 'updated';\n requestOptions.per_page = requestOptions.per_page || '100'; // eslint-disable-line\n\n return requestOptions;\n }\n\n /**\n * if a `Date` is passed to this function it will be converted to an ISO string\n * @param {*} date - the object to attempt to cooerce into an ISO date string\n * @return {string} - the ISO representation of `date` or whatever was passed in if it was not a date\n */\n _dateToISO(date) {\n if (date && (date instanceof Date)) {\n date = date.toISOString();\n }\n\n return date;\n }\n\n /**\n * A function that receives the result of the API request.\n * @callback Requestable.callback\n * @param {Requestable.Error} error - the error returned by the API or `null`\n * @param {(Object|true)} result - the data returned by the API or `true` if the API returns `204 No Content`\n * @param {Object} request - the raw {@linkcode https://github.com/mzabriskie/axios#response-schema Response}\n */\n /**\n * Make a request.\n * @param {string} method - the method for the request (GET, PUT, POST, DELETE)\n * @param {string} path - the path for the request\n * @param {*} [data] - the data to send to the server. For HTTP methods that don't have a body the data\n * will be sent as query parameters\n * @param {Requestable.callback} [cb] - the callback for the request\n * @param {boolean} [raw=false] - if the request should be sent as raw. If this is a falsy value then the\n * request will be made as JSON\n * @return {Promise} - the Promise for the http request\n */\n _request(method, path, data, cb, raw) {\n const url = this.__getURL(path);\n\n const AcceptHeader = (data || {}).AcceptHeader;\n if (AcceptHeader) {\n delete data.AcceptHeader;\n }\n const headers = this.__getRequestHeaders(raw, AcceptHeader);\n\n let queryParams = {};\n\n const shouldUseDataAsParams = data && (typeof data === 'object') && methodHasNoBody(method);\n if (shouldUseDataAsParams) {\n queryParams = data;\n data = undefined;\n }\n\n const config = {\n url: url,\n method: method,\n headers: headers,\n params: queryParams,\n data: data,\n responseType: raw ? 'text' : 'json',\n };\n\n log(`${config.method} to ${config.url}`);\n const requestPromise = axios(config).catch(callbackErrorOrThrow(cb, path));\n\n if (cb) {\n requestPromise.then((response) => {\n if (response.data && Object.keys(response.data).length > 0) {\n // When data has results\n cb(null, response.data, response);\n } else if (config.method !== 'GET' && Object.keys(response.data).length < 1) {\n // True when successful submit a request and receive a empty object\n cb(null, (response.status < 300), response);\n } else {\n cb(null, response.data, response);\n }\n });\n }\n\n return requestPromise;\n }\n\n /**\n * Make a request to an endpoint the returns 204 when true and 404 when false\n * @param {string} path - the path to request\n * @param {Object} data - any query parameters for the request\n * @param {Requestable.callback} cb - the callback that will receive `true` or `false`\n * @param {method} [method=GET] - HTTP Method to use\n * @return {Promise} - the promise for the http request\n */\n _request204or404(path, data, cb, method = 'GET') {\n return this._request(method, path, data)\n .then(function success(response) {\n if (cb) {\n cb(null, true, response);\n }\n return true;\n }, function failure(response) {\n if (response.response.status === 404) {\n if (cb) {\n cb(null, false, response);\n }\n return false;\n }\n\n if (cb) {\n cb(response);\n }\n throw response;\n });\n }\n\n /**\n * Make a request and fetch all the available data. Github will paginate responses so for queries\n * that might span multiple pages this method is preferred to {@link Requestable#request}\n * @param {string} path - the path to request\n * @param {Object} options - the query parameters to include\n * @param {Requestable.callback} [cb] - the function to receive the data. The returned data will always be an array.\n * @param {Object[]} results - the partial results. This argument is intended for interal use only.\n * @return {Promise} - a promise which will resolve when all pages have been fetched\n * @deprecated This will be folded into {@link Requestable#_request} in the 2.0 release.\n */\n _requestAllPages(path, options, cb, results) {\n results = results || [];\n\n return this._request('GET', path, options)\n .then((response) => {\n let thisGroup;\n if (response.data instanceof Array) {\n thisGroup = response.data;\n } else if (response.data.items instanceof Array) {\n thisGroup = response.data.items;\n } else {\n let message = `cannot figure out how to append ${response.data} to the result set`;\n throw new ResponseError(message, path, response);\n }\n results.push(...thisGroup);\n\n const nextUrl = getNextPage(response.headers.link);\n if (nextUrl && typeof options.page !== 'number') {\n log(`getting next page: ${nextUrl}`);\n return this._requestAllPages(nextUrl, options, cb, results);\n }\n\n if (cb) {\n cb(null, results, response);\n }\n\n response.data = results;\n return response;\n }).catch(callbackErrorOrThrow(cb, path));\n }\n}\n\nmodule.exports = Requestable;\n\n// ////////////////////////// //\n// Private helper functions //\n// ////////////////////////// //\nconst METHODS_WITH_NO_BODY = ['GET', 'HEAD', 'DELETE'];\nfunction methodHasNoBody(method) {\n return METHODS_WITH_NO_BODY.indexOf(method) !== -1;\n}\n\nfunction getNextPage(linksHeader = '') {\n const links = linksHeader.split(/\\s*,\\s*/); // splits and strips the urls\n return links.reduce(function(nextUrl, link) {\n if (link.search(/rel=\"next\"/) !== -1) {\n return (link.match(/<(.*)>/) || [])[1];\n }\n\n return nextUrl;\n }, undefined);\n}\n\nfunction callbackErrorOrThrow(cb, path) {\n return function handler(object) {\n let error;\n if (object.hasOwnProperty('config')) {\n const {response: {status, statusText}, config: {method, url}} = object;\n let message = (`${status} error making request ${method} ${url}: \"${statusText}\"`);\n error = new ResponseError(message, path, object);\n log(`${message} ${JSON.stringify(object.data)}`);\n } else {\n error = object;\n }\n if (cb) {\n log('going to error callback');\n cb(error);\n } else {\n log('throwing error');\n throw error;\n }\n };\n}\n"],"file":"Requestable.js"} \ No newline at end of file diff --git a/dist/components/Search.js b/dist/components/Search.js new file mode 100644 index 00000000..30442dc4 --- /dev/null +++ b/dist/components/Search.js @@ -0,0 +1,151 @@ +'use strict'; + +var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); + +var _Requestable2 = require('./Requestable'); + +var _Requestable3 = _interopRequireDefault(_Requestable2); + +var _debug = require('debug'); + +var _debug2 = _interopRequireDefault(_debug); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } + +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } /** + * @file + * @copyright 2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc. + * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}. + * Github.js is freely distributable. + */ + +var log = (0, _debug2.default)('github:search'); + +/** + * Wrap the Search API + */ + +var Search = function (_Requestable) { + _inherits(Search, _Requestable); + + /** + * Create a Search + * @param {Object} defaults - defaults for the search + * @param {Requestable.auth} [auth] - information required to authenticate to Github + * @param {string} [apiBase=https://api.github.com] - the base Github API URL + */ + function Search(defaults, auth, apiBase) { + _classCallCheck(this, Search); + + var _this = _possibleConstructorReturn(this, (Search.__proto__ || Object.getPrototypeOf(Search)).call(this, auth, apiBase)); + + _this.__defaults = _this._getOptionsWithDefaults(defaults); + return _this; + } + + /** + * Available search options + * @see https://developer.github.com/v3/search/#parameters + * @typedef {Object} Search.Params + * @param {string} q - the query to make + * @param {string} sort - the sort field, one of `stars`, `forks`, or `updated`. + * Default is [best match](https://developer.github.com/v3/search/#ranking-search-results) + * @param {string} order - the ordering, either `asc` or `desc` + */ + /** + * Perform a search on the GitHub API + * @private + * @param {string} path - the scope of the search + * @param {Search.Params} [withOptions] - additional parameters for the search + * @param {Requestable.callback} [cb] - will receive the results of the search + * @return {Promise} - the promise for the http request + */ + + + _createClass(Search, [{ + key: '_search', + value: function _search(path) { + var _this2 = this; + + var withOptions = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; + var cb = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : undefined; + + var requestOptions = {}; + Object.keys(this.__defaults).forEach(function (prop) { + requestOptions[prop] = _this2.__defaults[prop]; + }); + Object.keys(withOptions).forEach(function (prop) { + requestOptions[prop] = withOptions[prop]; + }); + + log('searching ' + path + ' with options:', requestOptions); + return this._requestAllPages('/search/' + path, requestOptions, cb); + } + + /** + * Search for repositories + * @see https://developer.github.com/v3/search/#search-repositories + * @param {Search.Params} [options] - additional parameters for the search + * @param {Requestable.callback} [cb] - will receive the results of the search + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'forRepositories', + value: function forRepositories(options, cb) { + return this._search('repositories', options, cb); + } + + /** + * Search for code + * @see https://developer.github.com/v3/search/#search-code + * @param {Search.Params} [options] - additional parameters for the search + * @param {Requestable.callback} [cb] - will receive the results of the search + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'forCode', + value: function forCode(options, cb) { + return this._search('code', options, cb); + } + + /** + * Search for issues + * @see https://developer.github.com/v3/search/#search-issues + * @param {Search.Params} [options] - additional parameters for the search + * @param {Requestable.callback} [cb] - will receive the results of the search + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'forIssues', + value: function forIssues(options, cb) { + return this._search('issues', options, cb); + } + + /** + * Search for users + * @see https://developer.github.com/v3/search/#search-users + * @param {Search.Params} [options] - additional parameters for the search + * @param {Requestable.callback} [cb] - will receive the results of the search + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'forUsers', + value: function forUsers(options, cb) { + return this._search('users', options, cb); + } + }]); + + return Search; +}(_Requestable3.default); + +module.exports = Search; +//# sourceMappingURL=data:application/json;base64,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 +//# sourceMappingURL=Search.js.map diff --git a/dist/components/Search.js.map b/dist/components/Search.js.map new file mode 100644 index 00000000..9276c5e8 --- /dev/null +++ b/dist/components/Search.js.map @@ -0,0 +1 @@ +{"version":3,"names":[],"mappings":"","sources":["Search.js"],"sourcesContent":["/**\n * @file\n * @copyright 2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n * Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\nimport debug from 'debug';\nconst log = debug('github:search');\n\n/**\n * Wrap the Search API\n */\nclass Search extends Requestable {\n /**\n * Create a Search\n * @param {Object} defaults - defaults for the search\n * @param {Requestable.auth} [auth] - information required to authenticate to Github\n * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n */\n constructor(defaults, auth, apiBase) {\n super(auth, apiBase);\n this.__defaults = this._getOptionsWithDefaults(defaults);\n }\n\n /**\n * Available search options\n * @see https://developer.github.com/v3/search/#parameters\n * @typedef {Object} Search.Params\n * @param {string} q - the query to make\n * @param {string} sort - the sort field, one of `stars`, `forks`, or `updated`.\n * Default is [best match](https://developer.github.com/v3/search/#ranking-search-results)\n * @param {string} order - the ordering, either `asc` or `desc`\n */\n /**\n * Perform a search on the GitHub API\n * @private\n * @param {string} path - the scope of the search\n * @param {Search.Params} [withOptions] - additional parameters for the search\n * @param {Requestable.callback} [cb] - will receive the results of the search\n * @return {Promise} - the promise for the http request\n */\n _search(path, withOptions = {}, cb = undefined) {\n let requestOptions = {};\n Object.keys(this.__defaults).forEach((prop) => {\n requestOptions[prop] = this.__defaults[prop];\n });\n Object.keys(withOptions).forEach((prop) => {\n requestOptions[prop] = withOptions[prop];\n });\n\n log(`searching ${path} with options:`, requestOptions);\n return this._requestAllPages(`/search/${path}`, requestOptions, cb);\n }\n\n /**\n * Search for repositories\n * @see https://developer.github.com/v3/search/#search-repositories\n * @param {Search.Params} [options] - additional parameters for the search\n * @param {Requestable.callback} [cb] - will receive the results of the search\n * @return {Promise} - the promise for the http request\n */\n forRepositories(options, cb) {\n return this._search('repositories', options, cb);\n }\n\n /**\n * Search for code\n * @see https://developer.github.com/v3/search/#search-code\n * @param {Search.Params} [options] - additional parameters for the search\n * @param {Requestable.callback} [cb] - will receive the results of the search\n * @return {Promise} - the promise for the http request\n */\n forCode(options, cb) {\n return this._search('code', options, cb);\n }\n\n /**\n * Search for issues\n * @see https://developer.github.com/v3/search/#search-issues\n * @param {Search.Params} [options] - additional parameters for the search\n * @param {Requestable.callback} [cb] - will receive the results of the search\n * @return {Promise} - the promise for the http request\n */\n forIssues(options, cb) {\n return this._search('issues', options, cb);\n }\n\n /**\n * Search for users\n * @see https://developer.github.com/v3/search/#search-users\n * @param {Search.Params} [options] - additional parameters for the search\n * @param {Requestable.callback} [cb] - will receive the results of the search\n * @return {Promise} - the promise for the http request\n */\n forUsers(options, cb) {\n return this._search('users', options, cb);\n }\n}\n\nmodule.exports = Search;\n"],"file":"Search.js"} \ No newline at end of file diff --git a/dist/components/Team.js b/dist/components/Team.js new file mode 100644 index 00000000..d0e069d4 --- /dev/null +++ b/dist/components/Team.js @@ -0,0 +1,219 @@ +'use strict'; + +var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); + +var _Requestable2 = require('./Requestable'); + +var _Requestable3 = _interopRequireDefault(_Requestable2); + +var _debug = require('debug'); + +var _debug2 = _interopRequireDefault(_debug); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } + +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } /** + * @file + * @copyright 2016 Matt Smith (Development Seed) + * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}. + * Github.js is freely distributable. + */ + +var log = (0, _debug2.default)('github:team'); + +/** + * A Team allows scoping of API requests to a particular Github Organization Team. + */ + +var Team = function (_Requestable) { + _inherits(Team, _Requestable); + + /** + * Create a Team. + * @param {string} [teamId] - the id for the team + * @param {Requestable.auth} [auth] - information required to authenticate to Github + * @param {string} [apiBase=https://api.github.com] - the base Github API URL + */ + function Team(teamId, auth, apiBase) { + _classCallCheck(this, Team); + + var _this = _possibleConstructorReturn(this, (Team.__proto__ || Object.getPrototypeOf(Team)).call(this, auth, apiBase)); + + _this.__teamId = teamId; + return _this; + } + + /** + * Get Team information + * @see https://developer.github.com/v3/orgs/teams/#get-team + * @param {Requestable.callback} [cb] - will receive the team + * @return {Promise} - the promise for the http request + */ + + + _createClass(Team, [{ + key: 'getTeam', + value: function getTeam(cb) { + log('Fetching Team ' + this.__teamId); + return this._request('Get', '/teams/' + this.__teamId, undefined, cb); + } + + /** + * List the Team's repositories + * @see https://developer.github.com/v3/orgs/teams/#list-team-repos + * @param {Requestable.callback} [cb] - will receive the list of repositories + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'listRepos', + value: function listRepos(cb) { + log('Fetching repositories for Team ' + this.__teamId); + return this._requestAllPages('/teams/' + this.__teamId + '/repos', undefined, cb); + } + + /** + * Edit Team information + * @see https://developer.github.com/v3/orgs/teams/#edit-team + * @param {object} options - Parameters for team edit + * @param {string} options.name - The name of the team + * @param {string} [options.description] - Team description + * @param {string} [options.repo_names] - Repos to add the team to + * @param {string} [options.privacy=secret] - The level of privacy the team should have. Can be either one + * of: `secret`, or `closed` + * @param {Requestable.callback} [cb] - will receive the updated team + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'editTeam', + value: function editTeam(options, cb) { + log('Editing Team ' + this.__teamId); + return this._request('PATCH', '/teams/' + this.__teamId, options, cb); + } + + /** + * List the users who are members of the Team + * @see https://developer.github.com/v3/orgs/teams/#list-team-members + * @param {object} options - Parameters for listing team users + * @param {string} [options.role=all] - can be one of: `all`, `maintainer`, or `member` + * @param {Requestable.callback} [cb] - will receive the list of users + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'listMembers', + value: function listMembers(options, cb) { + log('Getting members of Team ' + this.__teamId); + return this._requestAllPages('/teams/' + this.__teamId + '/members', options, cb); + } + + /** + * Get Team membership status for a user + * @see https://developer.github.com/v3/orgs/teams/#get-team-membership + * @param {string} username - can be one of: `all`, `maintainer`, or `member` + * @param {Requestable.callback} [cb] - will receive the membership status of a user + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'getMembership', + value: function getMembership(username, cb) { + log('Getting membership of user ' + username + ' in Team ' + this.__teamId); + return this._request('GET', '/teams/' + this.__teamId + '/memberships/' + username, undefined, cb); + } + + /** + * Add a member to the Team + * @see https://developer.github.com/v3/orgs/teams/#add-team-membership + * @param {string} username - can be one of: `all`, `maintainer`, or `member` + * @param {object} options - Parameters for adding a team member + * @param {string} [options.role=member] - The role that this user should have in the team. Can be one + * of: `member`, or `maintainer` + * @param {Requestable.callback} [cb] - will receive the membership status of added user + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'addMembership', + value: function addMembership(username, options, cb) { + log('Adding user ' + username + ' to Team ' + this.__teamId); + return this._request('PUT', '/teams/' + this.__teamId + '/memberships/' + username, options, cb); + } + + /** + * Get repo management status for team + * @see https://developer.github.com/v3/orgs/teams/#remove-team-membership + * @param {string} owner - Organization name + * @param {string} repo - Repo name + * @param {Requestable.callback} [cb] - will receive the membership status of added user + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'isManagedRepo', + value: function isManagedRepo(owner, repo, cb) { + log('Getting repo management by Team ' + this.__teamId + ' for repo ' + owner + '/' + repo); + return this._request204or404('/teams/' + this.__teamId + '/repos/' + owner + '/' + repo, undefined, cb); + } + + /** + * Add or Update repo management status for team + * @see https://developer.github.com/v3/orgs/teams/#add-or-update-team-repository + * @param {string} owner - Organization name + * @param {string} repo - Repo name + * @param {object} options - Parameters for adding or updating repo management for the team + * @param {string} [options.permission] - The permission to grant the team on this repository. Can be one + * of: `pull`, `push`, or `admin` + * @param {Requestable.callback} [cb] - will receive the membership status of added user + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'manageRepo', + value: function manageRepo(owner, repo, options, cb) { + log('Adding or Updating repo management by Team ' + this.__teamId + ' for repo ' + owner + '/' + repo); + return this._request204or404('/teams/' + this.__teamId + '/repos/' + owner + '/' + repo, options, cb, 'PUT'); + } + + /** + * Remove repo management status for team + * @see https://developer.github.com/v3/orgs/teams/#remove-team-repository + * @param {string} owner - Organization name + * @param {string} repo - Repo name + * @param {Requestable.callback} [cb] - will receive the membership status of added user + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'unmanageRepo', + value: function unmanageRepo(owner, repo, cb) { + log('Remove repo management by Team ' + this.__teamId + ' for repo ' + owner + '/' + repo); + return this._request204or404('/teams/' + this.__teamId + '/repos/' + owner + '/' + repo, undefined, cb, 'DELETE'); + } + + /** + * Delete Team + * @see https://developer.github.com/v3/orgs/teams/#delete-team + * @param {Requestable.callback} [cb] - will receive the list of repositories + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'deleteTeam', + value: function deleteTeam(cb) { + log('Deleting Team ' + this.__teamId); + return this._request204or404('/teams/' + this.__teamId, undefined, cb, 'DELETE'); + } + }]); + + return Team; +}(_Requestable3.default); + +module.exports = Team; +//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["Team.js"],"names":["log","Team","teamId","auth","apiBase","__teamId","cb","_request","undefined","_requestAllPages","options","username","owner","repo","_request204or404","module","exports"],"mappings":";;;;AAOA;;;;AACA;;;;;;;;;;+eARA;;;;;;;AASA,IAAMA,MAAM,qBAAM,aAAN,CAAZ;;AAEA;;;;IAGMC,I;;;AACH;;;;;;AAMA,gBAAYC,MAAZ,EAAoBC,IAApB,EAA0BC,OAA1B,EAAmC;AAAA;;AAAA,4GAC1BD,IAD0B,EACpBC,OADoB;;AAEhC,UAAKC,QAAL,GAAgBH,MAAhB;AAFgC;AAGlC;;AAED;;;;;;;;;;4BAMQI,E,EAAI;AACTN,6BAAqB,KAAKK,QAA1B;AACA,aAAO,KAAKE,QAAL,CAAc,KAAd,cAA+B,KAAKF,QAApC,EAAgDG,SAAhD,EAA2DF,EAA3D,CAAP;AACF;;AAED;;;;;;;;;8BAMUA,E,EAAI;AACXN,8CAAsC,KAAKK,QAA3C;AACA,aAAO,KAAKI,gBAAL,aAAgC,KAAKJ,QAArC,aAAuDG,SAAvD,EAAkEF,EAAlE,CAAP;AACF;;AAED;;;;;;;;;;;;;;;6BAYSI,O,EAASJ,E,EAAI;AACnBN,4BAAoB,KAAKK,QAAzB;AACA,aAAO,KAAKE,QAAL,CAAc,OAAd,cAAiC,KAAKF,QAAtC,EAAkDK,OAAlD,EAA2DJ,EAA3D,CAAP;AACF;;AAED;;;;;;;;;;;gCAQYI,O,EAASJ,E,EAAI;AACtBN,uCAA+B,KAAKK,QAApC;AACA,aAAO,KAAKI,gBAAL,aAAgC,KAAKJ,QAArC,eAAyDK,OAAzD,EAAkEJ,EAAlE,CAAP;AACF;;AAED;;;;;;;;;;kCAOcK,Q,EAAUL,E,EAAI;AACzBN,0CAAkCW,QAAlC,iBAAsD,KAAKN,QAA3D;AACA,aAAO,KAAKE,QAAL,CAAc,KAAd,cAA+B,KAAKF,QAApC,qBAA4DM,QAA5D,EAAwEH,SAAxE,EAAmFF,EAAnF,CAAP;AACF;;AAED;;;;;;;;;;;;;kCAUcK,Q,EAAUD,O,EAASJ,E,EAAI;AAClCN,2BAAmBW,QAAnB,iBAAuC,KAAKN,QAA5C;AACA,aAAO,KAAKE,QAAL,CAAc,KAAd,cAA+B,KAAKF,QAApC,qBAA4DM,QAA5D,EAAwED,OAAxE,EAAiFJ,EAAjF,CAAP;AACF;;AAED;;;;;;;;;;;kCAQcM,K,EAAOC,I,EAAMP,E,EAAI;AAC5BN,+CAAuC,KAAKK,QAA5C,kBAAiEO,KAAjE,SAA0EC,IAA1E;AACA,aAAO,KAAKC,gBAAL,aAAgC,KAAKT,QAArC,eAAuDO,KAAvD,SAAgEC,IAAhE,EAAwEL,SAAxE,EAAmFF,EAAnF,CAAP;AACF;;AAED;;;;;;;;;;;;;;+BAWWM,K,EAAOC,I,EAAMH,O,EAASJ,E,EAAI;AAClCN,0DAAkD,KAAKK,QAAvD,kBAA4EO,KAA5E,SAAqFC,IAArF;AACA,aAAO,KAAKC,gBAAL,aAAgC,KAAKT,QAArC,eAAuDO,KAAvD,SAAgEC,IAAhE,EAAwEH,OAAxE,EAAiFJ,EAAjF,EAAqF,KAArF,CAAP;AACF;;AAED;;;;;;;;;;;iCAQaM,K,EAAOC,I,EAAMP,E,EAAI;AAC3BN,8CAAsC,KAAKK,QAA3C,kBAAgEO,KAAhE,SAAyEC,IAAzE;AACA,aAAO,KAAKC,gBAAL,aAAgC,KAAKT,QAArC,eAAuDO,KAAvD,SAAgEC,IAAhE,EAAwEL,SAAxE,EAAmFF,EAAnF,EAAuF,QAAvF,CAAP;AACF;;AAED;;;;;;;;;+BAMWA,E,EAAI;AACZN,6BAAqB,KAAKK,QAA1B;AACA,aAAO,KAAKS,gBAAL,aAAgC,KAAKT,QAArC,EAAiDG,SAAjD,EAA4DF,EAA5D,EAAgE,QAAhE,CAAP;AACF;;;;;;AAGJS,OAAOC,OAAP,GAAiBf,IAAjB","file":"Team.js","sourcesContent":["/**\n * @file\n * @copyright  2016 Matt Smith (Development Seed)\n * @license    Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n *             Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\nimport debug from 'debug';\nconst log = debug('github:team');\n\n/**\n * A Team allows scoping of API requests to a particular Github Organization Team.\n */\nclass Team extends Requestable {\n   /**\n    * Create a Team.\n    * @param {string} [teamId] - the id for the team\n    * @param {Requestable.auth} [auth] - information required to authenticate to Github\n    * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n    */\n   constructor(teamId, auth, apiBase) {\n      super(auth, apiBase);\n      this.__teamId = teamId;\n   }\n\n   /**\n    * Get Team information\n    * @see https://developer.github.com/v3/orgs/teams/#get-team\n    * @param {Requestable.callback} [cb] - will receive the team\n    * @return {Promise} - the promise for the http request\n    */\n   getTeam(cb) {\n      log(`Fetching Team ${this.__teamId}`);\n      return this._request('Get', `/teams/${this.__teamId}`, undefined, cb);\n   }\n\n   /**\n    * List the Team's repositories\n    * @see https://developer.github.com/v3/orgs/teams/#list-team-repos\n    * @param {Requestable.callback} [cb] - will receive the list of repositories\n    * @return {Promise} - the promise for the http request\n    */\n   listRepos(cb) {\n      log(`Fetching repositories for Team ${this.__teamId}`);\n      return this._requestAllPages(`/teams/${this.__teamId}/repos`, undefined, cb);\n   }\n\n   /**\n    * Edit Team information\n    * @see https://developer.github.com/v3/orgs/teams/#edit-team\n    * @param {object} options - Parameters for team edit\n    * @param {string} options.name - The name of the team\n    * @param {string} [options.description] - Team description\n    * @param {string} [options.repo_names] - Repos to add the team to\n    * @param {string} [options.privacy=secret] - The level of privacy the team should have. Can be either one\n    * of: `secret`, or `closed`\n    * @param {Requestable.callback} [cb] - will receive the updated team\n    * @return {Promise} - the promise for the http request\n    */\n   editTeam(options, cb) {\n      log(`Editing Team ${this.__teamId}`);\n      return this._request('PATCH', `/teams/${this.__teamId}`, options, cb);\n   }\n\n   /**\n    * List the users who are members of the Team\n    * @see https://developer.github.com/v3/orgs/teams/#list-team-members\n    * @param {object} options - Parameters for listing team users\n    * @param {string} [options.role=all] - can be one of: `all`, `maintainer`, or `member`\n    * @param {Requestable.callback} [cb] - will receive the list of users\n    * @return {Promise} - the promise for the http request\n    */\n   listMembers(options, cb) {\n      log(`Getting members of Team ${this.__teamId}`);\n      return this._requestAllPages(`/teams/${this.__teamId}/members`, options, cb);\n   }\n\n   /**\n    * Get Team membership status for a user\n    * @see https://developer.github.com/v3/orgs/teams/#get-team-membership\n    * @param {string} username - can be one of: `all`, `maintainer`, or `member`\n    * @param {Requestable.callback} [cb] - will receive the membership status of a user\n    * @return {Promise} - the promise for the http request\n    */\n   getMembership(username, cb) {\n      log(`Getting membership of user ${username} in Team ${this.__teamId}`);\n      return this._request('GET', `/teams/${this.__teamId}/memberships/${username}`, undefined, cb);\n   }\n\n   /**\n    * Add a member to the Team\n    * @see https://developer.github.com/v3/orgs/teams/#add-team-membership\n    * @param {string} username - can be one of: `all`, `maintainer`, or `member`\n    * @param {object} options - Parameters for adding a team member\n    * @param {string} [options.role=member] - The role that this user should have in the team. Can be one\n    * of: `member`, or `maintainer`\n    * @param {Requestable.callback} [cb] - will receive the membership status of added user\n    * @return {Promise} - the promise for the http request\n    */\n   addMembership(username, options, cb) {\n      log(`Adding user ${username} to Team ${this.__teamId}`);\n      return this._request('PUT', `/teams/${this.__teamId}/memberships/${username}`, options, cb);\n   }\n\n   /**\n    * Get repo management status for team\n    * @see https://developer.github.com/v3/orgs/teams/#remove-team-membership\n    * @param {string} owner - Organization name\n    * @param {string} repo - Repo name\n    * @param {Requestable.callback} [cb] - will receive the membership status of added user\n    * @return {Promise} - the promise for the http request\n    */\n   isManagedRepo(owner, repo, cb) {\n      log(`Getting repo management by Team ${this.__teamId} for repo ${owner}/${repo}`);\n      return this._request204or404(`/teams/${this.__teamId}/repos/${owner}/${repo}`, undefined, cb);\n   }\n\n   /**\n    * Add or Update repo management status for team\n    * @see https://developer.github.com/v3/orgs/teams/#add-or-update-team-repository\n    * @param {string} owner - Organization name\n    * @param {string} repo - Repo name\n    * @param {object} options - Parameters for adding or updating repo management for the team\n    * @param {string} [options.permission] - The permission to grant the team on this repository. Can be one\n    * of: `pull`, `push`, or `admin`\n    * @param {Requestable.callback} [cb] - will receive the membership status of added user\n    * @return {Promise} - the promise for the http request\n    */\n   manageRepo(owner, repo, options, cb) {\n      log(`Adding or Updating repo management by Team ${this.__teamId} for repo ${owner}/${repo}`);\n      return this._request204or404(`/teams/${this.__teamId}/repos/${owner}/${repo}`, options, cb, 'PUT');\n   }\n\n   /**\n    * Remove repo management status for team\n    * @see https://developer.github.com/v3/orgs/teams/#remove-team-repository\n    * @param {string} owner - Organization name\n    * @param {string} repo - Repo name\n    * @param {Requestable.callback} [cb] - will receive the membership status of added user\n    * @return {Promise} - the promise for the http request\n    */\n   unmanageRepo(owner, repo, cb) {\n      log(`Remove repo management by Team ${this.__teamId} for repo ${owner}/${repo}`);\n      return this._request204or404(`/teams/${this.__teamId}/repos/${owner}/${repo}`, undefined, cb, 'DELETE');\n   }\n\n   /**\n    * Delete Team\n    * @see https://developer.github.com/v3/orgs/teams/#delete-team\n    * @param {Requestable.callback} [cb] - will receive the list of repositories\n    * @return {Promise} - the promise for the http request\n    */\n   deleteTeam(cb) {\n      log(`Deleting Team ${this.__teamId}`);\n      return this._request204or404(`/teams/${this.__teamId}`, undefined, cb, 'DELETE');\n   }\n}\n\nmodule.exports = Team;\n"]} +//# sourceMappingURL=Team.js.map diff --git a/dist/components/Team.js.map b/dist/components/Team.js.map new file mode 100644 index 00000000..d7323e92 --- /dev/null +++ b/dist/components/Team.js.map @@ -0,0 +1 @@ +{"version":3,"names":[],"mappings":"","sources":["Team.js"],"sourcesContent":["/**\n * @file\n * @copyright 2016 Matt Smith (Development Seed)\n * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n * Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\nimport debug from 'debug';\nconst log = debug('github:team');\n\n/**\n * A Team allows scoping of API requests to a particular Github Organization Team.\n */\nclass Team extends Requestable {\n /**\n * Create a Team.\n * @param {string} [teamId] - the id for the team\n * @param {Requestable.auth} [auth] - information required to authenticate to Github\n * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n */\n constructor(teamId, auth, apiBase) {\n super(auth, apiBase);\n this.__teamId = teamId;\n }\n\n /**\n * Get Team information\n * @see https://developer.github.com/v3/orgs/teams/#get-team\n * @param {Requestable.callback} [cb] - will receive the team\n * @return {Promise} - the promise for the http request\n */\n getTeam(cb) {\n log(`Fetching Team ${this.__teamId}`);\n return this._request('Get', `/teams/${this.__teamId}`, undefined, cb);\n }\n\n /**\n * List the Team's repositories\n * @see https://developer.github.com/v3/orgs/teams/#list-team-repos\n * @param {Requestable.callback} [cb] - will receive the list of repositories\n * @return {Promise} - the promise for the http request\n */\n listRepos(cb) {\n log(`Fetching repositories for Team ${this.__teamId}`);\n return this._requestAllPages(`/teams/${this.__teamId}/repos`, undefined, cb);\n }\n\n /**\n * Edit Team information\n * @see https://developer.github.com/v3/orgs/teams/#edit-team\n * @param {object} options - Parameters for team edit\n * @param {string} options.name - The name of the team\n * @param {string} [options.description] - Team description\n * @param {string} [options.repo_names] - Repos to add the team to\n * @param {string} [options.privacy=secret] - The level of privacy the team should have. Can be either one\n * of: `secret`, or `closed`\n * @param {Requestable.callback} [cb] - will receive the updated team\n * @return {Promise} - the promise for the http request\n */\n editTeam(options, cb) {\n log(`Editing Team ${this.__teamId}`);\n return this._request('PATCH', `/teams/${this.__teamId}`, options, cb);\n }\n\n /**\n * List the users who are members of the Team\n * @see https://developer.github.com/v3/orgs/teams/#list-team-members\n * @param {object} options - Parameters for listing team users\n * @param {string} [options.role=all] - can be one of: `all`, `maintainer`, or `member`\n * @param {Requestable.callback} [cb] - will receive the list of users\n * @return {Promise} - the promise for the http request\n */\n listMembers(options, cb) {\n log(`Getting members of Team ${this.__teamId}`);\n return this._requestAllPages(`/teams/${this.__teamId}/members`, options, cb);\n }\n\n /**\n * Get Team membership status for a user\n * @see https://developer.github.com/v3/orgs/teams/#get-team-membership\n * @param {string} username - can be one of: `all`, `maintainer`, or `member`\n * @param {Requestable.callback} [cb] - will receive the membership status of a user\n * @return {Promise} - the promise for the http request\n */\n getMembership(username, cb) {\n log(`Getting membership of user ${username} in Team ${this.__teamId}`);\n return this._request('GET', `/teams/${this.__teamId}/memberships/${username}`, undefined, cb);\n }\n\n /**\n * Add a member to the Team\n * @see https://developer.github.com/v3/orgs/teams/#add-team-membership\n * @param {string} username - can be one of: `all`, `maintainer`, or `member`\n * @param {object} options - Parameters for adding a team member\n * @param {string} [options.role=member] - The role that this user should have in the team. Can be one\n * of: `member`, or `maintainer`\n * @param {Requestable.callback} [cb] - will receive the membership status of added user\n * @return {Promise} - the promise for the http request\n */\n addMembership(username, options, cb) {\n log(`Adding user ${username} to Team ${this.__teamId}`);\n return this._request('PUT', `/teams/${this.__teamId}/memberships/${username}`, options, cb);\n }\n\n /**\n * Get repo management status for team\n * @see https://developer.github.com/v3/orgs/teams/#remove-team-membership\n * @param {string} owner - Organization name\n * @param {string} repo - Repo name\n * @param {Requestable.callback} [cb] - will receive the membership status of added user\n * @return {Promise} - the promise for the http request\n */\n isManagedRepo(owner, repo, cb) {\n log(`Getting repo management by Team ${this.__teamId} for repo ${owner}/${repo}`);\n return this._request204or404(`/teams/${this.__teamId}/repos/${owner}/${repo}`, undefined, cb);\n }\n\n /**\n * Add or Update repo management status for team\n * @see https://developer.github.com/v3/orgs/teams/#add-or-update-team-repository\n * @param {string} owner - Organization name\n * @param {string} repo - Repo name\n * @param {object} options - Parameters for adding or updating repo management for the team\n * @param {string} [options.permission] - The permission to grant the team on this repository. Can be one\n * of: `pull`, `push`, or `admin`\n * @param {Requestable.callback} [cb] - will receive the membership status of added user\n * @return {Promise} - the promise for the http request\n */\n manageRepo(owner, repo, options, cb) {\n log(`Adding or Updating repo management by Team ${this.__teamId} for repo ${owner}/${repo}`);\n return this._request204or404(`/teams/${this.__teamId}/repos/${owner}/${repo}`, options, cb, 'PUT');\n }\n\n /**\n * Remove repo management status for team\n * @see https://developer.github.com/v3/orgs/teams/#remove-team-repository\n * @param {string} owner - Organization name\n * @param {string} repo - Repo name\n * @param {Requestable.callback} [cb] - will receive the membership status of added user\n * @return {Promise} - the promise for the http request\n */\n unmanageRepo(owner, repo, cb) {\n log(`Remove repo management by Team ${this.__teamId} for repo ${owner}/${repo}`);\n return this._request204or404(`/teams/${this.__teamId}/repos/${owner}/${repo}`, undefined, cb, 'DELETE');\n }\n\n /**\n * Delete Team\n * @see https://developer.github.com/v3/orgs/teams/#delete-team\n * @param {Requestable.callback} [cb] - will receive the list of repositories\n * @return {Promise} - the promise for the http request\n */\n deleteTeam(cb) {\n log(`Deleting Team ${this.__teamId}`);\n return this._request204or404(`/teams/${this.__teamId}`, undefined, cb, 'DELETE');\n }\n}\n\nmodule.exports = Team;\n"],"file":"Team.js"} \ No newline at end of file diff --git a/dist/components/User.js b/dist/components/User.js new file mode 100644 index 00000000..323be78c --- /dev/null +++ b/dist/components/User.js @@ -0,0 +1,264 @@ +'use strict'; + +var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); + +var _Requestable2 = require('./Requestable'); + +var _Requestable3 = _interopRequireDefault(_Requestable2); + +var _debug = require('debug'); + +var _debug2 = _interopRequireDefault(_debug); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } + +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } /** + * @file + * @copyright 2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc. + * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}. + * Github.js is freely distributable. + */ + +var log = (0, _debug2.default)('github:user'); + +/** + * A User allows scoping of API requests to a particular Github user. + */ + +var User = function (_Requestable) { + _inherits(User, _Requestable); + + /** + * Create a User. + * @param {string} [username] - the user to use for user-scoped queries + * @param {Requestable.auth} [auth] - information required to authenticate to Github + * @param {string} [apiBase=https://api.github.com] - the base Github API URL + */ + function User(username, auth, apiBase) { + _classCallCheck(this, User); + + var _this = _possibleConstructorReturn(this, (User.__proto__ || Object.getPrototypeOf(User)).call(this, auth, apiBase)); + + _this.__user = username; + return _this; + } + + /** + * Get the url for the request. (dependent on if we're requesting for the authenticated user or not) + * @private + * @param {string} endpoint - the endpoint being requested + * @return {string} - the resolved endpoint + */ + + + _createClass(User, [{ + key: '__getScopedUrl', + value: function __getScopedUrl(endpoint) { + if (this.__user) { + return endpoint ? '/users/' + this.__user + '/' + endpoint : '/users/' + this.__user; + } else { + // eslint-disable-line + switch (endpoint) { + case '': + return '/user'; + + case 'notifications': + case 'gists': + return '/' + endpoint; + + default: + return '/user/' + endpoint; + } + } + } + + /** + * List the user's repositories + * @see https://developer.github.com/v3/repos/#list-user-repositories + * @param {Object} [options={}] - any options to refine the search + * @param {Requestable.callback} [cb] - will receive the list of repositories + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'listRepos', + value: function listRepos(options, cb) { + if (typeof options === 'function') { + cb = options; + options = {}; + } + + options = this._getOptionsWithDefaults(options); + + log('Fetching repositories with options: ' + JSON.stringify(options)); + return this._requestAllPages(this.__getScopedUrl('repos'), options, cb); + } + + /** + * List the orgs that the user belongs to + * @see https://developer.github.com/v3/orgs/#list-user-organizations + * @param {Requestable.callback} [cb] - will receive the list of organizations + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'listOrgs', + value: function listOrgs(cb) { + return this._request('GET', this.__getScopedUrl('orgs'), null, cb); + } + + /** + * List the user's gists + * @see https://developer.github.com/v3/gists/#list-a-users-gists + * @param {Requestable.callback} [cb] - will receive the list of gists + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'listGists', + value: function listGists(cb) { + return this._request('GET', this.__getScopedUrl('gists'), null, cb); + } + + /** + * List the user's starred gists + * @see https://developer.github.com/v3/gists/#list-starred-gists + * @param {Requestable.callback} [cb] - will receive the list of gists + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'listStarredGists', + value: function listStarredGists(cb) { + return this._request('GET', this.__getScopedUrl('gists/starred'), null, cb); + } + + /** + * List the user's gists + * @see https://developer.github.com/v3/gists/#list-a-users-gists + * @param {Requestable.callback} [cb] - will receive the list of gists + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'listStarredGists', + value: function listStarredGists(cb) { + return this._request('GET', this.__getScopedUrl('gists'), null, cb); + } + + /** + * List the user's notifications + * @see https://developer.github.com/v3/activity/notifications/#list-your-notifications + * @param {Object} [options={}] - any options to refine the search + * @param {Requestable.callback} [cb] - will receive the list of repositories + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'listNotifications', + value: function listNotifications(options, cb) { + options = options || {}; + if (typeof options === 'function') { + cb = options; + options = {}; + } + + options.since = this._dateToISO(options.since); + options.before = this._dateToISO(options.before); + + return this._request('GET', this.__getScopedUrl('notifications'), options, cb); + } + + /** + * Show the user's profile + * @see https://developer.github.com/v3/users/#get-a-single-user + * @param {Requestable.callback} [cb] - will receive the user's information + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'getProfile', + value: function getProfile(cb) { + return this._request('GET', this.__getScopedUrl(''), null, cb); + } + + /** + * Gets the list of starred repositories for the user + * @see https://developer.github.com/v3/activity/starring/#list-repositories-being-starred + * @param {Requestable.callback} [cb] - will receive the list of starred repositories + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'listStarredRepos', + value: function listStarredRepos(cb) { + var requestOptions = this._getOptionsWithDefaults(); + return this._requestAllPages(this.__getScopedUrl('starred'), requestOptions, cb); + } + + /** + * List email addresses for a user + * @see https://developer.github.com/v3/users/emails/#list-email-addresses-for-a-user + * @param {Requestable.callback} [cb] - will receive the list of emails + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'getEmails', + value: function getEmails(cb) { + return this._request('GET', '/user/emails', null, cb); + } + + /** + * Have the authenticated user follow this user + * @see https://developer.github.com/v3/users/followers/#follow-a-user + * @param {string} username - the user to follow + * @param {Requestable.callback} [cb] - will receive true if the request succeeds + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'follow', + value: function follow(username, cb) { + return this._request('PUT', '/user/following/' + this.__user, null, cb); + } + + /** + * Have the currently authenticated user unfollow this user + * @see https://developer.github.com/v3/users/followers/#follow-a-user + * @param {string} username - the user to unfollow + * @param {Requestable.callback} [cb] - receives true if the request succeeds + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'unfollow', + value: function unfollow(username, cb) { + return this._request('DELETE', '/user/following/' + this.__user, null, cb); + } + + /** + * Create a new repository for the currently authenticated user + * @see https://developer.github.com/v3/repos/#create + * @param {object} options - the repository definition + * @param {Requestable.callback} [cb] - will receive the API response + * @return {Promise} - the promise for the http request + */ + + }, { + key: 'createRepo', + value: function createRepo(options, cb) { + return this._request('POST', '/user/repos', options, cb); + } + }]); + + return User; +}(_Requestable3.default); + +module.exports = User; +//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["User.js"],"names":["log","User","username","auth","apiBase","__user","endpoint","options","cb","_getOptionsWithDefaults","JSON","stringify","_requestAllPages","__getScopedUrl","_request","since","_dateToISO","before","requestOptions","module","exports"],"mappings":"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","file":"User.js","sourcesContent":["/**\n * @file\n * @copyright  2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license    Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n *             Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\nimport debug from 'debug';\nconst log = debug('github:user');\n\n/**\n * A User allows scoping of API requests to a particular Github user.\n */\nclass User extends Requestable {\n   /**\n    * Create a User.\n    * @param {string} [username] - the user to use for user-scoped queries\n    * @param {Requestable.auth} [auth] - information required to authenticate to Github\n    * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n    */\n   constructor(username, auth, apiBase) {\n      super(auth, apiBase);\n      this.__user = username;\n   }\n\n   /**\n    * Get the url for the request. (dependent on if we're requesting for the authenticated user or not)\n    * @private\n    * @param {string} endpoint - the endpoint being requested\n    * @return {string} - the resolved endpoint\n    */\n   __getScopedUrl(endpoint) {\n      if (this.__user) {\n         return endpoint ?\n            `/users/${this.__user}/${endpoint}` :\n            `/users/${this.__user}`\n            ;\n\n      } else { // eslint-disable-line\n         switch (endpoint) {\n            case '':\n               return '/user';\n\n            case 'notifications':\n            case 'gists':\n               return `/${endpoint}`;\n\n            default:\n               return `/user/${endpoint}`;\n         }\n      }\n   }\n\n   /**\n    * List the user's repositories\n    * @see https://developer.github.com/v3/repos/#list-user-repositories\n    * @param {Object} [options={}] - any options to refine the search\n    * @param {Requestable.callback} [cb] - will receive the list of repositories\n    * @return {Promise} - the promise for the http request\n    */\n   listRepos(options, cb) {\n      if (typeof options === 'function') {\n         cb = options;\n         options = {};\n      }\n\n      options = this._getOptionsWithDefaults(options);\n\n      log(`Fetching repositories with options: ${JSON.stringify(options)}`);\n      return this._requestAllPages(this.__getScopedUrl('repos'), options, cb);\n   }\n\n   /**\n    * List the orgs that the user belongs to\n    * @see https://developer.github.com/v3/orgs/#list-user-organizations\n    * @param {Requestable.callback} [cb] - will receive the list of organizations\n    * @return {Promise} - the promise for the http request\n    */\n   listOrgs(cb) {\n      return this._request('GET', this.__getScopedUrl('orgs'), null, cb);\n   }\n\n   /**\n    * List the user's gists\n    * @see https://developer.github.com/v3/gists/#list-a-users-gists\n    * @param {Requestable.callback} [cb] - will receive the list of gists\n    * @return {Promise} - the promise for the http request\n    */\n   listGists(cb) {\n      return this._request('GET', this.__getScopedUrl('gists'), null, cb);\n   }\n\n   /**\n    * List the user's starred gists\n    * @see https://developer.github.com/v3/gists/#list-starred-gists\n    * @param {Requestable.callback} [cb] - will receive the list of gists\n    * @return {Promise} - the promise for the http request\n    */\n   listStarredGists(cb) {\n      return this._request('GET', this.__getScopedUrl('gists/starred'), null, cb);\n   }\n\n   /**\n    * List the user's gists\n    * @see https://developer.github.com/v3/gists/#list-a-users-gists\n    * @param {Requestable.callback} [cb] - will receive the list of gists\n    * @return {Promise} - the promise for the http request\n    */\n   listStarredGists(cb) {\n      return this._request('GET', this.__getScopedUrl('gists'), null, cb);\n   }\n\n   /**\n    * List the user's notifications\n    * @see https://developer.github.com/v3/activity/notifications/#list-your-notifications\n    * @param {Object} [options={}] - any options to refine the search\n    * @param {Requestable.callback} [cb] - will receive the list of repositories\n    * @return {Promise} - the promise for the http request\n    */\n   listNotifications(options, cb) {\n      options = options || {};\n      if (typeof options === 'function') {\n         cb = options;\n         options = {};\n      }\n\n      options.since = this._dateToISO(options.since);\n      options.before = this._dateToISO(options.before);\n\n      return this._request('GET', this.__getScopedUrl('notifications'), options, cb);\n   }\n\n   /**\n    * Show the user's profile\n    * @see https://developer.github.com/v3/users/#get-a-single-user\n    * @param {Requestable.callback} [cb] - will receive the user's information\n    * @return {Promise} - the promise for the http request\n    */\n   getProfile(cb) {\n      return this._request('GET', this.__getScopedUrl(''), null, cb);\n   }\n\n   /**\n    * Gets the list of starred repositories for the user\n    * @see https://developer.github.com/v3/activity/starring/#list-repositories-being-starred\n    * @param {Requestable.callback} [cb] - will receive the list of starred repositories\n    * @return {Promise} - the promise for the http request\n    */\n   listStarredRepos(cb) {\n      let requestOptions = this._getOptionsWithDefaults();\n      return this._requestAllPages(this.__getScopedUrl('starred'), requestOptions, cb);\n   }\n\n   /**\n    * List email addresses for a user\n    * @see https://developer.github.com/v3/users/emails/#list-email-addresses-for-a-user\n    * @param {Requestable.callback} [cb] - will receive the list of emails\n    * @return {Promise} - the promise for the http request\n    */\n   getEmails(cb) {\n      return this._request('GET', '/user/emails', null, cb);\n   }\n\n   /**\n    * Have the authenticated user follow this user\n    * @see https://developer.github.com/v3/users/followers/#follow-a-user\n    * @param {string} username - the user to follow\n    * @param {Requestable.callback} [cb] - will receive true if the request succeeds\n    * @return {Promise} - the promise for the http request\n    */\n   follow(username, cb) {\n      return this._request('PUT', `/user/following/${this.__user}`, null, cb);\n   }\n\n   /**\n    * Have the currently authenticated user unfollow this user\n    * @see https://developer.github.com/v3/users/followers/#follow-a-user\n    * @param {string} username - the user to unfollow\n    * @param {Requestable.callback} [cb] - receives true if the request succeeds\n    * @return {Promise} - the promise for the http request\n    */\n   unfollow(username, cb) {\n      return this._request('DELETE', `/user/following/${this.__user}`, null, cb);\n   }\n\n   /**\n    * Create a new repository for the currently authenticated user\n    * @see https://developer.github.com/v3/repos/#create\n    * @param {object} options - the repository definition\n    * @param {Requestable.callback} [cb] - will receive the API response\n    * @return {Promise} - the promise for the http request\n    */\n   createRepo(options, cb) {\n      return this._request('POST', '/user/repos', options, cb);\n   }\n}\n\nmodule.exports = User;\n"]} +//# sourceMappingURL=User.js.map diff --git a/dist/components/User.js.map b/dist/components/User.js.map new file mode 100644 index 00000000..69accc37 --- /dev/null +++ b/dist/components/User.js.map @@ -0,0 +1 @@ +{"version":3,"names":[],"mappings":"","sources":["User.js"],"sourcesContent":["/**\n * @file\n * @copyright 2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n * Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\nimport debug from 'debug';\nconst log = debug('github:user');\n\n/**\n * A User allows scoping of API requests to a particular Github user.\n */\nclass User extends Requestable {\n /**\n * Create a User.\n * @param {string} [username] - the user to use for user-scoped queries\n * @param {Requestable.auth} [auth] - information required to authenticate to Github\n * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n */\n constructor(username, auth, apiBase) {\n super(auth, apiBase);\n this.__user = username;\n }\n\n /**\n * Get the url for the request. (dependent on if we're requesting for the authenticated user or not)\n * @private\n * @param {string} endpoint - the endpoint being requested\n * @return {string} - the resolved endpoint\n */\n __getScopedUrl(endpoint) {\n if (this.__user) {\n return endpoint ?\n `/users/${this.__user}/${endpoint}` :\n `/users/${this.__user}`\n ;\n\n } else { // eslint-disable-line\n switch (endpoint) {\n case '':\n return '/user';\n\n case 'notifications':\n case 'gists':\n return `/${endpoint}`;\n\n default:\n return `/user/${endpoint}`;\n }\n }\n }\n\n /**\n * List the user's repositories\n * @see https://developer.github.com/v3/repos/#list-user-repositories\n * @param {Object} [options={}] - any options to refine the search\n * @param {Requestable.callback} [cb] - will receive the list of repositories\n * @return {Promise} - the promise for the http request\n */\n listRepos(options, cb) {\n if (typeof options === 'function') {\n cb = options;\n options = {};\n }\n\n options = this._getOptionsWithDefaults(options);\n\n log(`Fetching repositories with options: ${JSON.stringify(options)}`);\n return this._requestAllPages(this.__getScopedUrl('repos'), options, cb);\n }\n\n /**\n * List the orgs that the user belongs to\n * @see https://developer.github.com/v3/orgs/#list-user-organizations\n * @param {Requestable.callback} [cb] - will receive the list of organizations\n * @return {Promise} - the promise for the http request\n */\n listOrgs(cb) {\n return this._request('GET', this.__getScopedUrl('orgs'), null, cb);\n }\n\n /**\n * List the user's gists\n * @see https://developer.github.com/v3/gists/#list-a-users-gists\n * @param {Requestable.callback} [cb] - will receive the list of gists\n * @return {Promise} - the promise for the http request\n */\n listGists(cb) {\n return this._request('GET', this.__getScopedUrl('gists'), null, cb);\n }\n\n /**\n * List the user's starred gists\n * @see https://developer.github.com/v3/gists/#list-starred-gists\n * @param {Requestable.callback} [cb] - will receive the list of gists\n * @return {Promise} - the promise for the http request\n */\n listStarredGists(cb) {\n return this._request('GET', this.__getScopedUrl('gists/starred'), null, cb);\n }\n\n /**\n * List the user's gists\n * @see https://developer.github.com/v3/gists/#list-a-users-gists\n * @param {Requestable.callback} [cb] - will receive the list of gists\n * @return {Promise} - the promise for the http request\n */\n listStarredGists(cb) {\n return this._request('GET', this.__getScopedUrl('gists'), null, cb);\n }\n\n /**\n * List the user's notifications\n * @see https://developer.github.com/v3/activity/notifications/#list-your-notifications\n * @param {Object} [options={}] - any options to refine the search\n * @param {Requestable.callback} [cb] - will receive the list of repositories\n * @return {Promise} - the promise for the http request\n */\n listNotifications(options, cb) {\n options = options || {};\n if (typeof options === 'function') {\n cb = options;\n options = {};\n }\n\n options.since = this._dateToISO(options.since);\n options.before = this._dateToISO(options.before);\n\n return this._request('GET', this.__getScopedUrl('notifications'), options, cb);\n }\n\n /**\n * Show the user's profile\n * @see https://developer.github.com/v3/users/#get-a-single-user\n * @param {Requestable.callback} [cb] - will receive the user's information\n * @return {Promise} - the promise for the http request\n */\n getProfile(cb) {\n return this._request('GET', this.__getScopedUrl(''), null, cb);\n }\n\n /**\n * Gets the list of starred repositories for the user\n * @see https://developer.github.com/v3/activity/starring/#list-repositories-being-starred\n * @param {Requestable.callback} [cb] - will receive the list of starred repositories\n * @return {Promise} - the promise for the http request\n */\n listStarredRepos(cb) {\n let requestOptions = this._getOptionsWithDefaults();\n return this._requestAllPages(this.__getScopedUrl('starred'), requestOptions, cb);\n }\n\n /**\n * List email addresses for a user\n * @see https://developer.github.com/v3/users/emails/#list-email-addresses-for-a-user\n * @param {Requestable.callback} [cb] - will receive the list of emails\n * @return {Promise} - the promise for the http request\n */\n getEmails(cb) {\n return this._request('GET', '/user/emails', null, cb);\n }\n\n /**\n * Have the authenticated user follow this user\n * @see https://developer.github.com/v3/users/followers/#follow-a-user\n * @param {string} username - the user to follow\n * @param {Requestable.callback} [cb] - will receive true if the request succeeds\n * @return {Promise} - the promise for the http request\n */\n follow(username, cb) {\n return this._request('PUT', `/user/following/${this.__user}`, null, cb);\n }\n\n /**\n * Have the currently authenticated user unfollow this user\n * @see https://developer.github.com/v3/users/followers/#follow-a-user\n * @param {string} username - the user to unfollow\n * @param {Requestable.callback} [cb] - receives true if the request succeeds\n * @return {Promise} - the promise for the http request\n */\n unfollow(username, cb) {\n return this._request('DELETE', `/user/following/${this.__user}`, null, cb);\n }\n\n /**\n * Create a new repository for the currently authenticated user\n * @see https://developer.github.com/v3/repos/#create\n * @param {object} options - the repository definition\n * @param {Requestable.callback} [cb] - will receive the API response\n * @return {Promise} - the promise for the http request\n */\n createRepo(options, cb) {\n return this._request('POST', '/user/repos', options, cb);\n }\n}\n\nmodule.exports = User;\n"],"file":"User.js"} \ No newline at end of file From ddfd8f3cb5f5f8cc2fae51832d4ad85cec9b4d0f Mon Sep 17 00:00:00 2001 From: Jan Hoffmann Date: Tue, 31 Jan 2017 17:10:22 +0100 Subject: [PATCH 4/4] Added missing func to the builded version --- dist/GitHub.bundle.js | 13 ------------- dist/GitHub.bundle.js.map | 2 +- dist/GitHub.bundle.min.js | 4 ++-- dist/GitHub.bundle.min.js.map | 2 +- dist/GitHub.js | 13 ------------- dist/GitHub.js.map | 2 +- dist/GitHub.min.js | 2 +- dist/GitHub.min.js.map | 2 +- dist/components/User.js | 15 +-------------- dist/components/User.js.map | 2 +- lib/User.js | 10 ---------- 11 files changed, 9 insertions(+), 58 deletions(-) diff --git a/dist/GitHub.bundle.js b/dist/GitHub.bundle.js index eb0857b6..e0cc28f7 100644 --- a/dist/GitHub.bundle.js +++ b/dist/GitHub.bundle.js @@ -3401,19 +3401,6 @@ var User = function (_Requestable) { return this._request('GET', this.__getScopedUrl('gists/starred'), null, cb); } - /** - * List the user's gists - * @see https://developer.github.com/v3/gists/#list-a-users-gists - * @param {Requestable.callback} [cb] - will receive the list of gists - * @return {Promise} - the promise for the http request - */ - - }, { - key: 'listStarredGists', - value: function listStarredGists(cb) { - return this._request('GET', this.__getScopedUrl('gists'), null, cb); - } - /** * List the user's notifications * @see https://developer.github.com/v3/activity/notifications/#list-your-notifications diff --git a/dist/GitHub.bundle.js.map b/dist/GitHub.bundle.js.map index 245e776f..7a5fa0ba 100644 --- a/dist/GitHub.bundle.js.map +++ b/dist/GitHub.bundle.js.map @@ -1 +1 @@ -{"version":3,"sources":["node_modules/browser-pack/_prelude.js","lib/Gist.js","lib/GitHub.js","lib/Issue.js","lib/Markdown.js","lib/Organization.js","lib/Project.js","lib/RateLimit.js","lib/Repository.js","lib/Requestable.js","lib/Search.js","lib/Team.js","lib/User.js","node_modules/axios/index.js","node_modules/axios/lib/adapters/xhr.js","node_modules/axios/lib/axios.js","node_modules/axios/lib/cancel/Cancel.js","node_modules/axios/lib/cancel/CancelToken.js","node_modules/axios/lib/cancel/isCancel.js","node_modules/axios/lib/core/Axios.js","node_modules/axios/lib/core/InterceptorManager.js","node_modules/axios/lib/core/createError.js","node_modules/axios/lib/core/dispatchRequest.js","node_modules/axios/lib/core/enhanceError.js","node_modules/axios/lib/core/settle.js","node_modules/axios/lib/core/transformData.js","node_modules/axios/lib/defaults.js","node_modules/axios/lib/helpers/bind.js","node_modules/axios/lib/helpers/btoa.js","node_modules/axios/lib/helpers/buildURL.js","node_modules/axios/lib/helpers/combineURLs.js","node_modules/axios/lib/helpers/cookies.js","node_modules/axios/lib/helpers/isAbsoluteURL.js","node_modules/axios/lib/helpers/isURLSameOrigin.js","node_modules/axios/lib/helpers/normalizeHeaderName.js","node_modules/axios/lib/helpers/parseHeaders.js","node_modules/axios/lib/helpers/spread.js","node_modules/axios/lib/utils.js","node_modules/base64-js/index.js","node_modules/buffer/index.js","node_modules/debug/src/browser.js","node_modules/debug/src/debug.js","node_modules/ieee754/index.js","node_modules/isarray/index.js","node_modules/js-base64/base64.js","node_modules/ms/index.js","node_modules/process/browser.js","node_modules/utf8/utf8.js"],"names":[],"mappings":"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AAK,QAAL,CAAc,MAAd,EAAsB,aAAtB,EAAqC,OAArC,EAA8C,EAA9C,CAAP;AACF;;;;;;AAGJ,OAAO,OAAP,GAAiB,IAAjB;;;ACtMA;;;ACAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;ACjLA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACpDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACnBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACzDA;AACA;AACA;AACA;AACA;AACA;;ACLA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACrFA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACpDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC/EA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACnBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACzBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;ACpBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;AC7FA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACXA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACpCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACpEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACZA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACrDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACdA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACpEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACZA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACr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lHA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;AC7vDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;ACtLA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACvMA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACpFA;AACA;AACA;AACA;AACA;AACA;;ACLA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AClMA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACrJA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;ACpLA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA","file":"GitHub.bundle.js","sourcesContent":["(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require==\"function\"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error(\"Cannot find module '\"+o+\"'\");throw f.code=\"MODULE_NOT_FOUND\",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require==\"function\"&&require;for(var o=0;o {\n this.__id = response.data.id;\n return response;\n });\n }\n\n /**\n * Delete a gist.\n * @see https://developer.github.com/v3/gists/#delete-a-gist\n * @param {Requestable.callback} [cb] - will receive true if the request succeeds\n * @return {Promise} - the Promise for the http request\n */\n delete(cb) {\n return this._request('DELETE', `/gists/${this.__id}`, null, cb);\n }\n\n /**\n * Fork a gist.\n * @see https://developer.github.com/v3/gists/#fork-a-gist\n * @param {Requestable.callback} [cb] - the function that will receive the gist\n * @return {Promise} - the Promise for the http request\n */\n fork(cb) {\n return this._request('POST', `/gists/${this.__id}/forks`, null, cb);\n }\n\n /**\n * Update a gist.\n * @see https://developer.github.com/v3/gists/#edit-a-gist\n * @param {Object} gist - the new data for the gist\n * @param {Requestable.callback} [cb] - the function that receives the API result\n * @return {Promise} - the Promise for the http request\n */\n update(gist, cb) {\n return this._request('PATCH', `/gists/${this.__id}`, gist, cb);\n }\n\n /**\n * Star a gist.\n * @see https://developer.github.com/v3/gists/#star-a-gist\n * @param {Requestable.callback} [cb] - will receive true if the request is successful\n * @return {Promise} - the Promise for the http request\n */\n star(cb) {\n return this._request('PUT', `/gists/${this.__id}/star`, null, cb);\n }\n\n /**\n * Unstar a gist.\n * @see https://developer.github.com/v3/gists/#unstar-a-gist\n * @param {Requestable.callback} [cb] - will receive true if the request is successful\n * @return {Promise} - the Promise for the http request\n */\n unstar(cb) {\n return this._request('DELETE', `/gists/${this.__id}/star`, null, cb);\n }\n\n /**\n * Check if a gist is starred by the user.\n * @see https://developer.github.com/v3/gists/#check-if-a-gist-is-starred\n * @param {Requestable.callback} [cb] - will receive true if the gist is starred and false if the gist is not starred\n * @return {Promise} - the Promise for the http request\n */\n isStarred(cb) {\n return this._request204or404(`/gists/${this.__id}/star`, null, cb);\n }\n\n /**\n * List the gist's commits\n * @see https://developer.github.com/v3/gists/#list-gist-commits\n * @param {Requestable.callback} [cb] - will receive the array of commits\n * @return {Promise} - the Promise for the http request\n */\n listCommits(cb) {\n return this._requestAllPages(`/gists/${this.__id}/commits`, null, cb);\n }\n\n /**\n * Fetch one of the gist's revision.\n * @see https://developer.github.com/v3/gists/#get-a-specific-revision-of-a-gist\n * @param {string} revision - the id of the revision\n * @param {Requestable.callback} [cb] - will receive the revision\n * @return {Promise} - the Promise for the http request\n */\n getRevision(revision, cb) {\n return this._request('GET', `/gists/${this.__id}/${revision}`, null, cb);\n }\n\n /**\n * List the gist's comments\n * @see https://developer.github.com/v3/gists/comments/#list-comments-on-a-gist\n * @param {Requestable.callback} [cb] - will receive the array of comments\n * @return {Promise} - the promise for the http request\n */\n listComments(cb) {\n return this._requestAllPages(`/gists/${this.__id}/comments`, null, cb);\n }\n\n /**\n * Fetch one of the gist's comments\n * @see https://developer.github.com/v3/gists/comments/#get-a-single-comment\n * @param {number} comment - the id of the comment\n * @param {Requestable.callback} [cb] - will receive the comment\n * @return {Promise} - the Promise for the http request\n */\n getComment(comment, cb) {\n return this._request('GET', `/gists/${this.__id}/comments/${comment}`, null, cb);\n }\n\n /**\n * Comment on a gist\n * @see https://developer.github.com/v3/gists/comments/#create-a-comment\n * @param {string} comment - the comment to add\n * @param {Requestable.callback} [cb] - the function that receives the API result\n * @return {Promise} - the Promise for the http request\n */\n createComment(comment, cb) {\n return this._request('POST', `/gists/${this.__id}/comments`, {body: comment}, cb);\n }\n\n /**\n * Edit a comment on the gist\n * @see https://developer.github.com/v3/gists/comments/#edit-a-comment\n * @param {number} comment - the id of the comment\n * @param {string} body - the new comment\n * @param {Requestable.callback} [cb] - will receive the modified comment\n * @return {Promise} - the promise for the http request\n */\n editComment(comment, body, cb) {\n return this._request('PATCH', `/gists/${this.__id}/comments/${comment}`, {body: body}, cb);\n }\n\n /**\n * Delete a comment on the gist.\n * @see https://developer.github.com/v3/gists/comments/#delete-a-comment\n * @param {number} comment - the id of the comment\n * @param {Requestable.callback} [cb] - will receive true if the request succeeds\n * @return {Promise} - the Promise for the http request\n */\n deleteComment(comment, cb) {\n return this._request('DELETE', `/gists/${this.__id}/comments/${comment}`, null, cb);\n }\n}\n\nmodule.exports = Gist;\n","/**\n * @file\n * @copyright 2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n * Github.js is freely distributable.\n */\n/* eslint valid-jsdoc: [\"error\", {\"requireReturnDescription\": false}] */\n\nimport Gist from './Gist';\nimport User from './User';\nimport Issue from './Issue';\nimport Search from './Search';\nimport RateLimit from './RateLimit';\nimport Repository from './Repository';\nimport Organization from './Organization';\nimport Team from './Team';\nimport Markdown from './Markdown';\nimport Project from './Project';\n\n/**\n * GitHub encapsulates the functionality to create various API wrapper objects.\n */\nclass GitHub {\n /**\n * Create a new GitHub.\n * @param {Requestable.auth} [auth] - the credentials to authenticate to Github. If auth is\n * not provided requests will be made unauthenticated\n * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n */\n constructor(auth, apiBase = 'https://api.github.com') {\n this.__apiBase = apiBase;\n this.__auth = auth || {};\n }\n\n /**\n * Create a new Gist wrapper\n * @param {number} [id] - the id for the gist, leave undefined when creating a new gist\n * @return {Gist}\n */\n getGist(id) {\n return new Gist(id, this.__auth, this.__apiBase);\n }\n\n /**\n * Create a new User wrapper\n * @param {string} [user] - the name of the user to get information about\n * leave undefined for the authenticated user\n * @return {User}\n */\n getUser(user) {\n return new User(user, this.__auth, this.__apiBase);\n }\n\n /**\n * Create a new Organization wrapper\n * @param {string} organization - the name of the organization\n * @return {Organization}\n */\n getOrganization(organization) {\n return new Organization(organization, this.__auth, this.__apiBase);\n }\n\n /**\n * create a new Team wrapper\n * @param {string} teamId - the name of the team\n * @return {team}\n */\n getTeam(teamId) {\n return new Team(teamId, this.__auth, this.__apiBase);\n }\n\n /**\n * Create a new Repository wrapper\n * @param {string} user - the user who owns the respository\n * @param {string} repo - the name of the repository\n * @return {Repository}\n */\n getRepo(user, repo) {\n return new Repository(this._getFullName(user, repo), this.__auth, this.__apiBase);\n }\n\n /**\n * Create a new Issue wrapper\n * @param {string} user - the user who owns the respository\n * @param {string} repo - the name of the repository\n * @return {Issue}\n */\n getIssues(user, repo) {\n return new Issue(this._getFullName(user, repo), this.__auth, this.__apiBase);\n }\n\n /**\n * Create a new Search wrapper\n * @param {string} query - the query to search for\n * @return {Search}\n */\n search(query) {\n return new Search(query, this.__auth, this.__apiBase);\n }\n\n /**\n * Create a new RateLimit wrapper\n * @return {RateLimit}\n */\n getRateLimit() {\n return new RateLimit(this.__auth, this.__apiBase);\n }\n\n /**\n * Create a new Markdown wrapper\n * @return {Markdown}\n */\n getMarkdown() {\n return new Markdown(this.__auth, this.__apiBase);\n }\n\n /**\n * Create a new Project wrapper\n * @param {string} id - the id of the project\n * @return {Markdown}\n */\n getProject(id) {\n return new Project(id, this.__auth, this.__apiBase);\n }\n\n /**\n * Computes the full repository name\n * @param {string} user - the username (or the full name)\n * @param {string} repo - the repository name, must not be passed if `user` is the full name\n * @return {string} the repository's full name\n */\n _getFullName(user, repo) {\n let fullname = user;\n\n if (repo) {\n fullname = `${user}/${repo}`;\n }\n\n return fullname;\n }\n}\n\nmodule.exports = GitHub;\n","/**\n * @file\n * @copyright 2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n * Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\n\n/**\n * Issue wraps the functionality to get issues for repositories\n */\nclass Issue extends Requestable {\n /**\n * Create a new Issue\n * @param {string} repository - the full name of the repository (`:user/:repo`) to get issues for\n * @param {Requestable.auth} [auth] - information required to authenticate to Github\n * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n */\n constructor(repository, auth, apiBase) {\n super(auth, apiBase);\n this.__repository = repository;\n }\n\n /**\n * Create a new issue\n * @see https://developer.github.com/v3/issues/#create-an-issue\n * @param {Object} issueData - the issue to create\n * @param {Requestable.callback} [cb] - will receive the created issue\n * @return {Promise} - the promise for the http request\n */\n createIssue(issueData, cb) {\n return this._request('POST', `/repos/${this.__repository}/issues`, issueData, cb);\n }\n\n /**\n * List the issues for the repository\n * @see https://developer.github.com/v3/issues/#list-issues-for-a-repository\n * @param {Object} options - filtering options\n * @param {Requestable.callback} [cb] - will receive the array of issues\n * @return {Promise} - the promise for the http request\n */\n listIssues(options, cb) {\n return this._requestAllPages(`/repos/${this.__repository}/issues`, options, cb);\n }\n\n /**\n * List the events for an issue\n * @see https://developer.github.com/v3/issues/events/#list-events-for-an-issue\n * @param {number} issue - the issue to get events for\n * @param {Requestable.callback} [cb] - will receive the list of events\n * @return {Promise} - the promise for the http request\n */\n listIssueEvents(issue, cb) {\n return this._request('GET', `/repos/${this.__repository}/issues/${issue}/events`, null, cb);\n }\n\n /**\n * List comments on an issue\n * @see https://developer.github.com/v3/issues/comments/#list-comments-on-an-issue\n * @param {number} issue - the id of the issue to get comments from\n * @param {Requestable.callback} [cb] - will receive the comments\n * @return {Promise} - the promise for the http request\n */\n listIssueComments(issue, cb) {\n return this._request('GET', `/repos/${this.__repository}/issues/${issue}/comments`, null, cb);\n }\n\n /**\n * Get a single comment on an issue\n * @see https://developer.github.com/v3/issues/comments/#get-a-single-comment\n * @param {number} id - the comment id to get\n * @param {Requestable.callback} [cb] - will receive the comment\n * @return {Promise} - the promise for the http request\n */\n getIssueComment(id, cb) {\n return this._request('GET', `/repos/${this.__repository}/issues/comments/${id}`, null, cb);\n }\n\n /**\n * Comment on an issue\n * @see https://developer.github.com/v3/issues/comments/#create-a-comment\n * @param {number} issue - the id of the issue to comment on\n * @param {string} comment - the comment to add\n * @param {Requestable.callback} [cb] - will receive the created comment\n * @return {Promise} - the promise for the http request\n */\n createIssueComment(issue, comment, cb) {\n return this._request('POST', `/repos/${this.__repository}/issues/${issue}/comments`, {body: comment}, cb);\n }\n\n /**\n * Edit a comment on an issue\n * @see https://developer.github.com/v3/issues/comments/#edit-a-comment\n * @param {number} id - the comment id to edit\n * @param {string} comment - the comment to edit\n * @param {Requestable.callback} [cb] - will receive the edited comment\n * @return {Promise} - the promise for the http request\n */\n editIssueComment(id, comment, cb) {\n return this._request('PATCH', `/repos/${this.__repository}/issues/comments/${id}`, {body: comment}, cb);\n }\n\n /**\n * Delete a comment on an issue\n * @see https://developer.github.com/v3/issues/comments/#delete-a-comment\n * @param {number} id - the comment id to delete\n * @param {Requestable.callback} [cb] - will receive true if the request is successful\n * @return {Promise} - the promise for the http request\n */\n deleteIssueComment(id, cb) {\n return this._request('DELETE', `/repos/${this.__repository}/issues/comments/${id}`, null, cb);\n }\n\n /**\n * Edit an issue\n * @see https://developer.github.com/v3/issues/#edit-an-issue\n * @param {number} issue - the issue number to edit\n * @param {Object} issueData - the new issue data\n * @param {Requestable.callback} [cb] - will receive the modified issue\n * @return {Promise} - the promise for the http request\n */\n editIssue(issue, issueData, cb) {\n return this._request('PATCH', `/repos/${this.__repository}/issues/${issue}`, issueData, cb);\n }\n\n /**\n * Get a particular issue\n * @see https://developer.github.com/v3/issues/#get-a-single-issue\n * @param {number} issue - the issue number to fetch\n * @param {Requestable.callback} [cb] - will receive the issue\n * @return {Promise} - the promise for the http request\n */\n getIssue(issue, cb) {\n return this._request('GET', `/repos/${this.__repository}/issues/${issue}`, null, cb);\n }\n\n /**\n * List the milestones for the repository\n * @see https://developer.github.com/v3/issues/milestones/#list-milestones-for-a-repository\n * @param {Object} options - filtering options\n * @param {Requestable.callback} [cb] - will receive the array of milestones\n * @return {Promise} - the promise for the http request\n */\n listMilestones(options, cb) {\n return this._request('GET', `/repos/${this.__repository}/milestones`, options, cb);\n }\n\n /**\n * Get a milestone\n * @see https://developer.github.com/v3/issues/milestones/#get-a-single-milestone\n * @param {string} milestone - the id of the milestone to fetch\n * @param {Requestable.callback} [cb] - will receive the milestone\n * @return {Promise} - the promise for the http request\n */\n getMilestone(milestone, cb) {\n return this._request('GET', `/repos/${this.__repository}/milestones/${milestone}`, null, cb);\n }\n\n /**\n * Create a new milestone\n * @see https://developer.github.com/v3/issues/milestones/#create-a-milestone\n * @param {Object} milestoneData - the milestone definition\n * @param {Requestable.callback} [cb] - will receive the milestone\n * @return {Promise} - the promise for the http request\n */\n createMilestone(milestoneData, cb) {\n return this._request('POST', `/repos/${this.__repository}/milestones`, milestoneData, cb);\n }\n\n /**\n * Edit a milestone\n * @see https://developer.github.com/v3/issues/milestones/#update-a-milestone\n * @param {string} milestone - the id of the milestone to edit\n * @param {Object} milestoneData - the updates to make to the milestone\n * @param {Requestable.callback} [cb] - will receive the updated milestone\n * @return {Promise} - the promise for the http request\n */\n editMilestone(milestone, milestoneData, cb) {\n return this._request('PATCH', `/repos/${this.__repository}/milestones/${milestone}`, milestoneData, cb);\n }\n\n /**\n * Delete a milestone (this is distinct from closing a milestone)\n * @see https://developer.github.com/v3/issues/milestones/#delete-a-milestone\n * @param {string} milestone - the id of the milestone to delete\n * @param {Requestable.callback} [cb] - will receive the status\n * @return {Promise} - the promise for the http request\n */\n deleteMilestone(milestone, cb) {\n return this._request('DELETE', `/repos/${this.__repository}/milestones/${milestone}`, null, cb);\n }\n\n /**\n * Create a new label\n * @see https://developer.github.com/v3/issues/labels/#create-a-label\n * @param {Object} labelData - the label definition\n * @param {Requestable.callback} [cb] - will receive the object representing the label\n * @return {Promise} - the promise for the http request\n */\n createLabel(labelData, cb) {\n return this._request('POST', `/repos/${this.__repository}/labels`, labelData, cb);\n }\n\n /**\n * List the labels for the repository\n * @see https://developer.github.com/v3/issues/labels/#list-all-labels-for-this-repository\n * @param {Object} options - filtering options\n * @param {Requestable.callback} [cb] - will receive the array of labels\n * @return {Promise} - the promise for the http request\n */\n listLabels(options, cb) {\n return this._request('GET', `/repos/${this.__repository}/labels`, options, cb);\n }\n\n /**\n * Get a label\n * @see https://developer.github.com/v3/issues/labels/#get-a-single-label\n * @param {string} label - the name of the label to fetch\n * @param {Requestable.callback} [cb] - will receive the label\n * @return {Promise} - the promise for the http request\n */\n getLabel(label, cb) {\n return this._request('GET', `/repos/${this.__repository}/labels/${label}`, null, cb);\n }\n\n /**\n * Edit a label\n * @see https://developer.github.com/v3/issues/labels/#update-a-label\n * @param {string} label - the name of the label to edit\n * @param {Object} labelData - the updates to make to the label\n * @param {Requestable.callback} [cb] - will receive the updated label\n * @return {Promise} - the promise for the http request\n */\n editLabel(label, labelData, cb) {\n return this._request('PATCH', `/repos/${this.__repository}/labels/${label}`, labelData, cb);\n }\n\n /**\n * Delete a label\n * @see https://developer.github.com/v3/issues/labels/#delete-a-label\n * @param {string} label - the name of the label to delete\n * @param {Requestable.callback} [cb] - will receive the status\n * @return {Promise} - the promise for the http request\n */\n deleteLabel(label, cb) {\n return this._request('DELETE', `/repos/${this.__repository}/labels/${label}`, null, cb);\n }\n}\n\nmodule.exports = Issue;\n","/**\n * @file\n * @copyright 2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n * Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\n\n/**\n * Renders html from Markdown text\n */\nclass Markdown extends Requestable {\n /**\n * construct a Markdown\n * @param {Requestable.auth} auth - the credentials to authenticate to GitHub\n * @param {string} [apiBase] - the base Github API URL\n * @return {Promise} - the promise for the http request\n */\n constructor(auth, apiBase) {\n super(auth, apiBase);\n }\n\n /**\n * Render html from Markdown text.\n * @see https://developer.github.com/v3/markdown/#render-an-arbitrary-markdown-document\n * @param {Object} options - conversion options\n * @param {string} [options.text] - the markdown text to convert\n * @param {string} [options.mode=markdown] - can be either `markdown` or `gfm`\n * @param {string} [options.context] - repository name if mode is gfm\n * @param {Requestable.callback} [cb] - will receive the converted html\n * @return {Promise} - the promise for the http request\n */\n render(options, cb) {\n return this._request('POST', '/markdown', options, cb);\n }\n}\n\nmodule.exports = Markdown;\n","/**\n * @file\n * @copyright 2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n * Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\n\n/**\n * Organization encapsulates the functionality to create repositories in organizations\n */\nclass Organization extends Requestable {\n /**\n * Create a new Organization\n * @param {string} organization - the name of the organization\n * @param {Requestable.auth} [auth] - information required to authenticate to Github\n * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n */\n constructor(organization, auth, apiBase) {\n super(auth, apiBase);\n this.__name = organization;\n }\n\n /**\n * Create a repository in an organization\n * @see https://developer.github.com/v3/repos/#create\n * @param {Object} options - the repository definition\n * @param {Requestable.callback} [cb] - will receive the created repository\n * @return {Promise} - the promise for the http request\n */\n createRepo(options, cb) {\n return this._request('POST', `/orgs/${this.__name}/repos`, options, cb);\n }\n\n /**\n * List the repositories in an organization\n * @see https://developer.github.com/v3/repos/#list-organization-repositories\n * @param {Requestable.callback} [cb] - will receive the list of repositories\n * @return {Promise} - the promise for the http request\n */\n getRepos(cb) {\n let requestOptions = this._getOptionsWithDefaults({direction: 'desc'});\n\n return this._requestAllPages(`/orgs/${this.__name}/repos`, requestOptions, cb);\n }\n\n /**\n * Query if the user is a member or not\n * @param {string} username - the user in question\n * @param {Requestable.callback} [cb] - will receive true if the user is a member\n * @return {Promise} - the promise for the http request\n */\n isMember(username, cb) {\n return this._request204or404(`/orgs/${this.__name}/members/${username}`, null, cb);\n }\n\n /**\n * List the users who are members of the company\n * @see https://developer.github.com/v3/orgs/members/#members-list\n * @param {object} options - filtering options\n * @param {string} [options.filter=all] - can be either `2fa_disabled` or `all`\n * @param {string} [options.role=all] - can be one of: `all`, `admin`, or `member`\n * @param {Requestable.callback} [cb] - will receive the list of users\n * @return {Promise} - the promise for the http request\n */\n listMembers(options, cb) {\n return this._request('GET', `/orgs/${this.__name}/members`, options, cb);\n }\n\n /**\n * List the Teams in the Organization\n * @see https://developer.github.com/v3/orgs/teams/#list-teams\n * @param {Requestable.callback} [cb] - will receive the list of teams\n * @return {Promise} - the promise for the http request\n */\n getTeams(cb) {\n return this._requestAllPages(`/orgs/${this.__name}/teams`, undefined, cb);\n }\n\n /**\n * Create a team\n * @see https://developer.github.com/v3/orgs/teams/#create-team\n * @param {object} options - Team creation parameters\n * @param {string} options.name - The name of the team\n * @param {string} [options.description] - Team description\n * @param {string} [options.repo_names] - Repos to add the team to\n * @param {string} [options.privacy=secret] - The level of privacy the team should have. Can be either one\n * of: `secret`, or `closed`\n * @param {Requestable.callback} [cb] - will receive the created team\n * @return {Promise} - the promise for the http request\n */\n createTeam(options, cb) {\n return this._request('POST', `/orgs/${this.__name}/teams`, options, cb);\n }\n\n /**\n * Get information about all projects\n * @see https://developer.github.com/v3/projects/#list-organization-projects\n * @param {Requestable.callback} [cb] - will receive the list of projects\n * @return {Promise} - the promise for the http request\n */\n listProjects(cb) {\n return this._requestAllPages(`/orgs/${this.__name}/projects`, {AcceptHeader: 'inertia-preview'}, cb);\n }\n\n /**\n * Create a new project\n * @see https://developer.github.com/v3/repos/projects/#create-a-project\n * @param {Object} options - the description of the project\n * @param {Requestable.callback} cb - will receive the newly created project\n * @return {Promise} - the promise for the http request\n */\n createProject(options, cb) {\n options = options || {};\n options.AcceptHeader = 'inertia-preview';\n return this._request('POST', `/orgs/${this.__name}/projects`, options, cb);\n }\n}\n\nmodule.exports = Organization;\n","/**\n * @file\n * @copyright 2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n * Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\n\n/**\n * Project encapsulates the functionality to create, query, and modify cards and columns.\n */\nclass Project extends Requestable {\n /**\n * Create a Project.\n * @param {string} id - the id of the project\n * @param {Requestable.auth} [auth] - information required to authenticate to Github\n * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n */\n constructor(id, auth, apiBase) {\n super(auth, apiBase, 'inertia-preview');\n this.__id = id;\n }\n\n /**\n * Get information about a project\n * @see https://developer.github.com/v3/projects/#get-a-project\n * @param {Requestable.callback} cb - will receive the project information\n * @return {Promise} - the promise for the http request\n */\n getProject(cb) {\n return this._request('GET', `/projects/${this.__id}`, null, cb);\n }\n\n /**\n * Edit a project\n * @see https://developer.github.com/v3/projects/#update-a-project\n * @param {Object} options - the description of the project\n * @param {Requestable.callback} cb - will receive the modified project\n * @return {Promise} - the promise for the http request\n */\n updateProject(options, cb) {\n return this._request('PATCH', `/projects/${this.__id}`, options, cb);\n }\n\n /**\n * Delete a project\n * @see https://developer.github.com/v3/projects/#delete-a-project\n * @param {Requestable.callback} cb - will receive true if the operation is successful\n * @return {Promise} - the promise for the http request\n */\n deleteProject(cb) {\n return this._request('DELETE', `/projects/${this.__id}`, null, cb);\n }\n\n /**\n * Get information about all columns of a project\n * @see https://developer.github.com/v3/projects/columns/#list-project-columns\n * @param {Requestable.callback} [cb] - will receive the list of columns\n * @return {Promise} - the promise for the http request\n */\n listProjectColumns(cb) {\n return this._requestAllPages(`/projects/${this.__id}/columns`, null, cb);\n }\n\n /**\n * Get information about a column\n * @see https://developer.github.com/v3/projects/columns/#get-a-project-column\n * @param {string} colId - the id of the column\n * @param {Requestable.callback} cb - will receive the column information\n * @return {Promise} - the promise for the http request\n */\n getProjectColumn(colId, cb) {\n return this._request('GET', `/projects/columns/${colId}`, null, cb);\n }\n\n /**\n * Create a new column\n * @see https://developer.github.com/v3/projects/columns/#create-a-project-column\n * @param {Object} options - the description of the column\n * @param {Requestable.callback} cb - will receive the newly created column\n * @return {Promise} - the promise for the http request\n */\n createProjectColumn(options, cb) {\n return this._request('POST', `/projects/${this.__id}/columns`, options, cb);\n }\n\n /**\n * Edit a column\n * @see https://developer.github.com/v3/projects/columns/#update-a-project-column\n * @param {string} colId - the column id\n * @param {Object} options - the description of the column\n * @param {Requestable.callback} cb - will receive the modified column\n * @return {Promise} - the promise for the http request\n */\n updateProjectColumn(colId, options, cb) {\n return this._request('PATCH', `/projects/columns/${colId}`, options, cb);\n }\n\n /**\n * Delete a column\n * @see https://developer.github.com/v3/projects/columns/#delete-a-project-column\n * @param {string} colId - the column to be deleted\n * @param {Requestable.callback} cb - will receive true if the operation is successful\n * @return {Promise} - the promise for the http request\n */\n deleteProjectColumn(colId, cb) {\n return this._request('DELETE', `/projects/columns/${colId}`, null, cb);\n }\n\n /**\n * Move a column\n * @see https://developer.github.com/v3/projects/columns/#move-a-project-column\n * @param {string} colId - the column to be moved\n * @param {string} position - can be one of first, last, or after:,\n * where is the id value of a column in the same project.\n * @param {Requestable.callback} cb - will receive true if the operation is successful\n * @return {Promise} - the promise for the http request\n */\n moveProjectColumn(colId, position, cb) {\n return this._request(\n 'POST',\n `/projects/columns/${colId}/moves`,\n {position: position},\n cb\n );\n }\n\n /**\n * Get information about all cards of a project\n * @see https://developer.github.com/v3/projects/cards/#list-project-cards\n * @param {Requestable.callback} [cb] - will receive the list of cards\n * @return {Promise} - the promise for the http request\n */\n listProjectCards(cb) {\n return this.listProjectColumns()\n .then(({data}) => {\n return Promise.all(data.map((column) => {\n return this._requestAllPages(`/projects/columns/${column.id}/cards`, null);\n }));\n }).then((cardsInColumns) => {\n const cards = cardsInColumns.reduce((prev, {data}) => {\n prev.push(...data);\n return prev;\n }, []);\n if (cb) {\n cb(null, cards);\n }\n return cards;\n }).catch((err) => {\n if (cb) {\n cb(err);\n return;\n }\n throw err;\n });\n }\n\n /**\n * Get information about all cards of a column\n * @see https://developer.github.com/v3/projects/cards/#list-project-cards\n * @param {string} colId - the id of the column\n * @param {Requestable.callback} [cb] - will receive the list of cards\n * @return {Promise} - the promise for the http request\n */\n listColumnCards(colId, cb) {\n return this._requestAllPages(`/projects/columns/${colId}/cards`, null, cb);\n }\n\n /**\n * Get information about a card\n * @see https://developer.github.com/v3/projects/cards/#get-a-project-card\n * @param {string} cardId - the id of the card\n * @param {Requestable.callback} cb - will receive the card information\n * @return {Promise} - the promise for the http request\n */\n getProjectCard(cardId, cb) {\n return this._request('GET', `/projects/columns/cards/${cardId}`, null, cb);\n }\n\n /**\n * Create a new card\n * @see https://developer.github.com/v3/projects/cards/#create-a-project-card\n * @param {string} colId - the column id\n * @param {Object} options - the description of the card\n * @param {Requestable.callback} cb - will receive the newly created card\n * @return {Promise} - the promise for the http request\n */\n createProjectCard(colId, options, cb) {\n return this._request('POST', `/projects/columns/${colId}/cards`, options, cb);\n }\n\n /**\n * Edit a card\n * @see https://developer.github.com/v3/projects/cards/#update-a-project-card\n * @param {string} cardId - the card id\n * @param {Object} options - the description of the card\n * @param {Requestable.callback} cb - will receive the modified card\n * @return {Promise} - the promise for the http request\n */\n updateProjectCard(cardId, options, cb) {\n return this._request('PATCH', `/projects/columns/cards/${cardId}`, options, cb);\n }\n\n /**\n * Delete a card\n * @see https://developer.github.com/v3/projects/cards/#delete-a-project-card\n * @param {string} cardId - the card to be deleted\n * @param {Requestable.callback} cb - will receive true if the operation is successful\n * @return {Promise} - the promise for the http request\n */\n deleteProjectCard(cardId, cb) {\n return this._request('DELETE', `/projects/columns/cards/${cardId}`, null, cb);\n }\n\n /**\n * Move a card\n * @see https://developer.github.com/v3/projects/cards/#move-a-project-card\n * @param {string} cardId - the card to be moved\n * @param {string} position - can be one of top, bottom, or after:,\n * where is the id value of a card in the same project.\n * @param {string} colId - the id value of a column in the same project.\n * @param {Requestable.callback} cb - will receive true if the operation is successful\n * @return {Promise} - the promise for the http request\n */\n moveProjectCard(cardId, position, colId, cb) {\n return this._request(\n 'POST',\n `/projects/columns/cards/${cardId}/moves`,\n {position: position, column_id: colId}, // eslint-disable-line camelcase\n cb\n );\n }\n}\n\nmodule.exports = Project;\n","/**\n * @file\n * @copyright 2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n * Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\n\n/**\n * RateLimit allows users to query their rate-limit status\n */\nclass RateLimit extends Requestable {\n /**\n * construct a RateLimit\n * @param {Requestable.auth} auth - the credentials to authenticate to GitHub\n * @param {string} [apiBase] - the base Github API URL\n * @return {Promise} - the promise for the http request\n */\n constructor(auth, apiBase) {\n super(auth, apiBase);\n }\n\n /**\n * Query the current rate limit\n * @see https://developer.github.com/v3/rate_limit/\n * @param {Requestable.callback} [cb] - will receive the rate-limit data\n * @return {Promise} - the promise for the http request\n */\n getRateLimit(cb) {\n return this._request('GET', '/rate_limit', null, cb);\n }\n}\n\nmodule.exports = RateLimit;\n","/**\n * @file\n * @copyright 2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n * Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\nimport Utf8 from 'utf8';\nimport {\n Base64,\n} from 'js-base64';\nimport debug from 'debug';\nconst log = debug('github:repository');\n\n/**\n * Respository encapsulates the functionality to create, query, and modify files.\n */\nclass Repository extends Requestable {\n /**\n * Create a Repository.\n * @param {string} fullname - the full name of the repository\n * @param {Requestable.auth} [auth] - information required to authenticate to Github\n * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n */\n constructor(fullname, auth, apiBase) {\n super(auth, apiBase);\n this.__fullname = fullname;\n this.__currentTree = {\n branch: null,\n sha: null,\n };\n }\n\n /**\n * Get a reference\n * @see https://developer.github.com/v3/git/refs/#get-a-reference\n * @param {string} ref - the reference to get\n * @param {Requestable.callback} [cb] - will receive the reference's refSpec or a list of refSpecs that match `ref`\n * @return {Promise} - the promise for the http request\n */\n getRef(ref, cb) {\n return this._request('GET', `/repos/${this.__fullname}/git/refs/${ref}`, null, cb);\n }\n\n /**\n * Create a reference\n * @see https://developer.github.com/v3/git/refs/#create-a-reference\n * @param {Object} options - the object describing the ref\n * @param {Requestable.callback} [cb] - will receive the ref\n * @return {Promise} - the promise for the http request\n */\n createRef(options, cb) {\n return this._request('POST', `/repos/${this.__fullname}/git/refs`, options, cb);\n }\n\n /**\n * Delete a reference\n * @see https://developer.github.com/v3/git/refs/#delete-a-reference\n * @param {string} ref - the name of the ref to delte\n * @param {Requestable.callback} [cb] - will receive true if the request is successful\n * @return {Promise} - the promise for the http request\n */\n deleteRef(ref, cb) {\n return this._request('DELETE', `/repos/${this.__fullname}/git/refs/${ref}`, null, cb);\n }\n\n /**\n * Delete a repository\n * @see https://developer.github.com/v3/repos/#delete-a-repository\n * @param {Requestable.callback} [cb] - will receive true if the request is successful\n * @return {Promise} - the promise for the http request\n */\n deleteRepo(cb) {\n return this._request('DELETE', `/repos/${this.__fullname}`, null, cb);\n }\n\n /**\n * List the tags on a repository\n * @see https://developer.github.com/v3/repos/#list-tags\n * @param {Requestable.callback} [cb] - will receive the tag data\n * @return {Promise} - the promise for the http request\n */\n listTags(cb) {\n return this._request('GET', `/repos/${this.__fullname}/tags`, null, cb);\n }\n\n /**\n * List the open pull requests on the repository\n * @see https://developer.github.com/v3/pulls/#list-pull-requests\n * @param {Object} options - options to filter the search\n * @param {Requestable.callback} [cb] - will receive the list of PRs\n * @return {Promise} - the promise for the http request\n */\n listPullRequests(options, cb) {\n options = options || {};\n return this._request('GET', `/repos/${this.__fullname}/pulls`, options, cb);\n }\n\n /**\n * Get information about a specific pull request\n * @see https://developer.github.com/v3/pulls/#get-a-single-pull-request\n * @param {number} number - the PR you wish to fetch\n * @param {Requestable.callback} [cb] - will receive the PR from the API\n * @return {Promise} - the promise for the http request\n */\n getPullRequest(number, cb) {\n return this._request('GET', `/repos/${this.__fullname}/pulls/${number}`, null, cb);\n }\n\n /**\n * List the files of a specific pull request\n * @see https://developer.github.com/v3/pulls/#list-pull-requests-files\n * @param {number|string} number - the PR you wish to fetch\n * @param {Requestable.callback} [cb] - will receive the list of files from the API\n * @return {Promise} - the promise for the http request\n */\n listPullRequestFiles(number, cb) {\n return this._request('GET', `/repos/${this.__fullname}/pulls/${number}/files`, null, cb);\n }\n\n /**\n * Compare two branches/commits/repositories\n * @see https://developer.github.com/v3/repos/commits/#compare-two-commits\n * @param {string} base - the base commit\n * @param {string} head - the head commit\n * @param {Requestable.callback} cb - will receive the comparison\n * @return {Promise} - the promise for the http request\n */\n compareBranches(base, head, cb) {\n return this._request('GET', `/repos/${this.__fullname}/compare/${base}...${head}`, null, cb);\n }\n\n /**\n * List all the branches for the repository\n * @see https://developer.github.com/v3/repos/#list-branches\n * @param {Requestable.callback} cb - will receive the list of branches\n * @return {Promise} - the promise for the http request\n */\n listBranches(cb) {\n return this._request('GET', `/repos/${this.__fullname}/branches`, null, cb);\n }\n\n /**\n * Get a raw blob from the repository\n * @see https://developer.github.com/v3/git/blobs/#get-a-blob\n * @param {string} sha - the sha of the blob to fetch\n * @param {Requestable.callback} cb - will receive the blob from the API\n * @return {Promise} - the promise for the http request\n */\n getBlob(sha, cb) {\n return this._request('GET', `/repos/${this.__fullname}/git/blobs/${sha}`, null, cb, 'raw');\n }\n\n /**\n * Get a single branch\n * @see https://developer.github.com/v3/repos/branches/#get-branch\n * @param {string} branch - the name of the branch to fetch\n * @param {Requestable.callback} cb - will receive the branch from the API\n * @returns {Promise} - the promise for the http request\n */\n getBranch(branch, cb) {\n return this._request('GET', `/repos/${this.__fullname}/branches/${branch}`, null, cb);\n }\n\n /**\n * Get a commit from the repository\n * @see https://developer.github.com/v3/repos/commits/#get-a-single-commit\n * @param {string} sha - the sha for the commit to fetch\n * @param {Requestable.callback} cb - will receive the commit data\n * @return {Promise} - the promise for the http request\n */\n getCommit(sha, cb) {\n return this._request('GET', `/repos/${this.__fullname}/git/commits/${sha}`, null, cb);\n }\n\n /**\n * List the commits on a repository, optionally filtering by path, author or time range\n * @see https://developer.github.com/v3/repos/commits/#list-commits-on-a-repository\n * @param {Object} [options] - the filtering options for commits\n * @param {string} [options.sha] - the SHA or branch to start from\n * @param {string} [options.path] - the path to search on\n * @param {string} [options.author] - the commit author\n * @param {(Date|string)} [options.since] - only commits after this date will be returned\n * @param {(Date|string)} [options.until] - only commits before this date will be returned\n * @param {Requestable.callback} cb - will receive the list of commits found matching the criteria\n * @return {Promise} - the promise for the http request\n */\n listCommits(options, cb) {\n options = options || {};\n\n options.since = this._dateToISO(options.since);\n options.until = this._dateToISO(options.until);\n\n return this._request('GET', `/repos/${this.__fullname}/commits`, options, cb);\n }\n\n /**\n * Gets a single commit information for a repository\n * @see https://developer.github.com/v3/repos/commits/#get-a-single-commit\n * @param {string} ref - the reference for the commit-ish\n * @param {Requestable.callback} cb - will receive the commit information\n * @return {Promise} - the promise for the http request\n */\n getSingleCommit(ref, cb) {\n ref = ref || '';\n return this._request('GET', `/repos/${this.__fullname}/commits/${ref}`, null, cb);\n }\n\n /**\n * Get tha sha for a particular object in the repository. This is a convenience function\n * @see https://developer.github.com/v3/repos/contents/#get-contents\n * @param {string} [branch] - the branch to look in, or the repository's default branch if omitted\n * @param {string} path - the path of the file or directory\n * @param {Requestable.callback} cb - will receive a description of the requested object, including a `SHA` property\n * @return {Promise} - the promise for the http request\n */\n getSha(branch, path, cb) {\n branch = branch ? `?ref=${branch}` : '';\n return this._request('GET', `/repos/${this.__fullname}/contents/${path}${branch}`, null, cb);\n }\n\n /**\n * List the commit statuses for a particular sha, branch, or tag\n * @see https://developer.github.com/v3/repos/statuses/#list-statuses-for-a-specific-ref\n * @param {string} sha - the sha, branch, or tag to get statuses for\n * @param {Requestable.callback} cb - will receive the list of statuses\n * @return {Promise} - the promise for the http request\n */\n listStatuses(sha, cb) {\n return this._request('GET', `/repos/${this.__fullname}/commits/${sha}/statuses`, null, cb);\n }\n\n /**\n * Get a description of a git tree\n * @see https://developer.github.com/v3/git/trees/#get-a-tree\n * @param {string} treeSHA - the SHA of the tree to fetch\n * @param {Requestable.callback} cb - will receive the callback data\n * @return {Promise} - the promise for the http request\n */\n getTree(treeSHA, cb) {\n return this._request('GET', `/repos/${this.__fullname}/git/trees/${treeSHA}`, null, cb);\n }\n\n /**\n * Create a blob\n * @see https://developer.github.com/v3/git/blobs/#create-a-blob\n * @param {(string|Buffer|Blob)} content - the content to add to the repository\n * @param {Requestable.callback} cb - will receive the details of the created blob\n * @return {Promise} - the promise for the http request\n */\n createBlob(content, cb) {\n let postBody = this._getContentObject(content);\n\n log('sending content', postBody);\n return this._request('POST', `/repos/${this.__fullname}/git/blobs`, postBody, cb);\n }\n\n /**\n * Get the object that represents the provided content\n * @param {string|Buffer|Blob} content - the content to send to the server\n * @return {Object} the representation of `content` for the GitHub API\n */\n _getContentObject(content) {\n if (typeof content === 'string') {\n log('contet is a string');\n return {\n content: Utf8.encode(content),\n encoding: 'utf-8',\n };\n\n } else if (typeof Buffer !== 'undefined' && content instanceof Buffer) {\n log('We appear to be in Node');\n return {\n content: content.toString('base64'),\n encoding: 'base64',\n };\n\n } else if (typeof Blob !== 'undefined' && content instanceof Blob) {\n log('We appear to be in the browser');\n return {\n content: Base64.encode(content),\n encoding: 'base64',\n };\n\n } else { // eslint-disable-line\n log(`Not sure what this content is: ${typeof content}, ${JSON.stringify(content)}`);\n throw new Error('Unknown content passed to postBlob. Must be string or Buffer (node) or Blob (web)');\n }\n }\n\n /**\n * Update a tree in Git\n * @see https://developer.github.com/v3/git/trees/#create-a-tree\n * @param {string} baseTreeSHA - the SHA of the tree to update\n * @param {string} path - the path for the new file\n * @param {string} blobSHA - the SHA for the blob to put at `path`\n * @param {Requestable.callback} cb - will receive the new tree that is created\n * @return {Promise} - the promise for the http request\n * @deprecated use {@link Repository#createTree} instead\n */\n updateTree(baseTreeSHA, path, blobSHA, cb) {\n let newTree = {\n base_tree: baseTreeSHA, // eslint-disable-line\n tree: [{\n path: path,\n sha: blobSHA,\n mode: '100644',\n type: 'blob',\n }],\n };\n\n return this._request('POST', `/repos/${this.__fullname}/git/trees`, newTree, cb);\n }\n\n /**\n * Create a new tree in git\n * @see https://developer.github.com/v3/git/trees/#create-a-tree\n * @param {Object} tree - the tree to create\n * @param {string} baseSHA - the root sha of the tree\n * @param {Requestable.callback} cb - will receive the new tree that is created\n * @return {Promise} - the promise for the http request\n */\n createTree(tree, baseSHA, cb) {\n return this._request('POST', `/repos/${this.__fullname}/git/trees`, {\n tree,\n base_tree: baseSHA, // eslint-disable-line camelcase\n }, cb);\n }\n\n /**\n * Add a commit to the repository\n * @see https://developer.github.com/v3/git/commits/#create-a-commit\n * @param {string} parent - the SHA of the parent commit\n * @param {string} tree - the SHA of the tree for this commit\n * @param {string} message - the commit message\n * @param {Requestable.callback} cb - will receive the commit that is created\n * @return {Promise} - the promise for the http request\n */\n commit(parent, tree, message, cb) {\n let data = {\n message,\n tree,\n parents: [parent],\n };\n\n return this._request('POST', `/repos/${this.__fullname}/git/commits`, data, cb)\n .then((response) => {\n this.__currentTree.sha = response.data.sha; // Update latest commit\n return response;\n });\n }\n\n /**\n * Update a ref\n * @see https://developer.github.com/v3/git/refs/#update-a-reference\n * @param {string} ref - the ref to update\n * @param {string} commitSHA - the SHA to point the reference to\n * @param {boolean} force - indicates whether to force or ensure a fast-forward update\n * @param {Requestable.callback} cb - will receive the updated ref back\n * @return {Promise} - the promise for the http request\n */\n updateHead(ref, commitSHA, force, cb) {\n return this._request('PATCH', `/repos/${this.__fullname}/git/refs/${ref}`, {\n sha: commitSHA,\n force: force,\n }, cb);\n }\n\n /**\n * Update commit status\n * @see https://developer.github.com/v3/repos/statuses/\n * @param {string} commitSHA - the SHA of the commit that should be updated\n * @param {object} options - Commit status parameters\n * @param {string} options.state - The state of the status. Can be one of: pending, success, error, or failure.\n * @param {string} [options.target_url] - The target URL to associate with this status.\n * @param {string} [options.description] - A short description of the status.\n * @param {string} [options.context] - A string label to differentiate this status among CI systems.\n * @param {Requestable.callback} cb - will receive the updated commit back\n * @return {Promise} - the promise for the http request\n */\n updateStatus(commitSHA, options, cb) {\n return this._request('POST', `/repos/${this.__fullname}/statuses/${commitSHA}`, options, cb);\n }\n\n /**\n * Update repository information\n * @see https://developer.github.com/v3/repos/#edit\n * @param {object} options - New parameters that will be set to the repository\n * @param {string} options.name - Name of the repository\n * @param {string} [options.description] - A short description of the repository\n * @param {string} [options.homepage] - A URL with more information about the repository\n * @param {boolean} [options.private] - Either true to make the repository private, or false to make it public.\n * @param {boolean} [options.has_issues] - Either true to enable issues for this repository, false to disable them.\n * @param {boolean} [options.has_wiki] - Either true to enable the wiki for this repository, false to disable it.\n * @param {boolean} [options.has_downloads] - Either true to enable downloads, false to disable them.\n * @param {string} [options.default_branch] - Updates the default branch for this repository.\n * @param {Requestable.callback} cb - will receive the updated repository back\n * @return {Promise} - the promise for the http request\n */\n updateRepository(options, cb) {\n return this._request('PATCH', `/repos/${this.__fullname}`, options, cb);\n }\n\n /**\n * Get information about the repository\n * @see https://developer.github.com/v3/repos/#get\n * @param {Requestable.callback} cb - will receive the information about the repository\n * @return {Promise} - the promise for the http request\n */\n getDetails(cb) {\n return this._request('GET', `/repos/${this.__fullname}`, null, cb);\n }\n\n /**\n * List the contributors to the repository\n * @see https://developer.github.com/v3/repos/#list-contributors\n * @param {Requestable.callback} cb - will receive the list of contributors\n * @return {Promise} - the promise for the http request\n */\n getContributors(cb) {\n return this._request('GET', `/repos/${this.__fullname}/contributors`, null, cb);\n }\n\n /**\n * List the contributor stats to the repository\n * @see https://developer.github.com/v3/repos/#list-contributors\n * @param {Requestable.callback} cb - will receive the list of contributors\n * @return {Promise} - the promise for the http request\n */\n getContributorStats(cb) {\n return this._request('GET', `/repos/${this.__fullname}/stats/contributors`, null, cb);\n }\n\n /**\n * List the users who are collaborators on the repository. The currently authenticated user must have\n * push access to use this method\n * @see https://developer.github.com/v3/repos/collaborators/#list-collaborators\n * @param {Requestable.callback} cb - will receive the list of collaborators\n * @return {Promise} - the promise for the http request\n */\n getCollaborators(cb) {\n return this._request('GET', `/repos/${this.__fullname}/collaborators`, null, cb);\n }\n\n /**\n * Check if a user is a collaborator on the repository\n * @see https://developer.github.com/v3/repos/collaborators/#check-if-a-user-is-a-collaborator\n * @param {string} username - the user to check\n * @param {Requestable.callback} cb - will receive true if the user is a collaborator and false if they are not\n * @return {Promise} - the promise for the http request {Boolean} [description]\n */\n isCollaborator(username, cb) {\n return this._request('GET', `/repos/${this.__fullname}/collaborators/${username}`, null, cb);\n }\n\n /**\n * Get the contents of a repository\n * @see https://developer.github.com/v3/repos/contents/#get-contents\n * @param {string} ref - the ref to check\n * @param {string} path - the path containing the content to fetch\n * @param {boolean} raw - `true` if the results should be returned raw instead of GitHub's normalized format\n * @param {Requestable.callback} cb - will receive the fetched data\n * @return {Promise} - the promise for the http request\n */\n getContents(ref, path, raw, cb) {\n path = path ? `${encodeURI(path)}` : '';\n return this._request('GET', `/repos/${this.__fullname}/contents/${path}`, {\n ref,\n }, cb, raw);\n }\n\n /**\n * Get the README of a repository\n * @see https://developer.github.com/v3/repos/contents/#get-the-readme\n * @param {string} ref - the ref to check\n * @param {boolean} raw - `true` if the results should be returned raw instead of GitHub's normalized format\n * @param {Requestable.callback} cb - will receive the fetched data\n * @return {Promise} - the promise for the http request\n */\n getReadme(ref, raw, cb) {\n return this._request('GET', `/repos/${this.__fullname}/readme`, {\n ref,\n }, cb, raw);\n }\n\n /**\n * Fork a repository\n * @see https://developer.github.com/v3/repos/forks/#create-a-fork\n * @param {Requestable.callback} cb - will receive the information about the newly created fork\n * @return {Promise} - the promise for the http request\n */\n fork(cb) {\n return this._request('POST', `/repos/${this.__fullname}/forks`, null, cb);\n }\n\n /**\n * List a repository's forks\n * @see https://developer.github.com/v3/repos/forks/#list-forks\n * @param {Requestable.callback} cb - will receive the list of repositories forked from this one\n * @return {Promise} - the promise for the http request\n */\n listForks(cb) {\n return this._request('GET', `/repos/${this.__fullname}/forks`, null, cb);\n }\n\n /**\n * Create a new branch from an existing branch.\n * @param {string} [oldBranch=master] - the name of the existing branch\n * @param {string} newBranch - the name of the new branch\n * @param {Requestable.callback} cb - will receive the commit data for the head of the new branch\n * @return {Promise} - the promise for the http request\n */\n createBranch(oldBranch, newBranch, cb) {\n if (typeof newBranch === 'function') {\n cb = newBranch;\n newBranch = oldBranch;\n oldBranch = 'master';\n }\n\n return this.getRef(`heads/${oldBranch}`)\n .then((response) => {\n let sha = response.data.object.sha;\n return this.createRef({\n sha,\n ref: `refs/heads/${newBranch}`,\n }, cb);\n });\n }\n\n /**\n * Create a new pull request\n * @see https://developer.github.com/v3/pulls/#create-a-pull-request\n * @param {Object} options - the pull request description\n * @param {Requestable.callback} cb - will receive the new pull request\n * @return {Promise} - the promise for the http request\n */\n createPullRequest(options, cb) {\n return this._request('POST', `/repos/${this.__fullname}/pulls`, options, cb);\n }\n\n /**\n * Update a pull request\n * @see https://developer.github.com/v3/pulls/#update-a-pull-request\n * @param {number|string} number - the number of the pull request to update\n * @param {Object} options - the pull request description\n * @param {Requestable.callback} [cb] - will receive the pull request information\n * @return {Promise} - the promise for the http request\n */\n updatePullRequest(number, options, cb) {\n return this._request('PATCH', `/repos/${this.__fullname}/pulls/${number}`, options, cb);\n }\n\n /**\n * List the hooks for the repository\n * @see https://developer.github.com/v3/repos/hooks/#list-hooks\n * @param {Requestable.callback} cb - will receive the list of hooks\n * @return {Promise} - the promise for the http request\n */\n listHooks(cb) {\n return this._request('GET', `/repos/${this.__fullname}/hooks`, null, cb);\n }\n\n /**\n * Get a hook for the repository\n * @see https://developer.github.com/v3/repos/hooks/#get-single-hook\n * @param {number} id - the id of the webook\n * @param {Requestable.callback} cb - will receive the details of the webook\n * @return {Promise} - the promise for the http request\n */\n getHook(id, cb) {\n return this._request('GET', `/repos/${this.__fullname}/hooks/${id}`, null, cb);\n }\n\n /**\n * Add a new hook to the repository\n * @see https://developer.github.com/v3/repos/hooks/#create-a-hook\n * @param {Object} options - the configuration describing the new hook\n * @param {Requestable.callback} cb - will receive the new webhook\n * @return {Promise} - the promise for the http request\n */\n createHook(options, cb) {\n return this._request('POST', `/repos/${this.__fullname}/hooks`, options, cb);\n }\n\n /**\n * Edit an existing webhook\n * @see https://developer.github.com/v3/repos/hooks/#edit-a-hook\n * @param {number} id - the id of the webhook\n * @param {Object} options - the new description of the webhook\n * @param {Requestable.callback} cb - will receive the updated webhook\n * @return {Promise} - the promise for the http request\n */\n updateHook(id, options, cb) {\n return this._request('PATCH', `/repos/${this.__fullname}/hooks/${id}`, options, cb);\n }\n\n /**\n * Delete a webhook\n * @see https://developer.github.com/v3/repos/hooks/#delete-a-hook\n * @param {number} id - the id of the webhook to be deleted\n * @param {Requestable.callback} cb - will receive true if the call is successful\n * @return {Promise} - the promise for the http request\n */\n deleteHook(id, cb) {\n return this._request('DELETE', `/repos/${this.__fullname}/hooks/${id}`, null, cb);\n }\n\n /**\n * List the deploy keys for the repository\n * @see https://developer.github.com/v3/repos/keys/#list-deploy-keys\n * @param {Requestable.callback} cb - will receive the list of deploy keys\n * @return {Promise} - the promise for the http request\n */\n listKeys(cb) {\n return this._request('GET', `/repos/${this.__fullname}/keys`, null, cb);\n }\n\n /**\n * Get a deploy key for the repository\n * @see https://developer.github.com/v3/repos/keys/#get-a-deploy-key\n * @param {number} id - the id of the deploy key\n * @param {Requestable.callback} cb - will receive the details of the deploy key\n * @return {Promise} - the promise for the http request\n */\n getKey(id, cb) {\n return this._request('GET', `/repos/${this.__fullname}/keys/${id}`, null, cb);\n }\n\n /**\n * Add a new deploy key to the repository\n * @see https://developer.github.com/v3/repos/keys/#add-a-new-deploy-key\n * @param {Object} options - the configuration describing the new deploy key\n * @param {Requestable.callback} cb - will receive the new deploy key\n * @return {Promise} - the promise for the http request\n */\n createKey(options, cb) {\n return this._request('POST', `/repos/${this.__fullname}/keys`, options, cb);\n }\n\n /**\n * Delete a deploy key\n * @see https://developer.github.com/v3/repos/keys/#remove-a-deploy-key\n * @param {number} id - the id of the deploy key to be deleted\n * @param {Requestable.callback} cb - will receive true if the call is successful\n * @return {Promise} - the promise for the http request\n */\n deleteKey(id, cb) {\n return this._request('DELETE', `/repos/${this.__fullname}/keys/${id}`, null, cb);\n }\n\n /**\n * Delete a file from a branch\n * @see https://developer.github.com/v3/repos/contents/#delete-a-file\n * @param {string} branch - the branch to delete from, or the default branch if not specified\n * @param {string} path - the path of the file to remove\n * @param {Requestable.callback} cb - will receive the commit in which the delete occurred\n * @return {Promise} - the promise for the http request\n */\n deleteFile(branch, path, cb) {\n return this.getSha(branch, path)\n .then((response) => {\n const deleteCommit = {\n message: `Delete the file at '${path}'`,\n sha: response.data.sha,\n branch,\n };\n return this._request('DELETE', `/repos/${this.__fullname}/contents/${path}`, deleteCommit, cb);\n });\n }\n\n /**\n * Change all references in a repo from oldPath to new_path\n * @param {string} branch - the branch to carry out the reference change, or the default branch if not specified\n * @param {string} oldPath - original path\n * @param {string} newPath - new reference path\n * @param {Requestable.callback} cb - will receive the commit in which the move occurred\n * @return {Promise} - the promise for the http request\n */\n move(branch, oldPath, newPath, cb) {\n let oldSha;\n return this.getRef(`heads/${branch}`)\n .then(({data: {object}}) => this.getTree(`${object.sha}?recursive=true`))\n .then(({data: {tree, sha}}) => {\n oldSha = sha;\n let newTree = tree.map((ref) => {\n if (ref.path === oldPath) {\n ref.path = newPath;\n }\n if (ref.type === 'tree') {\n delete ref.sha;\n }\n return ref;\n });\n return this.createTree(newTree);\n })\n .then(({data: tree}) => this.commit(oldSha, tree.sha, `Renamed '${oldPath}' to '${newPath}'`))\n .then(({data: commit}) => this.updateHead(`heads/${branch}`, commit.sha, true, cb));\n }\n\n /**\n * Write a file to the repository\n * @see https://developer.github.com/v3/repos/contents/#update-a-file\n * @param {string} branch - the name of the branch\n * @param {string} path - the path for the file\n * @param {string} content - the contents of the file\n * @param {string} message - the commit message\n * @param {Object} [options] - commit options\n * @param {Object} [options.author] - the author of the commit\n * @param {Object} [options.commiter] - the committer\n * @param {boolean} [options.encode] - true if the content should be base64 encoded\n * @param {Requestable.callback} cb - will receive the new commit\n * @return {Promise} - the promise for the http request\n */\n writeFile(branch, path, content, message, options, cb) {\n if (typeof options === 'function') {\n cb = options;\n options = {};\n }\n let filePath = path ? encodeURI(path) : '';\n let shouldEncode = options.encode !== false;\n let commit = {\n branch,\n message,\n author: options.author,\n committer: options.committer,\n content: shouldEncode ? Base64.encode(content) : content,\n };\n\n return this.getSha(branch, filePath)\n .then((response) => {\n commit.sha = response.data.sha;\n return this._request('PUT', `/repos/${this.__fullname}/contents/${filePath}`, commit, cb);\n }, () => {\n return this._request('PUT', `/repos/${this.__fullname}/contents/${filePath}`, commit, cb);\n });\n }\n\n /**\n * Check if a repository is starred by you\n * @see https://developer.github.com/v3/activity/starring/#check-if-you-are-starring-a-repository\n * @param {Requestable.callback} cb - will receive true if the repository is starred and false if the repository\n * is not starred\n * @return {Promise} - the promise for the http request {Boolean} [description]\n */\n isStarred(cb) {\n return this._request204or404(`/user/starred/${this.__fullname}`, null, cb);\n }\n\n /**\n * Star a repository\n * @see https://developer.github.com/v3/activity/starring/#star-a-repository\n * @param {Requestable.callback} cb - will receive true if the repository is starred\n * @return {Promise} - the promise for the http request\n */\n star(cb) {\n return this._request('PUT', `/user/starred/${this.__fullname}`, null, cb);\n }\n\n /**\n * Unstar a repository\n * @see https://developer.github.com/v3/activity/starring/#unstar-a-repository\n * @param {Requestable.callback} cb - will receive true if the repository is unstarred\n * @return {Promise} - the promise for the http request\n */\n unstar(cb) {\n return this._request('DELETE', `/user/starred/${this.__fullname}`, null, cb);\n }\n\n /**\n * Create a new release\n * @see https://developer.github.com/v3/repos/releases/#create-a-release\n * @param {Object} options - the description of the release\n * @param {Requestable.callback} cb - will receive the newly created release\n * @return {Promise} - the promise for the http request\n */\n createRelease(options, cb) {\n return this._request('POST', `/repos/${this.__fullname}/releases`, options, cb);\n }\n\n /**\n * Edit a release\n * @see https://developer.github.com/v3/repos/releases/#edit-a-release\n * @param {string} id - the id of the release\n * @param {Object} options - the description of the release\n * @param {Requestable.callback} cb - will receive the modified release\n * @return {Promise} - the promise for the http request\n */\n updateRelease(id, options, cb) {\n return this._request('PATCH', `/repos/${this.__fullname}/releases/${id}`, options, cb);\n }\n\n /**\n * Get information about all releases\n * @see https://developer.github.com/v3/repos/releases/#list-releases-for-a-repository\n * @param {Requestable.callback} cb - will receive the release information\n * @return {Promise} - the promise for the http request\n */\n listReleases(cb) {\n return this._request('GET', `/repos/${this.__fullname}/releases`, null, cb);\n }\n\n /**\n * Get information about a release\n * @see https://developer.github.com/v3/repos/releases/#get-a-single-release\n * @param {string} id - the id of the release\n * @param {Requestable.callback} cb - will receive the release information\n * @return {Promise} - the promise for the http request\n */\n getRelease(id, cb) {\n return this._request('GET', `/repos/${this.__fullname}/releases/${id}`, null, cb);\n }\n\n /**\n * Delete a release\n * @see https://developer.github.com/v3/repos/releases/#delete-a-release\n * @param {string} id - the release to be deleted\n * @param {Requestable.callback} cb - will receive true if the operation is successful\n * @return {Promise} - the promise for the http request\n */\n deleteRelease(id, cb) {\n return this._request('DELETE', `/repos/${this.__fullname}/releases/${id}`, null, cb);\n }\n\n /**\n * Merge a pull request\n * @see https://developer.github.com/v3/pulls/#merge-a-pull-request-merge-button\n * @param {number|string} number - the number of the pull request to merge\n * @param {Object} options - the merge options for the pull request\n * @param {Requestable.callback} [cb] - will receive the merge information if the operation is successful\n * @return {Promise} - the promise for the http request\n */\n mergePullRequest(number, options, cb) {\n return this._request('PUT', `/repos/${this.__fullname}/pulls/${number}/merge`, options, cb);\n }\n\n /**\n * Get information about all projects\n * @see https://developer.github.com/v3/projects/#list-repository-projects\n * @param {Requestable.callback} [cb] - will receive the list of projects\n * @return {Promise} - the promise for the http request\n */\n listProjects(cb) {\n return this._requestAllPages(`/repos/${this.__fullname}/projects`, {AcceptHeader: 'inertia-preview'}, cb);\n }\n\n /**\n * Create a new project\n * @see https://developer.github.com/v3/projects/#create-a-repository-project\n * @param {Object} options - the description of the project\n * @param {Requestable.callback} cb - will receive the newly created project\n * @return {Promise} - the promise for the http request\n */\n createProject(options, cb) {\n options = options || {};\n options.AcceptHeader = 'inertia-preview';\n return this._request('POST', `/repos/${this.__fullname}/projects`, options, cb);\n }\n\n}\n\nmodule.exports = Repository;\n","/**\n * @file\n * @copyright 2016 Yahoo Inc.\n * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n * Github.js is freely distributable.\n */\n\nimport axios from 'axios';\nimport debug from 'debug';\nimport {Base64} from 'js-base64';\n\nconst log = debug('github:request');\n\n/**\n * The error structure returned when a network call fails\n */\nclass ResponseError extends Error {\n /**\n * Construct a new ResponseError\n * @param {string} message - an message to return instead of the the default error message\n * @param {string} path - the requested path\n * @param {Object} response - the object returned by Axios\n */\n constructor(message, path, response) {\n super(message);\n this.path = path;\n this.request = response.config;\n this.response = (response || {}).response || response;\n this.status = response.status;\n }\n}\n\n/**\n * Requestable wraps the logic for making http requests to the API\n */\nclass Requestable {\n /**\n * Either a username and password or an oauth token for Github\n * @typedef {Object} Requestable.auth\n * @prop {string} [username] - the Github username\n * @prop {string} [password] - the user's password\n * @prop {token} [token] - an OAuth token\n */\n /**\n * Initialize the http internals.\n * @param {Requestable.auth} [auth] - the credentials to authenticate to Github. If auth is\n * not provided request will be made unauthenticated\n * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n * @param {string} [AcceptHeader=v3] - the accept header for the requests\n */\n constructor(auth, apiBase, AcceptHeader) {\n this.__apiBase = apiBase || 'https://api.github.com';\n this.__auth = {\n token: auth.token,\n username: auth.username,\n password: auth.password,\n };\n this.__AcceptHeader = AcceptHeader || 'v3';\n\n if (auth.token) {\n this.__authorizationHeader = 'token ' + auth.token;\n } else if (auth.username && auth.password) {\n this.__authorizationHeader = 'Basic ' + Base64.encode(auth.username + ':' + auth.password);\n }\n }\n\n /**\n * Compute the URL to use to make a request.\n * @private\n * @param {string} path - either a URL relative to the API base or an absolute URL\n * @return {string} - the URL to use\n */\n __getURL(path) {\n let url = path;\n\n if (path.indexOf('//') === -1) {\n url = this.__apiBase + path;\n }\n\n let newCacheBuster = 'timestamp=' + new Date().getTime();\n return url.replace(/(timestamp=\\d+)/, newCacheBuster);\n }\n\n /**\n * Compute the headers required for an API request.\n * @private\n * @param {boolean} raw - if the request should be treated as JSON or as a raw request\n * @param {string} AcceptHeader - the accept header for the request\n * @return {Object} - the headers to use in the request\n */\n __getRequestHeaders(raw, AcceptHeader) {\n let headers = {\n 'Content-Type': 'application/json;charset=UTF-8',\n 'Accept': 'application/vnd.github.' + (AcceptHeader || this.__AcceptHeader),\n };\n\n if (raw) {\n headers.Accept += '.raw';\n }\n headers.Accept += '+json';\n\n if (this.__authorizationHeader) {\n headers.Authorization = this.__authorizationHeader;\n }\n\n return headers;\n }\n\n /**\n * Sets the default options for API requests\n * @protected\n * @param {Object} [requestOptions={}] - the current options for the request\n * @return {Object} - the options to pass to the request\n */\n _getOptionsWithDefaults(requestOptions = {}) {\n if (!(requestOptions.visibility || requestOptions.affiliation)) {\n requestOptions.type = requestOptions.type || 'all';\n }\n requestOptions.sort = requestOptions.sort || 'updated';\n requestOptions.per_page = requestOptions.per_page || '100'; // eslint-disable-line\n\n return requestOptions;\n }\n\n /**\n * if a `Date` is passed to this function it will be converted to an ISO string\n * @param {*} date - the object to attempt to cooerce into an ISO date string\n * @return {string} - the ISO representation of `date` or whatever was passed in if it was not a date\n */\n _dateToISO(date) {\n if (date && (date instanceof Date)) {\n date = date.toISOString();\n }\n\n return date;\n }\n\n /**\n * A function that receives the result of the API request.\n * @callback Requestable.callback\n * @param {Requestable.Error} error - the error returned by the API or `null`\n * @param {(Object|true)} result - the data returned by the API or `true` if the API returns `204 No Content`\n * @param {Object} request - the raw {@linkcode https://github.com/mzabriskie/axios#response-schema Response}\n */\n /**\n * Make a request.\n * @param {string} method - the method for the request (GET, PUT, POST, DELETE)\n * @param {string} path - the path for the request\n * @param {*} [data] - the data to send to the server. For HTTP methods that don't have a body the data\n * will be sent as query parameters\n * @param {Requestable.callback} [cb] - the callback for the request\n * @param {boolean} [raw=false] - if the request should be sent as raw. If this is a falsy value then the\n * request will be made as JSON\n * @return {Promise} - the Promise for the http request\n */\n _request(method, path, data, cb, raw) {\n const url = this.__getURL(path);\n\n const AcceptHeader = (data || {}).AcceptHeader;\n if (AcceptHeader) {\n delete data.AcceptHeader;\n }\n const headers = this.__getRequestHeaders(raw, AcceptHeader);\n\n let queryParams = {};\n\n const shouldUseDataAsParams = data && (typeof data === 'object') && methodHasNoBody(method);\n if (shouldUseDataAsParams) {\n queryParams = data;\n data = undefined;\n }\n\n const config = {\n url: url,\n method: method,\n headers: headers,\n params: queryParams,\n data: data,\n responseType: raw ? 'text' : 'json',\n };\n\n log(`${config.method} to ${config.url}`);\n const requestPromise = axios(config).catch(callbackErrorOrThrow(cb, path));\n\n if (cb) {\n requestPromise.then((response) => {\n if (response.data && Object.keys(response.data).length > 0) {\n // When data has results\n cb(null, response.data, response);\n } else if (config.method !== 'GET' && Object.keys(response.data).length < 1) {\n // True when successful submit a request and receive a empty object\n cb(null, (response.status < 300), response);\n } else {\n cb(null, response.data, response);\n }\n });\n }\n\n return requestPromise;\n }\n\n /**\n * Make a request to an endpoint the returns 204 when true and 404 when false\n * @param {string} path - the path to request\n * @param {Object} data - any query parameters for the request\n * @param {Requestable.callback} cb - the callback that will receive `true` or `false`\n * @param {method} [method=GET] - HTTP Method to use\n * @return {Promise} - the promise for the http request\n */\n _request204or404(path, data, cb, method = 'GET') {\n return this._request(method, path, data)\n .then(function success(response) {\n if (cb) {\n cb(null, true, response);\n }\n return true;\n }, function failure(response) {\n if (response.response.status === 404) {\n if (cb) {\n cb(null, false, response);\n }\n return false;\n }\n\n if (cb) {\n cb(response);\n }\n throw response;\n });\n }\n\n /**\n * Make a request and fetch all the available data. Github will paginate responses so for queries\n * that might span multiple pages this method is preferred to {@link Requestable#request}\n * @param {string} path - the path to request\n * @param {Object} options - the query parameters to include\n * @param {Requestable.callback} [cb] - the function to receive the data. The returned data will always be an array.\n * @param {Object[]} results - the partial results. This argument is intended for interal use only.\n * @return {Promise} - a promise which will resolve when all pages have been fetched\n * @deprecated This will be folded into {@link Requestable#_request} in the 2.0 release.\n */\n _requestAllPages(path, options, cb, results) {\n results = results || [];\n\n return this._request('GET', path, options)\n .then((response) => {\n let thisGroup;\n if (response.data instanceof Array) {\n thisGroup = response.data;\n } else if (response.data.items instanceof Array) {\n thisGroup = response.data.items;\n } else {\n let message = `cannot figure out how to append ${response.data} to the result set`;\n throw new ResponseError(message, path, response);\n }\n results.push(...thisGroup);\n\n const nextUrl = getNextPage(response.headers.link);\n if (nextUrl && typeof options.page !== 'number') {\n log(`getting next page: ${nextUrl}`);\n return this._requestAllPages(nextUrl, options, cb, results);\n }\n\n if (cb) {\n cb(null, results, response);\n }\n\n response.data = results;\n return response;\n }).catch(callbackErrorOrThrow(cb, path));\n }\n}\n\nmodule.exports = Requestable;\n\n// ////////////////////////// //\n// Private helper functions //\n// ////////////////////////// //\nconst METHODS_WITH_NO_BODY = ['GET', 'HEAD', 'DELETE'];\nfunction methodHasNoBody(method) {\n return METHODS_WITH_NO_BODY.indexOf(method) !== -1;\n}\n\nfunction getNextPage(linksHeader = '') {\n const links = linksHeader.split(/\\s*,\\s*/); // splits and strips the urls\n return links.reduce(function(nextUrl, link) {\n if (link.search(/rel=\"next\"/) !== -1) {\n return (link.match(/<(.*)>/) || [])[1];\n }\n\n return nextUrl;\n }, undefined);\n}\n\nfunction callbackErrorOrThrow(cb, path) {\n return function handler(object) {\n let error;\n if (object.hasOwnProperty('config')) {\n const {response: {status, statusText}, config: {method, url}} = object;\n let message = (`${status} error making request ${method} ${url}: \"${statusText}\"`);\n error = new ResponseError(message, path, object);\n log(`${message} ${JSON.stringify(object.data)}`);\n } else {\n error = object;\n }\n if (cb) {\n log('going to error callback');\n cb(error);\n } else {\n log('throwing error');\n throw error;\n }\n };\n}\n","/**\n * @file\n * @copyright 2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n * Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\nimport debug from 'debug';\nconst log = debug('github:search');\n\n/**\n * Wrap the Search API\n */\nclass Search extends Requestable {\n /**\n * Create a Search\n * @param {Object} defaults - defaults for the search\n * @param {Requestable.auth} [auth] - information required to authenticate to Github\n * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n */\n constructor(defaults, auth, apiBase) {\n super(auth, apiBase);\n this.__defaults = this._getOptionsWithDefaults(defaults);\n }\n\n /**\n * Available search options\n * @see https://developer.github.com/v3/search/#parameters\n * @typedef {Object} Search.Params\n * @param {string} q - the query to make\n * @param {string} sort - the sort field, one of `stars`, `forks`, or `updated`.\n * Default is [best match](https://developer.github.com/v3/search/#ranking-search-results)\n * @param {string} order - the ordering, either `asc` or `desc`\n */\n /**\n * Perform a search on the GitHub API\n * @private\n * @param {string} path - the scope of the search\n * @param {Search.Params} [withOptions] - additional parameters for the search\n * @param {Requestable.callback} [cb] - will receive the results of the search\n * @return {Promise} - the promise for the http request\n */\n _search(path, withOptions = {}, cb = undefined) {\n let requestOptions = {};\n Object.keys(this.__defaults).forEach((prop) => {\n requestOptions[prop] = this.__defaults[prop];\n });\n Object.keys(withOptions).forEach((prop) => {\n requestOptions[prop] = withOptions[prop];\n });\n\n log(`searching ${path} with options:`, requestOptions);\n return this._requestAllPages(`/search/${path}`, requestOptions, cb);\n }\n\n /**\n * Search for repositories\n * @see https://developer.github.com/v3/search/#search-repositories\n * @param {Search.Params} [options] - additional parameters for the search\n * @param {Requestable.callback} [cb] - will receive the results of the search\n * @return {Promise} - the promise for the http request\n */\n forRepositories(options, cb) {\n return this._search('repositories', options, cb);\n }\n\n /**\n * Search for code\n * @see https://developer.github.com/v3/search/#search-code\n * @param {Search.Params} [options] - additional parameters for the search\n * @param {Requestable.callback} [cb] - will receive the results of the search\n * @return {Promise} - the promise for the http request\n */\n forCode(options, cb) {\n return this._search('code', options, cb);\n }\n\n /**\n * Search for issues\n * @see https://developer.github.com/v3/search/#search-issues\n * @param {Search.Params} [options] - additional parameters for the search\n * @param {Requestable.callback} [cb] - will receive the results of the search\n * @return {Promise} - the promise for the http request\n */\n forIssues(options, cb) {\n return this._search('issues', options, cb);\n }\n\n /**\n * Search for users\n * @see https://developer.github.com/v3/search/#search-users\n * @param {Search.Params} [options] - additional parameters for the search\n * @param {Requestable.callback} [cb] - will receive the results of the search\n * @return {Promise} - the promise for the http request\n */\n forUsers(options, cb) {\n return this._search('users', options, cb);\n }\n}\n\nmodule.exports = Search;\n","/**\n * @file\n * @copyright 2016 Matt Smith (Development Seed)\n * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n * Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\nimport debug from 'debug';\nconst log = debug('github:team');\n\n/**\n * A Team allows scoping of API requests to a particular Github Organization Team.\n */\nclass Team extends Requestable {\n /**\n * Create a Team.\n * @param {string} [teamId] - the id for the team\n * @param {Requestable.auth} [auth] - information required to authenticate to Github\n * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n */\n constructor(teamId, auth, apiBase) {\n super(auth, apiBase);\n this.__teamId = teamId;\n }\n\n /**\n * Get Team information\n * @see https://developer.github.com/v3/orgs/teams/#get-team\n * @param {Requestable.callback} [cb] - will receive the team\n * @return {Promise} - the promise for the http request\n */\n getTeam(cb) {\n log(`Fetching Team ${this.__teamId}`);\n return this._request('Get', `/teams/${this.__teamId}`, undefined, cb);\n }\n\n /**\n * List the Team's repositories\n * @see https://developer.github.com/v3/orgs/teams/#list-team-repos\n * @param {Requestable.callback} [cb] - will receive the list of repositories\n * @return {Promise} - the promise for the http request\n */\n listRepos(cb) {\n log(`Fetching repositories for Team ${this.__teamId}`);\n return this._requestAllPages(`/teams/${this.__teamId}/repos`, undefined, cb);\n }\n\n /**\n * Edit Team information\n * @see https://developer.github.com/v3/orgs/teams/#edit-team\n * @param {object} options - Parameters for team edit\n * @param {string} options.name - The name of the team\n * @param {string} [options.description] - Team description\n * @param {string} [options.repo_names] - Repos to add the team to\n * @param {string} [options.privacy=secret] - The level of privacy the team should have. Can be either one\n * of: `secret`, or `closed`\n * @param {Requestable.callback} [cb] - will receive the updated team\n * @return {Promise} - the promise for the http request\n */\n editTeam(options, cb) {\n log(`Editing Team ${this.__teamId}`);\n return this._request('PATCH', `/teams/${this.__teamId}`, options, cb);\n }\n\n /**\n * List the users who are members of the Team\n * @see https://developer.github.com/v3/orgs/teams/#list-team-members\n * @param {object} options - Parameters for listing team users\n * @param {string} [options.role=all] - can be one of: `all`, `maintainer`, or `member`\n * @param {Requestable.callback} [cb] - will receive the list of users\n * @return {Promise} - the promise for the http request\n */\n listMembers(options, cb) {\n log(`Getting members of Team ${this.__teamId}`);\n return this._requestAllPages(`/teams/${this.__teamId}/members`, options, cb);\n }\n\n /**\n * Get Team membership status for a user\n * @see https://developer.github.com/v3/orgs/teams/#get-team-membership\n * @param {string} username - can be one of: `all`, `maintainer`, or `member`\n * @param {Requestable.callback} [cb] - will receive the membership status of a user\n * @return {Promise} - the promise for the http request\n */\n getMembership(username, cb) {\n log(`Getting membership of user ${username} in Team ${this.__teamId}`);\n return this._request('GET', `/teams/${this.__teamId}/memberships/${username}`, undefined, cb);\n }\n\n /**\n * Add a member to the Team\n * @see https://developer.github.com/v3/orgs/teams/#add-team-membership\n * @param {string} username - can be one of: `all`, `maintainer`, or `member`\n * @param {object} options - Parameters for adding a team member\n * @param {string} [options.role=member] - The role that this user should have in the team. Can be one\n * of: `member`, or `maintainer`\n * @param {Requestable.callback} [cb] - will receive the membership status of added user\n * @return {Promise} - the promise for the http request\n */\n addMembership(username, options, cb) {\n log(`Adding user ${username} to Team ${this.__teamId}`);\n return this._request('PUT', `/teams/${this.__teamId}/memberships/${username}`, options, cb);\n }\n\n /**\n * Get repo management status for team\n * @see https://developer.github.com/v3/orgs/teams/#remove-team-membership\n * @param {string} owner - Organization name\n * @param {string} repo - Repo name\n * @param {Requestable.callback} [cb] - will receive the membership status of added user\n * @return {Promise} - the promise for the http request\n */\n isManagedRepo(owner, repo, cb) {\n log(`Getting repo management by Team ${this.__teamId} for repo ${owner}/${repo}`);\n return this._request204or404(`/teams/${this.__teamId}/repos/${owner}/${repo}`, undefined, cb);\n }\n\n /**\n * Add or Update repo management status for team\n * @see https://developer.github.com/v3/orgs/teams/#add-or-update-team-repository\n * @param {string} owner - Organization name\n * @param {string} repo - Repo name\n * @param {object} options - Parameters for adding or updating repo management for the team\n * @param {string} [options.permission] - The permission to grant the team on this repository. Can be one\n * of: `pull`, `push`, or `admin`\n * @param {Requestable.callback} [cb] - will receive the membership status of added user\n * @return {Promise} - the promise for the http request\n */\n manageRepo(owner, repo, options, cb) {\n log(`Adding or Updating repo management by Team ${this.__teamId} for repo ${owner}/${repo}`);\n return this._request204or404(`/teams/${this.__teamId}/repos/${owner}/${repo}`, options, cb, 'PUT');\n }\n\n /**\n * Remove repo management status for team\n * @see https://developer.github.com/v3/orgs/teams/#remove-team-repository\n * @param {string} owner - Organization name\n * @param {string} repo - Repo name\n * @param {Requestable.callback} [cb] - will receive the membership status of added user\n * @return {Promise} - the promise for the http request\n */\n unmanageRepo(owner, repo, cb) {\n log(`Remove repo management by Team ${this.__teamId} for repo ${owner}/${repo}`);\n return this._request204or404(`/teams/${this.__teamId}/repos/${owner}/${repo}`, undefined, cb, 'DELETE');\n }\n\n /**\n * Delete Team\n * @see https://developer.github.com/v3/orgs/teams/#delete-team\n * @param {Requestable.callback} [cb] - will receive the list of repositories\n * @return {Promise} - the promise for the http request\n */\n deleteTeam(cb) {\n log(`Deleting Team ${this.__teamId}`);\n return this._request204or404(`/teams/${this.__teamId}`, undefined, cb, 'DELETE');\n }\n}\n\nmodule.exports = Team;\n","/**\n * @file\n * @copyright 2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n * Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\nimport debug from 'debug';\nconst log = debug('github:user');\n\n/**\n * A User allows scoping of API requests to a particular Github user.\n */\nclass User extends Requestable {\n /**\n * Create a User.\n * @param {string} [username] - the user to use for user-scoped queries\n * @param {Requestable.auth} [auth] - information required to authenticate to Github\n * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n */\n constructor(username, auth, apiBase) {\n super(auth, apiBase);\n this.__user = username;\n }\n\n /**\n * Get the url for the request. (dependent on if we're requesting for the authenticated user or not)\n * @private\n * @param {string} endpoint - the endpoint being requested\n * @return {string} - the resolved endpoint\n */\n __getScopedUrl(endpoint) {\n if (this.__user) {\n return endpoint ?\n `/users/${this.__user}/${endpoint}` :\n `/users/${this.__user}`\n ;\n\n } else { // eslint-disable-line\n switch (endpoint) {\n case '':\n return '/user';\n\n case 'notifications':\n case 'gists':\n return `/${endpoint}`;\n\n default:\n return `/user/${endpoint}`;\n }\n }\n }\n\n /**\n * List the user's repositories\n * @see https://developer.github.com/v3/repos/#list-user-repositories\n * @param {Object} [options={}] - any options to refine the search\n * @param {Requestable.callback} [cb] - will receive the list of repositories\n * @return {Promise} - the promise for the http request\n */\n listRepos(options, cb) {\n if (typeof options === 'function') {\n cb = options;\n options = {};\n }\n\n options = this._getOptionsWithDefaults(options);\n\n log(`Fetching repositories with options: ${JSON.stringify(options)}`);\n return this._requestAllPages(this.__getScopedUrl('repos'), options, cb);\n }\n\n /**\n * List the orgs that the user belongs to\n * @see https://developer.github.com/v3/orgs/#list-user-organizations\n * @param {Requestable.callback} [cb] - will receive the list of organizations\n * @return {Promise} - the promise for the http request\n */\n listOrgs(cb) {\n return this._request('GET', this.__getScopedUrl('orgs'), null, cb);\n }\n\n /**\n * List the user's gists\n * @see https://developer.github.com/v3/gists/#list-a-users-gists\n * @param {Requestable.callback} [cb] - will receive the list of gists\n * @return {Promise} - the promise for the http request\n */\n listGists(cb) {\n return this._request('GET', this.__getScopedUrl('gists'), null, cb);\n }\n\n /**\n * List the user's starred gists\n * @see https://developer.github.com/v3/gists/#list-starred-gists\n * @param {Requestable.callback} [cb] - will receive the list of gists\n * @return {Promise} - the promise for the http request\n */\n listStarredGists(cb) {\n return this._request('GET', this.__getScopedUrl('gists/starred'), null, cb);\n }\n\n /**\n * List the user's gists\n * @see https://developer.github.com/v3/gists/#list-a-users-gists\n * @param {Requestable.callback} [cb] - will receive the list of gists\n * @return {Promise} - the promise for the http request\n */\n listStarredGists(cb) {\n return this._request('GET', this.__getScopedUrl('gists'), null, cb);\n }\n\n /**\n * List the user's notifications\n * @see https://developer.github.com/v3/activity/notifications/#list-your-notifications\n * @param {Object} [options={}] - any options to refine the search\n * @param {Requestable.callback} [cb] - will receive the list of repositories\n * @return {Promise} - the promise for the http request\n */\n listNotifications(options, cb) {\n options = options || {};\n if (typeof options === 'function') {\n cb = options;\n options = {};\n }\n\n options.since = this._dateToISO(options.since);\n options.before = this._dateToISO(options.before);\n\n return this._request('GET', this.__getScopedUrl('notifications'), options, cb);\n }\n\n /**\n * Show the user's profile\n * @see https://developer.github.com/v3/users/#get-a-single-user\n * @param {Requestable.callback} [cb] - will receive the user's information\n * @return {Promise} - the promise for the http request\n */\n getProfile(cb) {\n return this._request('GET', this.__getScopedUrl(''), null, cb);\n }\n\n /**\n * Gets the list of starred repositories for the user\n * @see https://developer.github.com/v3/activity/starring/#list-repositories-being-starred\n * @param {Requestable.callback} [cb] - will receive the list of starred repositories\n * @return {Promise} - the promise for the http request\n */\n listStarredRepos(cb) {\n let requestOptions = this._getOptionsWithDefaults();\n return this._requestAllPages(this.__getScopedUrl('starred'), requestOptions, cb);\n }\n\n /**\n * List email addresses for a user\n * @see https://developer.github.com/v3/users/emails/#list-email-addresses-for-a-user\n * @param {Requestable.callback} [cb] - will receive the list of emails\n * @return {Promise} - the promise for the http request\n */\n getEmails(cb) {\n return this._request('GET', '/user/emails', null, cb);\n }\n\n /**\n * Have the authenticated user follow this user\n * @see https://developer.github.com/v3/users/followers/#follow-a-user\n * @param {string} username - the user to follow\n * @param {Requestable.callback} [cb] - will receive true if the request succeeds\n * @return {Promise} - the promise for the http request\n */\n follow(username, cb) {\n return this._request('PUT', `/user/following/${this.__user}`, null, cb);\n }\n\n /**\n * Have the currently authenticated user unfollow this user\n * @see https://developer.github.com/v3/users/followers/#follow-a-user\n * @param {string} username - the user to unfollow\n * @param {Requestable.callback} [cb] - receives true if the request succeeds\n * @return {Promise} - the promise for the http request\n */\n unfollow(username, cb) {\n return this._request('DELETE', `/user/following/${this.__user}`, null, cb);\n }\n\n /**\n * Create a new repository for the currently authenticated user\n * @see https://developer.github.com/v3/repos/#create\n * @param {object} options - the repository definition\n * @param {Requestable.callback} [cb] - will receive the API response\n * @return {Promise} - the promise for the http request\n */\n createRepo(options, cb) {\n return this._request('POST', '/user/repos', options, cb);\n }\n}\n\nmodule.exports = User;\n","module.exports = require('./lib/axios');","'use strict';\n\nvar utils = require('./../utils');\nvar settle = require('./../core/settle');\nvar buildURL = require('./../helpers/buildURL');\nvar parseHeaders = require('./../helpers/parseHeaders');\nvar isURLSameOrigin = require('./../helpers/isURLSameOrigin');\nvar createError = require('../core/createError');\nvar btoa = (typeof window !== 'undefined' && window.btoa && window.btoa.bind(window)) || require('./../helpers/btoa');\n\nmodule.exports = function xhrAdapter(config) {\n return new Promise(function dispatchXhrRequest(resolve, reject) {\n var requestData = config.data;\n var requestHeaders = config.headers;\n\n if (utils.isFormData(requestData)) {\n delete requestHeaders['Content-Type']; // Let the browser set it\n }\n\n var request = new XMLHttpRequest();\n var loadEvent = 'onreadystatechange';\n var xDomain = false;\n\n // For IE 8/9 CORS support\n // Only supports POST and GET calls and doesn't returns the response headers.\n // DON'T do this for testing b/c XMLHttpRequest is mocked, not XDomainRequest.\n if (process.env.NODE_ENV !== 'test' &&\n typeof window !== 'undefined' &&\n window.XDomainRequest && !('withCredentials' in request) &&\n !isURLSameOrigin(config.url)) {\n request = new window.XDomainRequest();\n loadEvent = 'onload';\n xDomain = true;\n request.onprogress = function handleProgress() {};\n request.ontimeout = function handleTimeout() {};\n }\n\n // HTTP basic authentication\n if (config.auth) {\n var username = config.auth.username || '';\n var password = config.auth.password || '';\n requestHeaders.Authorization = 'Basic ' + btoa(username + ':' + password);\n }\n\n request.open(config.method.toUpperCase(), buildURL(config.url, config.params, config.paramsSerializer), true);\n\n // Set the request timeout in MS\n request.timeout = config.timeout;\n\n // Listen for ready state\n request[loadEvent] = function handleLoad() {\n if (!request || (request.readyState !== 4 && !xDomain)) {\n return;\n }\n\n // The request errored out and we didn't get a response, this will be\n // handled by onerror instead\n // With one exception: request that using file: protocol, most browsers\n // will return status as 0 even though it's a successful request\n if (request.status === 0 && !(request.responseURL && request.responseURL.indexOf('file:') === 0)) {\n return;\n }\n\n // Prepare the response\n var responseHeaders = 'getAllResponseHeaders' in request ? parseHeaders(request.getAllResponseHeaders()) : null;\n var responseData = !config.responseType || config.responseType === 'text' ? request.responseText : request.response;\n var response = {\n data: responseData,\n // IE sends 1223 instead of 204 (https://github.com/mzabriskie/axios/issues/201)\n status: request.status === 1223 ? 204 : request.status,\n statusText: request.status === 1223 ? 'No Content' : request.statusText,\n headers: responseHeaders,\n config: config,\n request: request\n };\n\n settle(resolve, reject, response);\n\n // Clean up request\n request = null;\n };\n\n // Handle low level network errors\n request.onerror = function handleError() {\n // Real errors are hidden from us by the browser\n // onerror should only fire if it's a network error\n reject(createError('Network Error', config));\n\n // Clean up request\n request = null;\n };\n\n // Handle timeout\n request.ontimeout = function handleTimeout() {\n reject(createError('timeout of ' + config.timeout + 'ms exceeded', config, 'ECONNABORTED'));\n\n // Clean up request\n request = null;\n };\n\n // Add xsrf header\n // This is only done if running in a standard browser environment.\n // Specifically not if we're in a web worker, or react-native.\n if (utils.isStandardBrowserEnv()) {\n var cookies = require('./../helpers/cookies');\n\n // Add xsrf header\n var xsrfValue = (config.withCredentials || isURLSameOrigin(config.url)) && config.xsrfCookieName ?\n cookies.read(config.xsrfCookieName) :\n undefined;\n\n if (xsrfValue) {\n requestHeaders[config.xsrfHeaderName] = xsrfValue;\n }\n }\n\n // Add headers to the request\n if ('setRequestHeader' in request) {\n utils.forEach(requestHeaders, function setRequestHeader(val, key) {\n if (typeof requestData === 'undefined' && key.toLowerCase() === 'content-type') {\n // Remove Content-Type if data is undefined\n delete requestHeaders[key];\n } else {\n // Otherwise add header to the request\n request.setRequestHeader(key, val);\n }\n });\n }\n\n // Add withCredentials to request if needed\n if (config.withCredentials) {\n request.withCredentials = true;\n }\n\n // Add responseType to request if needed\n if (config.responseType) {\n try {\n request.responseType = config.responseType;\n } catch (e) {\n if (request.responseType !== 'json') {\n throw e;\n }\n }\n }\n\n // Handle progress if needed\n if (typeof config.onDownloadProgress === 'function') {\n request.addEventListener('progress', config.onDownloadProgress);\n }\n\n // Not all browsers support upload events\n if (typeof config.onUploadProgress === 'function' && request.upload) {\n request.upload.addEventListener('progress', config.onUploadProgress);\n }\n\n if (config.cancelToken) {\n // Handle cancellation\n config.cancelToken.promise.then(function onCanceled(cancel) {\n if (!request) {\n return;\n }\n\n request.abort();\n reject(cancel);\n // Clean up request\n request = null;\n });\n }\n\n if (requestData === undefined) {\n requestData = null;\n }\n\n // Send the request\n request.send(requestData);\n });\n};\n","'use strict';\n\nvar utils = require('./utils');\nvar bind = require('./helpers/bind');\nvar Axios = require('./core/Axios');\nvar defaults = require('./defaults');\n\n/**\n * Create an instance of Axios\n *\n * @param {Object} defaultConfig The default config for the instance\n * @return {Axios} A new instance of Axios\n */\nfunction createInstance(defaultConfig) {\n var context = new Axios(defaultConfig);\n var instance = bind(Axios.prototype.request, context);\n\n // Copy axios.prototype to instance\n utils.extend(instance, Axios.prototype, context);\n\n // Copy context to instance\n utils.extend(instance, context);\n\n return instance;\n}\n\n// Create the default instance to be exported\nvar axios = createInstance(defaults);\n\n// Expose Axios class to allow class inheritance\naxios.Axios = Axios;\n\n// Factory for creating new instances\naxios.create = function create(instanceConfig) {\n return createInstance(utils.merge(defaults, instanceConfig));\n};\n\n// Expose Cancel & CancelToken\naxios.Cancel = require('./cancel/Cancel');\naxios.CancelToken = require('./cancel/CancelToken');\naxios.isCancel = require('./cancel/isCancel');\n\n// Expose all/spread\naxios.all = function all(promises) {\n return Promise.all(promises);\n};\naxios.spread = require('./helpers/spread');\n\nmodule.exports = axios;\n\n// Allow use of default import syntax in TypeScript\nmodule.exports.default = axios;\n","'use strict';\n\n/**\n * A `Cancel` is an object that is thrown when an operation is canceled.\n *\n * @class\n * @param {string=} message The message.\n */\nfunction Cancel(message) {\n this.message = message;\n}\n\nCancel.prototype.toString = function toString() {\n return 'Cancel' + (this.message ? ': ' + this.message : '');\n};\n\nCancel.prototype.__CANCEL__ = true;\n\nmodule.exports = Cancel;\n","'use strict';\n\nvar Cancel = require('./Cancel');\n\n/**\n * A `CancelToken` is an object that can be used to request cancellation of an operation.\n *\n * @class\n * @param {Function} executor The executor function.\n */\nfunction CancelToken(executor) {\n if (typeof executor !== 'function') {\n throw new TypeError('executor must be a function.');\n }\n\n var resolvePromise;\n this.promise = new Promise(function promiseExecutor(resolve) {\n resolvePromise = resolve;\n });\n\n var token = this;\n executor(function cancel(message) {\n if (token.reason) {\n // Cancellation has already been requested\n return;\n }\n\n token.reason = new Cancel(message);\n resolvePromise(token.reason);\n });\n}\n\n/**\n * Throws a `Cancel` if cancellation has been requested.\n */\nCancelToken.prototype.throwIfRequested = function throwIfRequested() {\n if (this.reason) {\n throw this.reason;\n }\n};\n\n/**\n * Returns an object that contains a new `CancelToken` and a function that, when called,\n * cancels the `CancelToken`.\n */\nCancelToken.source = function source() {\n var cancel;\n var token = new CancelToken(function executor(c) {\n cancel = c;\n });\n return {\n token: token,\n cancel: cancel\n };\n};\n\nmodule.exports = CancelToken;\n","'use strict';\n\nmodule.exports = function isCancel(value) {\n return !!(value && value.__CANCEL__);\n};\n","'use strict';\n\nvar defaults = require('./../defaults');\nvar utils = require('./../utils');\nvar InterceptorManager = require('./InterceptorManager');\nvar dispatchRequest = require('./dispatchRequest');\nvar isAbsoluteURL = require('./../helpers/isAbsoluteURL');\nvar combineURLs = require('./../helpers/combineURLs');\n\n/**\n * Create a new instance of Axios\n *\n * @param {Object} instanceConfig The default config for the instance\n */\nfunction Axios(instanceConfig) {\n this.defaults = instanceConfig;\n this.interceptors = {\n request: new InterceptorManager(),\n response: new InterceptorManager()\n };\n}\n\n/**\n * Dispatch a request\n *\n * @param {Object} config The config specific for this request (merged with this.defaults)\n */\nAxios.prototype.request = function request(config) {\n /*eslint no-param-reassign:0*/\n // Allow for axios('example/url'[, config]) a la fetch API\n if (typeof config === 'string') {\n config = utils.merge({\n url: arguments[0]\n }, arguments[1]);\n }\n\n config = utils.merge(defaults, this.defaults, { method: 'get' }, config);\n\n // Support baseURL config\n if (config.baseURL && !isAbsoluteURL(config.url)) {\n config.url = combineURLs(config.baseURL, config.url);\n }\n\n // Hook up interceptors middleware\n var chain = [dispatchRequest, undefined];\n var promise = Promise.resolve(config);\n\n this.interceptors.request.forEach(function unshiftRequestInterceptors(interceptor) {\n chain.unshift(interceptor.fulfilled, interceptor.rejected);\n });\n\n this.interceptors.response.forEach(function pushResponseInterceptors(interceptor) {\n chain.push(interceptor.fulfilled, interceptor.rejected);\n });\n\n while (chain.length) {\n promise = promise.then(chain.shift(), chain.shift());\n }\n\n return promise;\n};\n\n// Provide aliases for supported request methods\nutils.forEach(['delete', 'get', 'head'], function forEachMethodNoData(method) {\n /*eslint func-names:0*/\n Axios.prototype[method] = function(url, config) {\n return this.request(utils.merge(config || {}, {\n method: method,\n url: url\n }));\n };\n});\n\nutils.forEach(['post', 'put', 'patch'], function forEachMethodWithData(method) {\n /*eslint func-names:0*/\n Axios.prototype[method] = function(url, data, config) {\n return this.request(utils.merge(config || {}, {\n method: method,\n url: url,\n data: data\n }));\n };\n});\n\nmodule.exports = Axios;\n","'use strict';\n\nvar utils = require('./../utils');\n\nfunction InterceptorManager() {\n this.handlers = [];\n}\n\n/**\n * Add a new interceptor to the stack\n *\n * @param {Function} fulfilled The function to handle `then` for a `Promise`\n * @param {Function} rejected The function to handle `reject` for a `Promise`\n *\n * @return {Number} An ID used to remove interceptor later\n */\nInterceptorManager.prototype.use = function use(fulfilled, rejected) {\n this.handlers.push({\n fulfilled: fulfilled,\n rejected: rejected\n });\n return this.handlers.length - 1;\n};\n\n/**\n * Remove an interceptor from the stack\n *\n * @param {Number} id The ID that was returned by `use`\n */\nInterceptorManager.prototype.eject = function eject(id) {\n if (this.handlers[id]) {\n this.handlers[id] = null;\n }\n};\n\n/**\n * Iterate over all the registered interceptors\n *\n * This method is particularly useful for skipping over any\n * interceptors that may have become `null` calling `eject`.\n *\n * @param {Function} fn The function to call for each interceptor\n */\nInterceptorManager.prototype.forEach = function forEach(fn) {\n utils.forEach(this.handlers, function forEachHandler(h) {\n if (h !== null) {\n fn(h);\n }\n });\n};\n\nmodule.exports = InterceptorManager;\n","'use strict';\n\nvar enhanceError = require('./enhanceError');\n\n/**\n * Create an Error with the specified message, config, error code, and response.\n *\n * @param {string} message The error message.\n * @param {Object} config The config.\n * @param {string} [code] The error code (for example, 'ECONNABORTED').\n @ @param {Object} [response] The response.\n * @returns {Error} The created error.\n */\nmodule.exports = function createError(message, config, code, response) {\n var error = new Error(message);\n return enhanceError(error, config, code, response);\n};\n","'use strict';\n\nvar utils = require('./../utils');\nvar transformData = require('./transformData');\nvar isCancel = require('../cancel/isCancel');\nvar defaults = require('../defaults');\n\n/**\n * Throws a `Cancel` if cancellation has been requested.\n */\nfunction throwIfCancellationRequested(config) {\n if (config.cancelToken) {\n config.cancelToken.throwIfRequested();\n }\n}\n\n/**\n * Dispatch a request to the server using the configured adapter.\n *\n * @param {object} config The config that is to be used for the request\n * @returns {Promise} The Promise to be fulfilled\n */\nmodule.exports = function dispatchRequest(config) {\n throwIfCancellationRequested(config);\n\n // Ensure headers exist\n config.headers = config.headers || {};\n\n // Transform request data\n config.data = transformData(\n config.data,\n config.headers,\n config.transformRequest\n );\n\n // Flatten headers\n config.headers = utils.merge(\n config.headers.common || {},\n config.headers[config.method] || {},\n config.headers || {}\n );\n\n utils.forEach(\n ['delete', 'get', 'head', 'post', 'put', 'patch', 'common'],\n function cleanHeaderConfig(method) {\n delete config.headers[method];\n }\n );\n\n var adapter = config.adapter || defaults.adapter;\n\n return adapter(config).then(function onAdapterResolution(response) {\n throwIfCancellationRequested(config);\n\n // Transform response data\n response.data = transformData(\n response.data,\n response.headers,\n config.transformResponse\n );\n\n return response;\n }, function onAdapterRejection(reason) {\n if (!isCancel(reason)) {\n throwIfCancellationRequested(config);\n\n // Transform response data\n if (reason && reason.response) {\n reason.response.data = transformData(\n reason.response.data,\n reason.response.headers,\n config.transformResponse\n );\n }\n }\n\n return Promise.reject(reason);\n });\n};\n","'use strict';\n\n/**\n * Update an Error with the specified config, error code, and response.\n *\n * @param {Error} error The error to update.\n * @param {Object} config The config.\n * @param {string} [code] The error code (for example, 'ECONNABORTED').\n @ @param {Object} [response] The response.\n * @returns {Error} The error.\n */\nmodule.exports = function enhanceError(error, config, code, response) {\n error.config = config;\n if (code) {\n error.code = code;\n }\n error.response = response;\n return error;\n};\n","'use strict';\n\nvar createError = require('./createError');\n\n/**\n * Resolve or reject a Promise based on response status.\n *\n * @param {Function} resolve A function that resolves the promise.\n * @param {Function} reject A function that rejects the promise.\n * @param {object} response The response.\n */\nmodule.exports = function settle(resolve, reject, response) {\n var validateStatus = response.config.validateStatus;\n // Note: status is not exposed by XDomainRequest\n if (!response.status || !validateStatus || validateStatus(response.status)) {\n resolve(response);\n } else {\n reject(createError(\n 'Request failed with status code ' + response.status,\n response.config,\n null,\n response\n ));\n }\n};\n","'use strict';\n\nvar utils = require('./../utils');\n\n/**\n * Transform the data for a request or a response\n *\n * @param {Object|String} data The data to be transformed\n * @param {Array} headers The headers for the request or response\n * @param {Array|Function} fns A single function or Array of functions\n * @returns {*} The resulting transformed data\n */\nmodule.exports = function transformData(data, headers, fns) {\n /*eslint no-param-reassign:0*/\n utils.forEach(fns, function transform(fn) {\n data = fn(data, headers);\n });\n\n return data;\n};\n","'use strict';\n\nvar utils = require('./utils');\nvar normalizeHeaderName = require('./helpers/normalizeHeaderName');\n\nvar PROTECTION_PREFIX = /^\\)\\]\\}',?\\n/;\nvar DEFAULT_CONTENT_TYPE = {\n 'Content-Type': 'application/x-www-form-urlencoded'\n};\n\nfunction setContentTypeIfUnset(headers, value) {\n if (!utils.isUndefined(headers) && utils.isUndefined(headers['Content-Type'])) {\n headers['Content-Type'] = value;\n }\n}\n\nfunction getDefaultAdapter() {\n var adapter;\n if (typeof XMLHttpRequest !== 'undefined') {\n // For browsers use XHR adapter\n adapter = require('./adapters/xhr');\n } else if (typeof process !== 'undefined') {\n // For node use HTTP adapter\n adapter = require('./adapters/http');\n }\n return adapter;\n}\n\nvar defaults = {\n adapter: getDefaultAdapter(),\n\n transformRequest: [function transformRequest(data, headers) {\n normalizeHeaderName(headers, 'Content-Type');\n if (utils.isFormData(data) ||\n utils.isArrayBuffer(data) ||\n utils.isStream(data) ||\n utils.isFile(data) ||\n utils.isBlob(data)\n ) {\n return data;\n }\n if (utils.isArrayBufferView(data)) {\n return data.buffer;\n }\n if (utils.isURLSearchParams(data)) {\n setContentTypeIfUnset(headers, 'application/x-www-form-urlencoded;charset=utf-8');\n return data.toString();\n }\n if (utils.isObject(data)) {\n setContentTypeIfUnset(headers, 'application/json;charset=utf-8');\n return JSON.stringify(data);\n }\n return data;\n }],\n\n transformResponse: [function transformResponse(data) {\n /*eslint no-param-reassign:0*/\n if (typeof data === 'string') {\n data = data.replace(PROTECTION_PREFIX, '');\n try {\n data = JSON.parse(data);\n } catch (e) { /* Ignore */ }\n }\n return data;\n }],\n\n timeout: 0,\n\n xsrfCookieName: 'XSRF-TOKEN',\n xsrfHeaderName: 'X-XSRF-TOKEN',\n\n maxContentLength: -1,\n\n validateStatus: function validateStatus(status) {\n return status >= 200 && status < 300;\n }\n};\n\ndefaults.headers = {\n common: {\n 'Accept': 'application/json, text/plain, */*'\n }\n};\n\nutils.forEach(['delete', 'get', 'head'], function forEachMehtodNoData(method) {\n defaults.headers[method] = {};\n});\n\nutils.forEach(['post', 'put', 'patch'], function forEachMethodWithData(method) {\n defaults.headers[method] = utils.merge(DEFAULT_CONTENT_TYPE);\n});\n\nmodule.exports = defaults;\n","'use strict';\n\nmodule.exports = function bind(fn, thisArg) {\n return function wrap() {\n var args = new Array(arguments.length);\n for (var i = 0; i < args.length; i++) {\n args[i] = arguments[i];\n }\n return fn.apply(thisArg, args);\n };\n};\n","'use strict';\n\n// btoa polyfill for IE<10 courtesy https://github.com/davidchambers/Base64.js\n\nvar chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=';\n\nfunction E() {\n this.message = 'String contains an invalid character';\n}\nE.prototype = new Error;\nE.prototype.code = 5;\nE.prototype.name = 'InvalidCharacterError';\n\nfunction btoa(input) {\n var str = String(input);\n var output = '';\n for (\n // initialize result and counter\n var block, charCode, idx = 0, map = chars;\n // if the next str index does not exist:\n // change the mapping table to \"=\"\n // check if d has no fractional digits\n str.charAt(idx | 0) || (map = '=', idx % 1);\n // \"8 - idx % 1 * 8\" generates the sequence 2, 4, 6, 8\n output += map.charAt(63 & block >> 8 - idx % 1 * 8)\n ) {\n charCode = str.charCodeAt(idx += 3 / 4);\n if (charCode > 0xFF) {\n throw new E();\n }\n block = block << 8 | charCode;\n }\n return output;\n}\n\nmodule.exports = btoa;\n","'use strict';\n\nvar utils = require('./../utils');\n\nfunction encode(val) {\n return encodeURIComponent(val).\n replace(/%40/gi, '@').\n replace(/%3A/gi, ':').\n replace(/%24/g, '$').\n replace(/%2C/gi, ',').\n replace(/%20/g, '+').\n replace(/%5B/gi, '[').\n replace(/%5D/gi, ']');\n}\n\n/**\n * Build a URL by appending params to the end\n *\n * @param {string} url The base of the url (e.g., http://www.google.com)\n * @param {object} [params] The params to be appended\n * @returns {string} The formatted url\n */\nmodule.exports = function buildURL(url, params, paramsSerializer) {\n /*eslint no-param-reassign:0*/\n if (!params) {\n return url;\n }\n\n var serializedParams;\n if (paramsSerializer) {\n serializedParams = paramsSerializer(params);\n } else if (utils.isURLSearchParams(params)) {\n serializedParams = params.toString();\n } else {\n var parts = [];\n\n utils.forEach(params, function serialize(val, key) {\n if (val === null || typeof val === 'undefined') {\n return;\n }\n\n if (utils.isArray(val)) {\n key = key + '[]';\n }\n\n if (!utils.isArray(val)) {\n val = [val];\n }\n\n utils.forEach(val, function parseValue(v) {\n if (utils.isDate(v)) {\n v = v.toISOString();\n } else if (utils.isObject(v)) {\n v = JSON.stringify(v);\n }\n parts.push(encode(key) + '=' + encode(v));\n });\n });\n\n serializedParams = parts.join('&');\n }\n\n if (serializedParams) {\n url += (url.indexOf('?') === -1 ? '?' : '&') + serializedParams;\n }\n\n return url;\n};\n","'use strict';\n\n/**\n * Creates a new URL by combining the specified URLs\n *\n * @param {string} baseURL The base URL\n * @param {string} relativeURL The relative URL\n * @returns {string} The combined URL\n */\nmodule.exports = function combineURLs(baseURL, relativeURL) {\n return baseURL.replace(/\\/+$/, '') + '/' + relativeURL.replace(/^\\/+/, '');\n};\n","'use strict';\n\nvar utils = require('./../utils');\n\nmodule.exports = (\n utils.isStandardBrowserEnv() ?\n\n // Standard browser envs support document.cookie\n (function standardBrowserEnv() {\n return {\n write: function write(name, value, expires, path, domain, secure) {\n var cookie = [];\n cookie.push(name + '=' + encodeURIComponent(value));\n\n if (utils.isNumber(expires)) {\n cookie.push('expires=' + new Date(expires).toGMTString());\n }\n\n if (utils.isString(path)) {\n cookie.push('path=' + path);\n }\n\n if (utils.isString(domain)) {\n cookie.push('domain=' + domain);\n }\n\n if (secure === true) {\n cookie.push('secure');\n }\n\n document.cookie = cookie.join('; ');\n },\n\n read: function read(name) {\n var match = document.cookie.match(new RegExp('(^|;\\\\s*)(' + name + ')=([^;]*)'));\n return (match ? decodeURIComponent(match[3]) : null);\n },\n\n remove: function remove(name) {\n this.write(name, '', Date.now() - 86400000);\n }\n };\n })() :\n\n // Non standard browser env (web workers, react-native) lack needed support.\n (function nonStandardBrowserEnv() {\n return {\n write: function write() {},\n read: function read() { return null; },\n remove: function remove() {}\n };\n })()\n);\n","'use strict';\n\n/**\n * Determines whether the specified URL is absolute\n *\n * @param {string} url The URL to test\n * @returns {boolean} True if the specified URL is absolute, otherwise false\n */\nmodule.exports = function isAbsoluteURL(url) {\n // A URL is considered absolute if it begins with \"://\" or \"//\" (protocol-relative URL).\n // RFC 3986 defines scheme name as a sequence of characters beginning with a letter and followed\n // by any combination of letters, digits, plus, period, or hyphen.\n return /^([a-z][a-z\\d\\+\\-\\.]*:)?\\/\\//i.test(url);\n};\n","'use strict';\n\nvar utils = require('./../utils');\n\nmodule.exports = (\n utils.isStandardBrowserEnv() ?\n\n // Standard browser envs have full support of the APIs needed to test\n // whether the request URL is of the same origin as current location.\n (function standardBrowserEnv() {\n var msie = /(msie|trident)/i.test(navigator.userAgent);\n var urlParsingNode = document.createElement('a');\n var originURL;\n\n /**\n * Parse a URL to discover it's components\n *\n * @param {String} url The URL to be parsed\n * @returns {Object}\n */\n function resolveURL(url) {\n var href = url;\n\n if (msie) {\n // IE needs attribute set twice to normalize properties\n urlParsingNode.setAttribute('href', href);\n href = urlParsingNode.href;\n }\n\n urlParsingNode.setAttribute('href', href);\n\n // urlParsingNode provides the UrlUtils interface - http://url.spec.whatwg.org/#urlutils\n return {\n href: urlParsingNode.href,\n protocol: urlParsingNode.protocol ? urlParsingNode.protocol.replace(/:$/, '') : '',\n host: urlParsingNode.host,\n search: urlParsingNode.search ? urlParsingNode.search.replace(/^\\?/, '') : '',\n hash: urlParsingNode.hash ? urlParsingNode.hash.replace(/^#/, '') : '',\n hostname: urlParsingNode.hostname,\n port: urlParsingNode.port,\n pathname: (urlParsingNode.pathname.charAt(0) === '/') ?\n urlParsingNode.pathname :\n '/' + urlParsingNode.pathname\n };\n }\n\n originURL = resolveURL(window.location.href);\n\n /**\n * Determine if a URL shares the same origin as the current location\n *\n * @param {String} requestURL The URL to test\n * @returns {boolean} True if URL shares the same origin, otherwise false\n */\n return function isURLSameOrigin(requestURL) {\n var parsed = (utils.isString(requestURL)) ? resolveURL(requestURL) : requestURL;\n return (parsed.protocol === originURL.protocol &&\n parsed.host === originURL.host);\n };\n })() :\n\n // Non standard browser envs (web workers, react-native) lack needed support.\n (function nonStandardBrowserEnv() {\n return function isURLSameOrigin() {\n return true;\n };\n })()\n);\n","'use strict';\n\nvar utils = require('../utils');\n\nmodule.exports = function normalizeHeaderName(headers, normalizedName) {\n utils.forEach(headers, function processHeader(value, name) {\n if (name !== normalizedName && name.toUpperCase() === normalizedName.toUpperCase()) {\n headers[normalizedName] = value;\n delete headers[name];\n }\n });\n};\n","'use strict';\n\nvar utils = require('./../utils');\n\n/**\n * Parse headers into an object\n *\n * ```\n * Date: Wed, 27 Aug 2014 08:58:49 GMT\n * Content-Type: application/json\n * Connection: keep-alive\n * Transfer-Encoding: chunked\n * ```\n *\n * @param {String} headers Headers needing to be parsed\n * @returns {Object} Headers parsed into an object\n */\nmodule.exports = function parseHeaders(headers) {\n var parsed = {};\n var key;\n var val;\n var i;\n\n if (!headers) { return parsed; }\n\n utils.forEach(headers.split('\\n'), function parser(line) {\n i = line.indexOf(':');\n key = utils.trim(line.substr(0, i)).toLowerCase();\n val = utils.trim(line.substr(i + 1));\n\n if (key) {\n parsed[key] = parsed[key] ? parsed[key] + ', ' + val : val;\n }\n });\n\n return parsed;\n};\n","'use strict';\n\n/**\n * Syntactic sugar for invoking a function and expanding an array for arguments.\n *\n * Common use case would be to use `Function.prototype.apply`.\n *\n * ```js\n * function f(x, y, z) {}\n * var args = [1, 2, 3];\n * f.apply(null, args);\n * ```\n *\n * With `spread` this example can be re-written.\n *\n * ```js\n * spread(function(x, y, z) {})([1, 2, 3]);\n * ```\n *\n * @param {Function} callback\n * @returns {Function}\n */\nmodule.exports = function spread(callback) {\n return function wrap(arr) {\n return callback.apply(null, arr);\n };\n};\n","'use strict';\n\nvar bind = require('./helpers/bind');\n\n/*global toString:true*/\n\n// utils is a library of generic helper functions non-specific to axios\n\nvar toString = Object.prototype.toString;\n\n/**\n * Determine if a value is an Array\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if value is an Array, otherwise false\n */\nfunction isArray(val) {\n return toString.call(val) === '[object Array]';\n}\n\n/**\n * Determine if a value is an ArrayBuffer\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if value is an ArrayBuffer, otherwise false\n */\nfunction isArrayBuffer(val) {\n return toString.call(val) === '[object ArrayBuffer]';\n}\n\n/**\n * Determine if a value is a FormData\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if value is an FormData, otherwise false\n */\nfunction isFormData(val) {\n return (typeof FormData !== 'undefined') && (val instanceof FormData);\n}\n\n/**\n * Determine if a value is a view on an ArrayBuffer\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if value is a view on an ArrayBuffer, otherwise false\n */\nfunction isArrayBufferView(val) {\n var result;\n if ((typeof ArrayBuffer !== 'undefined') && (ArrayBuffer.isView)) {\n result = ArrayBuffer.isView(val);\n } else {\n result = (val) && (val.buffer) && (val.buffer instanceof ArrayBuffer);\n }\n return result;\n}\n\n/**\n * Determine if a value is a String\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if value is a String, otherwise false\n */\nfunction isString(val) {\n return typeof val === 'string';\n}\n\n/**\n * Determine if a value is a Number\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if value is a Number, otherwise false\n */\nfunction isNumber(val) {\n return typeof val === 'number';\n}\n\n/**\n * Determine if a value is undefined\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if the value is undefined, otherwise false\n */\nfunction isUndefined(val) {\n return typeof val === 'undefined';\n}\n\n/**\n * Determine if a value is an Object\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if value is an Object, otherwise false\n */\nfunction isObject(val) {\n return val !== null && typeof val === 'object';\n}\n\n/**\n * Determine if a value is a Date\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if value is a Date, otherwise false\n */\nfunction isDate(val) {\n return toString.call(val) === '[object Date]';\n}\n\n/**\n * Determine if a value is a File\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if value is a File, otherwise false\n */\nfunction isFile(val) {\n return toString.call(val) === '[object File]';\n}\n\n/**\n * Determine if a value is a Blob\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if value is a Blob, otherwise false\n */\nfunction isBlob(val) {\n return toString.call(val) === '[object Blob]';\n}\n\n/**\n * Determine if a value is a Function\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if value is a Function, otherwise false\n */\nfunction isFunction(val) {\n return toString.call(val) === '[object Function]';\n}\n\n/**\n * Determine if a value is a Stream\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if value is a Stream, otherwise false\n */\nfunction isStream(val) {\n return isObject(val) && isFunction(val.pipe);\n}\n\n/**\n * Determine if a value is a URLSearchParams object\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if value is a URLSearchParams object, otherwise false\n */\nfunction isURLSearchParams(val) {\n return typeof URLSearchParams !== 'undefined' && val instanceof URLSearchParams;\n}\n\n/**\n * Trim excess whitespace off the beginning and end of a string\n *\n * @param {String} str The String to trim\n * @returns {String} The String freed of excess whitespace\n */\nfunction trim(str) {\n return str.replace(/^\\s*/, '').replace(/\\s*$/, '');\n}\n\n/**\n * Determine if we're running in a standard browser environment\n *\n * This allows axios to run in a web worker, and react-native.\n * Both environments support XMLHttpRequest, but not fully standard globals.\n *\n * web workers:\n * typeof window -> undefined\n * typeof document -> undefined\n *\n * react-native:\n * typeof document.createElement -> undefined\n */\nfunction isStandardBrowserEnv() {\n return (\n typeof window !== 'undefined' &&\n typeof document !== 'undefined' &&\n typeof document.createElement === 'function'\n );\n}\n\n/**\n * Iterate over an Array or an Object invoking a function for each item.\n *\n * If `obj` is an Array callback will be called passing\n * the value, index, and complete array for each item.\n *\n * If 'obj' is an Object callback will be called passing\n * the value, key, and complete object for each property.\n *\n * @param {Object|Array} obj The object to iterate\n * @param {Function} fn The callback to invoke for each item\n */\nfunction forEach(obj, fn) {\n // Don't bother if no value provided\n if (obj === null || typeof obj === 'undefined') {\n return;\n }\n\n // Force an array if not already something iterable\n if (typeof obj !== 'object' && !isArray(obj)) {\n /*eslint no-param-reassign:0*/\n obj = [obj];\n }\n\n if (isArray(obj)) {\n // Iterate over array values\n for (var i = 0, l = obj.length; i < l; i++) {\n fn.call(null, obj[i], i, obj);\n }\n } else {\n // Iterate over object keys\n for (var key in obj) {\n if (Object.prototype.hasOwnProperty.call(obj, key)) {\n fn.call(null, obj[key], key, obj);\n }\n }\n }\n}\n\n/**\n * Accepts varargs expecting each argument to be an object, then\n * immutably merges the properties of each object and returns result.\n *\n * When multiple objects contain the same key the later object in\n * the arguments list will take precedence.\n *\n * Example:\n *\n * ```js\n * var result = merge({foo: 123}, {foo: 456});\n * console.log(result.foo); // outputs 456\n * ```\n *\n * @param {Object} obj1 Object to merge\n * @returns {Object} Result of all merge properties\n */\nfunction merge(/* obj1, obj2, obj3, ... */) {\n var result = {};\n function assignValue(val, key) {\n if (typeof result[key] === 'object' && typeof val === 'object') {\n result[key] = merge(result[key], val);\n } else {\n result[key] = val;\n }\n }\n\n for (var i = 0, l = arguments.length; i < l; i++) {\n forEach(arguments[i], assignValue);\n }\n return result;\n}\n\n/**\n * Extends object a by mutably adding to it the properties of object b.\n *\n * @param {Object} a The object to be extended\n * @param {Object} b The object to copy properties from\n * @param {Object} thisArg The object to bind function to\n * @return {Object} The resulting value of object a\n */\nfunction extend(a, b, thisArg) {\n forEach(b, function assignValue(val, key) {\n if (thisArg && typeof val === 'function') {\n a[key] = bind(val, thisArg);\n } else {\n a[key] = val;\n }\n });\n return a;\n}\n\nmodule.exports = {\n isArray: isArray,\n isArrayBuffer: isArrayBuffer,\n isFormData: isFormData,\n isArrayBufferView: isArrayBufferView,\n isString: isString,\n isNumber: isNumber,\n isObject: isObject,\n isUndefined: isUndefined,\n isDate: isDate,\n isFile: isFile,\n isBlob: isBlob,\n isFunction: isFunction,\n isStream: isStream,\n isURLSearchParams: isURLSearchParams,\n isStandardBrowserEnv: isStandardBrowserEnv,\n forEach: forEach,\n merge: merge,\n extend: extend,\n trim: trim\n};\n","'use strict'\n\nexports.byteLength = byteLength\nexports.toByteArray = toByteArray\nexports.fromByteArray = fromByteArray\n\nvar lookup = []\nvar revLookup = []\nvar Arr = typeof Uint8Array !== 'undefined' ? Uint8Array : Array\n\nvar code = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'\nfor (var i = 0, len = code.length; i < len; ++i) {\n lookup[i] = code[i]\n revLookup[code.charCodeAt(i)] = i\n}\n\nrevLookup['-'.charCodeAt(0)] = 62\nrevLookup['_'.charCodeAt(0)] = 63\n\nfunction placeHoldersCount (b64) {\n var len = b64.length\n if (len % 4 > 0) {\n throw new Error('Invalid string. Length must be a multiple of 4')\n }\n\n // the number of equal signs (place holders)\n // if there are two placeholders, than the two characters before it\n // represent one byte\n // if there is only one, then the three characters before it represent 2 bytes\n // this is just a cheap hack to not do indexOf twice\n return b64[len - 2] === '=' ? 2 : b64[len - 1] === '=' ? 1 : 0\n}\n\nfunction byteLength (b64) {\n // base64 is 4/3 + up to two characters of the original data\n return b64.length * 3 / 4 - placeHoldersCount(b64)\n}\n\nfunction toByteArray (b64) {\n var i, j, l, tmp, placeHolders, arr\n var len = b64.length\n placeHolders = placeHoldersCount(b64)\n\n arr = new Arr(len * 3 / 4 - placeHolders)\n\n // if there are placeholders, only get up to the last complete 4 chars\n l = placeHolders > 0 ? len - 4 : len\n\n var L = 0\n\n for (i = 0, j = 0; i < l; i += 4, j += 3) {\n tmp = (revLookup[b64.charCodeAt(i)] << 18) | (revLookup[b64.charCodeAt(i + 1)] << 12) | (revLookup[b64.charCodeAt(i + 2)] << 6) | revLookup[b64.charCodeAt(i + 3)]\n arr[L++] = (tmp >> 16) & 0xFF\n arr[L++] = (tmp >> 8) & 0xFF\n arr[L++] = tmp & 0xFF\n }\n\n if (placeHolders === 2) {\n tmp = (revLookup[b64.charCodeAt(i)] << 2) | (revLookup[b64.charCodeAt(i + 1)] >> 4)\n arr[L++] = tmp & 0xFF\n } else if (placeHolders === 1) {\n tmp = (revLookup[b64.charCodeAt(i)] << 10) | (revLookup[b64.charCodeAt(i + 1)] << 4) | (revLookup[b64.charCodeAt(i + 2)] >> 2)\n arr[L++] = (tmp >> 8) & 0xFF\n arr[L++] = tmp & 0xFF\n }\n\n return arr\n}\n\nfunction tripletToBase64 (num) {\n return lookup[num >> 18 & 0x3F] + lookup[num >> 12 & 0x3F] + lookup[num >> 6 & 0x3F] + lookup[num & 0x3F]\n}\n\nfunction encodeChunk (uint8, start, end) {\n var tmp\n var output = []\n for (var i = start; i < end; i += 3) {\n tmp = (uint8[i] << 16) + (uint8[i + 1] << 8) + (uint8[i + 2])\n output.push(tripletToBase64(tmp))\n }\n return output.join('')\n}\n\nfunction fromByteArray (uint8) {\n var tmp\n var len = uint8.length\n var extraBytes = len % 3 // if we have 1 byte left, pad 2 bytes\n var output = ''\n var parts = []\n var maxChunkLength = 16383 // must be multiple of 3\n\n // go through the array every three bytes, we'll deal with trailing stuff later\n for (var i = 0, len2 = len - extraBytes; i < len2; i += maxChunkLength) {\n parts.push(encodeChunk(uint8, i, (i + maxChunkLength) > len2 ? len2 : (i + maxChunkLength)))\n }\n\n // pad the end with zeros, but make sure to not forget the extra bytes\n if (extraBytes === 1) {\n tmp = uint8[len - 1]\n output += lookup[tmp >> 2]\n output += lookup[(tmp << 4) & 0x3F]\n output += '=='\n } else if (extraBytes === 2) {\n tmp = (uint8[len - 2] << 8) + (uint8[len - 1])\n output += lookup[tmp >> 10]\n output += lookup[(tmp >> 4) & 0x3F]\n output += lookup[(tmp << 2) & 0x3F]\n output += '='\n }\n\n parts.push(output)\n\n return parts.join('')\n}\n","/*!\n * The buffer module from node.js, for the browser.\n *\n * @author Feross Aboukhadijeh \n * @license MIT\n */\n/* eslint-disable no-proto */\n\n'use strict'\n\nvar base64 = require('base64-js')\nvar ieee754 = require('ieee754')\nvar isArray = require('isarray')\n\nexports.Buffer = Buffer\nexports.SlowBuffer = SlowBuffer\nexports.INSPECT_MAX_BYTES = 50\n\n/**\n * If `Buffer.TYPED_ARRAY_SUPPORT`:\n * === true Use Uint8Array implementation (fastest)\n * === false Use Object implementation (most compatible, even IE6)\n *\n * Browsers that support typed arrays are IE 10+, Firefox 4+, Chrome 7+, Safari 5.1+,\n * Opera 11.6+, iOS 4.2+.\n *\n * Due to various browser bugs, sometimes the Object implementation will be used even\n * when the browser supports typed arrays.\n *\n * Note:\n *\n * - Firefox 4-29 lacks support for adding new properties to `Uint8Array` instances,\n * See: https://bugzilla.mozilla.org/show_bug.cgi?id=695438.\n *\n * - Chrome 9-10 is missing the `TypedArray.prototype.subarray` function.\n *\n * - IE10 has a broken `TypedArray.prototype.subarray` function which returns arrays of\n * incorrect length in some situations.\n\n * We detect these buggy browsers and set `Buffer.TYPED_ARRAY_SUPPORT` to `false` so they\n * get the Object implementation, which is slower but behaves correctly.\n */\nBuffer.TYPED_ARRAY_SUPPORT = global.TYPED_ARRAY_SUPPORT !== undefined\n ? global.TYPED_ARRAY_SUPPORT\n : typedArraySupport()\n\n/*\n * Export kMaxLength after typed array support is determined.\n */\nexports.kMaxLength = kMaxLength()\n\nfunction typedArraySupport () {\n try {\n var arr = new Uint8Array(1)\n arr.__proto__ = {__proto__: Uint8Array.prototype, foo: function () { return 42 }}\n return arr.foo() === 42 && // typed array instances can be augmented\n typeof arr.subarray === 'function' && // chrome 9-10 lack `subarray`\n arr.subarray(1, 1).byteLength === 0 // ie10 has broken `subarray`\n } catch (e) {\n return false\n }\n}\n\nfunction kMaxLength () {\n return Buffer.TYPED_ARRAY_SUPPORT\n ? 0x7fffffff\n : 0x3fffffff\n}\n\nfunction createBuffer (that, length) {\n if (kMaxLength() < length) {\n throw new RangeError('Invalid typed array length')\n }\n if (Buffer.TYPED_ARRAY_SUPPORT) {\n // Return an augmented `Uint8Array` instance, for best performance\n that = new Uint8Array(length)\n that.__proto__ = Buffer.prototype\n } else {\n // Fallback: Return an object instance of the Buffer class\n if (that === null) {\n that = new Buffer(length)\n }\n that.length = length\n }\n\n return that\n}\n\n/**\n * The Buffer constructor returns instances of `Uint8Array` that have their\n * prototype changed to `Buffer.prototype`. Furthermore, `Buffer` is a subclass of\n * `Uint8Array`, so the returned instances will have all the node `Buffer` methods\n * and the `Uint8Array` methods. Square bracket notation works as expected -- it\n * returns a single octet.\n *\n * The `Uint8Array` prototype remains unmodified.\n */\n\nfunction Buffer (arg, encodingOrOffset, length) {\n if (!Buffer.TYPED_ARRAY_SUPPORT && !(this instanceof Buffer)) {\n return new Buffer(arg, encodingOrOffset, length)\n }\n\n // Common case.\n if (typeof arg === 'number') {\n if (typeof encodingOrOffset === 'string') {\n throw new Error(\n 'If encoding is specified then the first argument must be a string'\n )\n }\n return allocUnsafe(this, arg)\n }\n return from(this, arg, encodingOrOffset, length)\n}\n\nBuffer.poolSize = 8192 // not used by this implementation\n\n// TODO: Legacy, not needed anymore. Remove in next major version.\nBuffer._augment = function (arr) {\n arr.__proto__ = Buffer.prototype\n return arr\n}\n\nfunction from (that, value, encodingOrOffset, length) {\n if (typeof value === 'number') {\n throw new TypeError('\"value\" argument must not be a number')\n }\n\n if (typeof ArrayBuffer !== 'undefined' && value instanceof ArrayBuffer) {\n return fromArrayBuffer(that, value, encodingOrOffset, length)\n }\n\n if (typeof value === 'string') {\n return fromString(that, value, encodingOrOffset)\n }\n\n return fromObject(that, value)\n}\n\n/**\n * Functionally equivalent to Buffer(arg, encoding) but throws a TypeError\n * if value is a number.\n * Buffer.from(str[, encoding])\n * Buffer.from(array)\n * Buffer.from(buffer)\n * Buffer.from(arrayBuffer[, byteOffset[, length]])\n **/\nBuffer.from = function (value, encodingOrOffset, length) {\n return from(null, value, encodingOrOffset, length)\n}\n\nif (Buffer.TYPED_ARRAY_SUPPORT) {\n Buffer.prototype.__proto__ = Uint8Array.prototype\n Buffer.__proto__ = Uint8Array\n if (typeof Symbol !== 'undefined' && Symbol.species &&\n Buffer[Symbol.species] === Buffer) {\n // Fix subarray() in ES2016. See: https://github.com/feross/buffer/pull/97\n Object.defineProperty(Buffer, Symbol.species, {\n value: null,\n configurable: true\n })\n }\n}\n\nfunction assertSize (size) {\n if (typeof size !== 'number') {\n throw new TypeError('\"size\" argument must be a number')\n } else if (size < 0) {\n throw new RangeError('\"size\" argument must not be negative')\n }\n}\n\nfunction alloc (that, size, fill, encoding) {\n assertSize(size)\n if (size <= 0) {\n return createBuffer(that, size)\n }\n if (fill !== undefined) {\n // Only pay attention to encoding if it's a string. This\n // prevents accidentally sending in a number that would\n // be interpretted as a start offset.\n return typeof encoding === 'string'\n ? createBuffer(that, size).fill(fill, encoding)\n : createBuffer(that, size).fill(fill)\n }\n return createBuffer(that, size)\n}\n\n/**\n * Creates a new filled Buffer instance.\n * alloc(size[, fill[, encoding]])\n **/\nBuffer.alloc = function (size, fill, encoding) {\n return alloc(null, size, fill, encoding)\n}\n\nfunction allocUnsafe (that, size) {\n assertSize(size)\n that = createBuffer(that, size < 0 ? 0 : checked(size) | 0)\n if (!Buffer.TYPED_ARRAY_SUPPORT) {\n for (var i = 0; i < size; ++i) {\n that[i] = 0\n }\n }\n return that\n}\n\n/**\n * Equivalent to Buffer(num), by default creates a non-zero-filled Buffer instance.\n * */\nBuffer.allocUnsafe = function (size) {\n return allocUnsafe(null, size)\n}\n/**\n * Equivalent to SlowBuffer(num), by default creates a non-zero-filled Buffer instance.\n */\nBuffer.allocUnsafeSlow = function (size) {\n return allocUnsafe(null, size)\n}\n\nfunction fromString (that, string, encoding) {\n if (typeof encoding !== 'string' || encoding === '') {\n encoding = 'utf8'\n }\n\n if (!Buffer.isEncoding(encoding)) {\n throw new TypeError('\"encoding\" must be a valid string encoding')\n }\n\n var length = byteLength(string, encoding) | 0\n that = createBuffer(that, length)\n\n var actual = that.write(string, encoding)\n\n if (actual !== length) {\n // Writing a hex string, for example, that contains invalid characters will\n // cause everything after the first invalid character to be ignored. (e.g.\n // 'abxxcd' will be treated as 'ab')\n that = that.slice(0, actual)\n }\n\n return that\n}\n\nfunction fromArrayLike (that, array) {\n var length = array.length < 0 ? 0 : checked(array.length) | 0\n that = createBuffer(that, length)\n for (var i = 0; i < length; i += 1) {\n that[i] = array[i] & 255\n }\n return that\n}\n\nfunction fromArrayBuffer (that, array, byteOffset, length) {\n array.byteLength // this throws if `array` is not a valid ArrayBuffer\n\n if (byteOffset < 0 || array.byteLength < byteOffset) {\n throw new RangeError('\\'offset\\' is out of bounds')\n }\n\n if (array.byteLength < byteOffset + (length || 0)) {\n throw new RangeError('\\'length\\' is out of bounds')\n }\n\n if (byteOffset === undefined && length === undefined) {\n array = new Uint8Array(array)\n } else if (length === undefined) {\n array = new Uint8Array(array, byteOffset)\n } else {\n array = new Uint8Array(array, byteOffset, length)\n }\n\n if (Buffer.TYPED_ARRAY_SUPPORT) {\n // Return an augmented `Uint8Array` instance, for best performance\n that = array\n that.__proto__ = Buffer.prototype\n } else {\n // Fallback: Return an object instance of the Buffer class\n that = fromArrayLike(that, array)\n }\n return that\n}\n\nfunction fromObject (that, obj) {\n if (Buffer.isBuffer(obj)) {\n var len = checked(obj.length) | 0\n that = createBuffer(that, len)\n\n if (that.length === 0) {\n return that\n }\n\n obj.copy(that, 0, 0, len)\n return that\n }\n\n if (obj) {\n if ((typeof ArrayBuffer !== 'undefined' &&\n obj.buffer instanceof ArrayBuffer) || 'length' in obj) {\n if (typeof obj.length !== 'number' || isnan(obj.length)) {\n return createBuffer(that, 0)\n }\n return fromArrayLike(that, obj)\n }\n\n if (obj.type === 'Buffer' && isArray(obj.data)) {\n return fromArrayLike(that, obj.data)\n }\n }\n\n throw new TypeError('First argument must be a string, Buffer, ArrayBuffer, Array, or array-like object.')\n}\n\nfunction checked (length) {\n // Note: cannot use `length < kMaxLength()` here because that fails when\n // length is NaN (which is otherwise coerced to zero.)\n if (length >= kMaxLength()) {\n throw new RangeError('Attempt to allocate Buffer larger than maximum ' +\n 'size: 0x' + kMaxLength().toString(16) + ' bytes')\n }\n return length | 0\n}\n\nfunction SlowBuffer (length) {\n if (+length != length) { // eslint-disable-line eqeqeq\n length = 0\n }\n return Buffer.alloc(+length)\n}\n\nBuffer.isBuffer = function isBuffer (b) {\n return !!(b != null && b._isBuffer)\n}\n\nBuffer.compare = function compare (a, b) {\n if (!Buffer.isBuffer(a) || !Buffer.isBuffer(b)) {\n throw new TypeError('Arguments must be Buffers')\n }\n\n if (a === b) return 0\n\n var x = a.length\n var y = b.length\n\n for (var i = 0, len = Math.min(x, y); i < len; ++i) {\n if (a[i] !== b[i]) {\n x = a[i]\n y = b[i]\n break\n }\n }\n\n if (x < y) return -1\n if (y < x) return 1\n return 0\n}\n\nBuffer.isEncoding = function isEncoding (encoding) {\n switch (String(encoding).toLowerCase()) {\n case 'hex':\n case 'utf8':\n case 'utf-8':\n case 'ascii':\n case 'latin1':\n case 'binary':\n case 'base64':\n case 'ucs2':\n case 'ucs-2':\n case 'utf16le':\n case 'utf-16le':\n return true\n default:\n return false\n }\n}\n\nBuffer.concat = function concat (list, length) {\n if (!isArray(list)) {\n throw new TypeError('\"list\" argument must be an Array of Buffers')\n }\n\n if (list.length === 0) {\n return Buffer.alloc(0)\n }\n\n var i\n if (length === undefined) {\n length = 0\n for (i = 0; i < list.length; ++i) {\n length += list[i].length\n }\n }\n\n var buffer = Buffer.allocUnsafe(length)\n var pos = 0\n for (i = 0; i < list.length; ++i) {\n var buf = list[i]\n if (!Buffer.isBuffer(buf)) {\n throw new TypeError('\"list\" argument must be an Array of Buffers')\n }\n buf.copy(buffer, pos)\n pos += buf.length\n }\n return buffer\n}\n\nfunction byteLength (string, encoding) {\n if (Buffer.isBuffer(string)) {\n return string.length\n }\n if (typeof ArrayBuffer !== 'undefined' && typeof ArrayBuffer.isView === 'function' &&\n (ArrayBuffer.isView(string) || string instanceof ArrayBuffer)) {\n return string.byteLength\n }\n if (typeof string !== 'string') {\n string = '' + string\n }\n\n var len = string.length\n if (len === 0) return 0\n\n // Use a for loop to avoid recursion\n var loweredCase = false\n for (;;) {\n switch (encoding) {\n case 'ascii':\n case 'latin1':\n case 'binary':\n return len\n case 'utf8':\n case 'utf-8':\n case undefined:\n return utf8ToBytes(string).length\n case 'ucs2':\n case 'ucs-2':\n case 'utf16le':\n case 'utf-16le':\n return len * 2\n case 'hex':\n return len >>> 1\n case 'base64':\n return base64ToBytes(string).length\n default:\n if (loweredCase) return utf8ToBytes(string).length // assume utf8\n encoding = ('' + encoding).toLowerCase()\n loweredCase = true\n }\n }\n}\nBuffer.byteLength = byteLength\n\nfunction slowToString (encoding, start, end) {\n var loweredCase = false\n\n // No need to verify that \"this.length <= MAX_UINT32\" since it's a read-only\n // property of a typed array.\n\n // This behaves neither like String nor Uint8Array in that we set start/end\n // to their upper/lower bounds if the value passed is out of range.\n // undefined is handled specially as per ECMA-262 6th Edition,\n // Section 13.3.3.7 Runtime Semantics: KeyedBindingInitialization.\n if (start === undefined || start < 0) {\n start = 0\n }\n // Return early if start > this.length. Done here to prevent potential uint32\n // coercion fail below.\n if (start > this.length) {\n return ''\n }\n\n if (end === undefined || end > this.length) {\n end = this.length\n }\n\n if (end <= 0) {\n return ''\n }\n\n // Force coersion to uint32. This will also coerce falsey/NaN values to 0.\n end >>>= 0\n start >>>= 0\n\n if (end <= start) {\n return ''\n }\n\n if (!encoding) encoding = 'utf8'\n\n while (true) {\n switch (encoding) {\n case 'hex':\n return hexSlice(this, start, end)\n\n case 'utf8':\n case 'utf-8':\n return utf8Slice(this, start, end)\n\n case 'ascii':\n return asciiSlice(this, start, end)\n\n case 'latin1':\n case 'binary':\n return latin1Slice(this, start, end)\n\n case 'base64':\n return base64Slice(this, start, end)\n\n case 'ucs2':\n case 'ucs-2':\n case 'utf16le':\n case 'utf-16le':\n return utf16leSlice(this, start, end)\n\n default:\n if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)\n encoding = (encoding + '').toLowerCase()\n loweredCase = true\n }\n }\n}\n\n// The property is used by `Buffer.isBuffer` and `is-buffer` (in Safari 5-7) to detect\n// Buffer instances.\nBuffer.prototype._isBuffer = true\n\nfunction swap (b, n, m) {\n var i = b[n]\n b[n] = b[m]\n b[m] = i\n}\n\nBuffer.prototype.swap16 = function swap16 () {\n var len = this.length\n if (len % 2 !== 0) {\n throw new RangeError('Buffer size must be a multiple of 16-bits')\n }\n for (var i = 0; i < len; i += 2) {\n swap(this, i, i + 1)\n }\n return this\n}\n\nBuffer.prototype.swap32 = function swap32 () {\n var len = this.length\n if (len % 4 !== 0) {\n throw new RangeError('Buffer size must be a multiple of 32-bits')\n }\n for (var i = 0; i < len; i += 4) {\n swap(this, i, i + 3)\n swap(this, i + 1, i + 2)\n }\n return this\n}\n\nBuffer.prototype.swap64 = function swap64 () {\n var len = this.length\n if (len % 8 !== 0) {\n throw new RangeError('Buffer size must be a multiple of 64-bits')\n }\n for (var i = 0; i < len; i += 8) {\n swap(this, i, i + 7)\n swap(this, i + 1, i + 6)\n swap(this, i + 2, i + 5)\n swap(this, i + 3, i + 4)\n }\n return this\n}\n\nBuffer.prototype.toString = function toString () {\n var length = this.length | 0\n if (length === 0) return ''\n if (arguments.length === 0) return utf8Slice(this, 0, length)\n return slowToString.apply(this, arguments)\n}\n\nBuffer.prototype.equals = function equals (b) {\n if (!Buffer.isBuffer(b)) throw new TypeError('Argument must be a Buffer')\n if (this === b) return true\n return Buffer.compare(this, b) === 0\n}\n\nBuffer.prototype.inspect = function inspect () {\n var str = ''\n var max = exports.INSPECT_MAX_BYTES\n if (this.length > 0) {\n str = this.toString('hex', 0, max).match(/.{2}/g).join(' ')\n if (this.length > max) str += ' ... '\n }\n return ''\n}\n\nBuffer.prototype.compare = function compare (target, start, end, thisStart, thisEnd) {\n if (!Buffer.isBuffer(target)) {\n throw new TypeError('Argument must be a Buffer')\n }\n\n if (start === undefined) {\n start = 0\n }\n if (end === undefined) {\n end = target ? target.length : 0\n }\n if (thisStart === undefined) {\n thisStart = 0\n }\n if (thisEnd === undefined) {\n thisEnd = this.length\n }\n\n if (start < 0 || end > target.length || thisStart < 0 || thisEnd > this.length) {\n throw new RangeError('out of range index')\n }\n\n if (thisStart >= thisEnd && start >= end) {\n return 0\n }\n if (thisStart >= thisEnd) {\n return -1\n }\n if (start >= end) {\n return 1\n }\n\n start >>>= 0\n end >>>= 0\n thisStart >>>= 0\n thisEnd >>>= 0\n\n if (this === target) return 0\n\n var x = thisEnd - thisStart\n var y = end - start\n var len = Math.min(x, y)\n\n var thisCopy = this.slice(thisStart, thisEnd)\n var targetCopy = target.slice(start, end)\n\n for (var i = 0; i < len; ++i) {\n if (thisCopy[i] !== targetCopy[i]) {\n x = thisCopy[i]\n y = targetCopy[i]\n break\n }\n }\n\n if (x < y) return -1\n if (y < x) return 1\n return 0\n}\n\n// Finds either the first index of `val` in `buffer` at offset >= `byteOffset`,\n// OR the last index of `val` in `buffer` at offset <= `byteOffset`.\n//\n// Arguments:\n// - buffer - a Buffer to search\n// - val - a string, Buffer, or number\n// - byteOffset - an index into `buffer`; will be clamped to an int32\n// - encoding - an optional encoding, relevant is val is a string\n// - dir - true for indexOf, false for lastIndexOf\nfunction bidirectionalIndexOf (buffer, val, byteOffset, encoding, dir) {\n // Empty buffer means no match\n if (buffer.length === 0) return -1\n\n // Normalize byteOffset\n if (typeof byteOffset === 'string') {\n encoding = byteOffset\n byteOffset = 0\n } else if (byteOffset > 0x7fffffff) {\n byteOffset = 0x7fffffff\n } else if (byteOffset < -0x80000000) {\n byteOffset = -0x80000000\n }\n byteOffset = +byteOffset // Coerce to Number.\n if (isNaN(byteOffset)) {\n // byteOffset: it it's undefined, null, NaN, \"foo\", etc, search whole buffer\n byteOffset = dir ? 0 : (buffer.length - 1)\n }\n\n // Normalize byteOffset: negative offsets start from the end of the buffer\n if (byteOffset < 0) byteOffset = buffer.length + byteOffset\n if (byteOffset >= buffer.length) {\n if (dir) return -1\n else byteOffset = buffer.length - 1\n } else if (byteOffset < 0) {\n if (dir) byteOffset = 0\n else return -1\n }\n\n // Normalize val\n if (typeof val === 'string') {\n val = Buffer.from(val, encoding)\n }\n\n // Finally, search either indexOf (if dir is true) or lastIndexOf\n if (Buffer.isBuffer(val)) {\n // Special case: looking for empty string/buffer always fails\n if (val.length === 0) {\n return -1\n }\n return arrayIndexOf(buffer, val, byteOffset, encoding, dir)\n } else if (typeof val === 'number') {\n val = val & 0xFF // Search for a byte value [0-255]\n if (Buffer.TYPED_ARRAY_SUPPORT &&\n typeof Uint8Array.prototype.indexOf === 'function') {\n if (dir) {\n return Uint8Array.prototype.indexOf.call(buffer, val, byteOffset)\n } else {\n return Uint8Array.prototype.lastIndexOf.call(buffer, val, byteOffset)\n }\n }\n return arrayIndexOf(buffer, [ val ], byteOffset, encoding, dir)\n }\n\n throw new TypeError('val must be string, number or Buffer')\n}\n\nfunction arrayIndexOf (arr, val, byteOffset, encoding, dir) {\n var indexSize = 1\n var arrLength = arr.length\n var valLength = val.length\n\n if (encoding !== undefined) {\n encoding = String(encoding).toLowerCase()\n if (encoding === 'ucs2' || encoding === 'ucs-2' ||\n encoding === 'utf16le' || encoding === 'utf-16le') {\n if (arr.length < 2 || val.length < 2) {\n return -1\n }\n indexSize = 2\n arrLength /= 2\n valLength /= 2\n byteOffset /= 2\n }\n }\n\n function read (buf, i) {\n if (indexSize === 1) {\n return buf[i]\n } else {\n return buf.readUInt16BE(i * indexSize)\n }\n }\n\n var i\n if (dir) {\n var foundIndex = -1\n for (i = byteOffset; i < arrLength; i++) {\n if (read(arr, i) === read(val, foundIndex === -1 ? 0 : i - foundIndex)) {\n if (foundIndex === -1) foundIndex = i\n if (i - foundIndex + 1 === valLength) return foundIndex * indexSize\n } else {\n if (foundIndex !== -1) i -= i - foundIndex\n foundIndex = -1\n }\n }\n } else {\n if (byteOffset + valLength > arrLength) byteOffset = arrLength - valLength\n for (i = byteOffset; i >= 0; i--) {\n var found = true\n for (var j = 0; j < valLength; j++) {\n if (read(arr, i + j) !== read(val, j)) {\n found = false\n break\n }\n }\n if (found) return i\n }\n }\n\n return -1\n}\n\nBuffer.prototype.includes = function includes (val, byteOffset, encoding) {\n return this.indexOf(val, byteOffset, encoding) !== -1\n}\n\nBuffer.prototype.indexOf = function indexOf (val, byteOffset, encoding) {\n return bidirectionalIndexOf(this, val, byteOffset, encoding, true)\n}\n\nBuffer.prototype.lastIndexOf = function lastIndexOf (val, byteOffset, encoding) {\n return bidirectionalIndexOf(this, val, byteOffset, encoding, false)\n}\n\nfunction hexWrite (buf, string, offset, length) {\n offset = Number(offset) || 0\n var remaining = buf.length - offset\n if (!length) {\n length = remaining\n } else {\n length = Number(length)\n if (length > remaining) {\n length = remaining\n }\n }\n\n // must be an even number of digits\n var strLen = string.length\n if (strLen % 2 !== 0) throw new TypeError('Invalid hex string')\n\n if (length > strLen / 2) {\n length = strLen / 2\n }\n for (var i = 0; i < length; ++i) {\n var parsed = parseInt(string.substr(i * 2, 2), 16)\n if (isNaN(parsed)) return i\n buf[offset + i] = parsed\n }\n return i\n}\n\nfunction utf8Write (buf, string, offset, length) {\n return blitBuffer(utf8ToBytes(string, buf.length - offset), buf, offset, length)\n}\n\nfunction asciiWrite (buf, string, offset, length) {\n return blitBuffer(asciiToBytes(string), buf, offset, length)\n}\n\nfunction latin1Write (buf, string, offset, length) {\n return asciiWrite(buf, string, offset, length)\n}\n\nfunction base64Write (buf, string, offset, length) {\n return blitBuffer(base64ToBytes(string), buf, offset, length)\n}\n\nfunction ucs2Write (buf, string, offset, length) {\n return blitBuffer(utf16leToBytes(string, buf.length - offset), buf, offset, length)\n}\n\nBuffer.prototype.write = function write (string, offset, length, encoding) {\n // Buffer#write(string)\n if (offset === undefined) {\n encoding = 'utf8'\n length = this.length\n offset = 0\n // Buffer#write(string, encoding)\n } else if (length === undefined && typeof offset === 'string') {\n encoding = offset\n length = this.length\n offset = 0\n // Buffer#write(string, offset[, length][, encoding])\n } else if (isFinite(offset)) {\n offset = offset | 0\n if (isFinite(length)) {\n length = length | 0\n if (encoding === undefined) encoding = 'utf8'\n } else {\n encoding = length\n length = undefined\n }\n // legacy write(string, encoding, offset, length) - remove in v0.13\n } else {\n throw new Error(\n 'Buffer.write(string, encoding, offset[, length]) is no longer supported'\n )\n }\n\n var remaining = this.length - offset\n if (length === undefined || length > remaining) length = remaining\n\n if ((string.length > 0 && (length < 0 || offset < 0)) || offset > this.length) {\n throw new RangeError('Attempt to write outside buffer bounds')\n }\n\n if (!encoding) encoding = 'utf8'\n\n var loweredCase = false\n for (;;) {\n switch (encoding) {\n case 'hex':\n return hexWrite(this, string, offset, length)\n\n case 'utf8':\n case 'utf-8':\n return utf8Write(this, string, offset, length)\n\n case 'ascii':\n return asciiWrite(this, string, offset, length)\n\n case 'latin1':\n case 'binary':\n return latin1Write(this, string, offset, length)\n\n case 'base64':\n // Warning: maxLength not taken into account in base64Write\n return base64Write(this, string, offset, length)\n\n case 'ucs2':\n case 'ucs-2':\n case 'utf16le':\n case 'utf-16le':\n return ucs2Write(this, string, offset, length)\n\n default:\n if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)\n encoding = ('' + encoding).toLowerCase()\n loweredCase = true\n }\n }\n}\n\nBuffer.prototype.toJSON = function toJSON () {\n return {\n type: 'Buffer',\n data: Array.prototype.slice.call(this._arr || this, 0)\n }\n}\n\nfunction base64Slice (buf, start, end) {\n if (start === 0 && end === buf.length) {\n return base64.fromByteArray(buf)\n } else {\n return base64.fromByteArray(buf.slice(start, end))\n }\n}\n\nfunction utf8Slice (buf, start, end) {\n end = Math.min(buf.length, end)\n var res = []\n\n var i = start\n while (i < end) {\n var firstByte = buf[i]\n var codePoint = null\n var bytesPerSequence = (firstByte > 0xEF) ? 4\n : (firstByte > 0xDF) ? 3\n : (firstByte > 0xBF) ? 2\n : 1\n\n if (i + bytesPerSequence <= end) {\n var secondByte, thirdByte, fourthByte, tempCodePoint\n\n switch (bytesPerSequence) {\n case 1:\n if (firstByte < 0x80) {\n codePoint = firstByte\n }\n break\n case 2:\n secondByte = buf[i + 1]\n if ((secondByte & 0xC0) === 0x80) {\n tempCodePoint = (firstByte & 0x1F) << 0x6 | (secondByte & 0x3F)\n if (tempCodePoint > 0x7F) {\n codePoint = tempCodePoint\n }\n }\n break\n case 3:\n secondByte = buf[i + 1]\n thirdByte = buf[i + 2]\n if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80) {\n tempCodePoint = (firstByte & 0xF) << 0xC | (secondByte & 0x3F) << 0x6 | (thirdByte & 0x3F)\n if (tempCodePoint > 0x7FF && (tempCodePoint < 0xD800 || tempCodePoint > 0xDFFF)) {\n codePoint = tempCodePoint\n }\n }\n break\n case 4:\n secondByte = buf[i + 1]\n thirdByte = buf[i + 2]\n fourthByte = buf[i + 3]\n if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80 && (fourthByte & 0xC0) === 0x80) {\n tempCodePoint = (firstByte & 0xF) << 0x12 | (secondByte & 0x3F) << 0xC | (thirdByte & 0x3F) << 0x6 | (fourthByte & 0x3F)\n if (tempCodePoint > 0xFFFF && tempCodePoint < 0x110000) {\n codePoint = tempCodePoint\n }\n }\n }\n }\n\n if (codePoint === null) {\n // we did not generate a valid codePoint so insert a\n // replacement char (U+FFFD) and advance only 1 byte\n codePoint = 0xFFFD\n bytesPerSequence = 1\n } else if (codePoint > 0xFFFF) {\n // encode to utf16 (surrogate pair dance)\n codePoint -= 0x10000\n res.push(codePoint >>> 10 & 0x3FF | 0xD800)\n codePoint = 0xDC00 | codePoint & 0x3FF\n }\n\n res.push(codePoint)\n i += bytesPerSequence\n }\n\n return decodeCodePointsArray(res)\n}\n\n// Based on http://stackoverflow.com/a/22747272/680742, the browser with\n// the lowest limit is Chrome, with 0x10000 args.\n// We go 1 magnitude less, for safety\nvar MAX_ARGUMENTS_LENGTH = 0x1000\n\nfunction decodeCodePointsArray (codePoints) {\n var len = codePoints.length\n if (len <= MAX_ARGUMENTS_LENGTH) {\n return String.fromCharCode.apply(String, codePoints) // avoid extra slice()\n }\n\n // Decode in chunks to avoid \"call stack size exceeded\".\n var res = ''\n var i = 0\n while (i < len) {\n res += String.fromCharCode.apply(\n String,\n codePoints.slice(i, i += MAX_ARGUMENTS_LENGTH)\n )\n }\n return res\n}\n\nfunction asciiSlice (buf, start, end) {\n var ret = ''\n end = Math.min(buf.length, end)\n\n for (var i = start; i < end; ++i) {\n ret += String.fromCharCode(buf[i] & 0x7F)\n }\n return ret\n}\n\nfunction latin1Slice (buf, start, end) {\n var ret = ''\n end = Math.min(buf.length, end)\n\n for (var i = start; i < end; ++i) {\n ret += String.fromCharCode(buf[i])\n }\n return ret\n}\n\nfunction hexSlice (buf, start, end) {\n var len = buf.length\n\n if (!start || start < 0) start = 0\n if (!end || end < 0 || end > len) end = len\n\n var out = ''\n for (var i = start; i < end; ++i) {\n out += toHex(buf[i])\n }\n return out\n}\n\nfunction utf16leSlice (buf, start, end) {\n var bytes = buf.slice(start, end)\n var res = ''\n for (var i = 0; i < bytes.length; i += 2) {\n res += String.fromCharCode(bytes[i] + bytes[i + 1] * 256)\n }\n return res\n}\n\nBuffer.prototype.slice = function slice (start, end) {\n var len = this.length\n start = ~~start\n end = end === undefined ? len : ~~end\n\n if (start < 0) {\n start += len\n if (start < 0) start = 0\n } else if (start > len) {\n start = len\n }\n\n if (end < 0) {\n end += len\n if (end < 0) end = 0\n } else if (end > len) {\n end = len\n }\n\n if (end < start) end = start\n\n var newBuf\n if (Buffer.TYPED_ARRAY_SUPPORT) {\n newBuf = this.subarray(start, end)\n newBuf.__proto__ = Buffer.prototype\n } else {\n var sliceLen = end - start\n newBuf = new Buffer(sliceLen, undefined)\n for (var i = 0; i < sliceLen; ++i) {\n newBuf[i] = this[i + start]\n }\n }\n\n return newBuf\n}\n\n/*\n * Need to make sure that buffer isn't trying to write out of bounds.\n */\nfunction checkOffset (offset, ext, length) {\n if ((offset % 1) !== 0 || offset < 0) throw new RangeError('offset is not uint')\n if (offset + ext > length) throw new RangeError('Trying to access beyond buffer length')\n}\n\nBuffer.prototype.readUIntLE = function readUIntLE (offset, byteLength, noAssert) {\n offset = offset | 0\n byteLength = byteLength | 0\n if (!noAssert) checkOffset(offset, byteLength, this.length)\n\n var val = this[offset]\n var mul = 1\n var i = 0\n while (++i < byteLength && (mul *= 0x100)) {\n val += this[offset + i] * mul\n }\n\n return val\n}\n\nBuffer.prototype.readUIntBE = function readUIntBE (offset, byteLength, noAssert) {\n offset = offset | 0\n byteLength = byteLength | 0\n if (!noAssert) {\n checkOffset(offset, byteLength, this.length)\n }\n\n var val = this[offset + --byteLength]\n var mul = 1\n while (byteLength > 0 && (mul *= 0x100)) {\n val += this[offset + --byteLength] * mul\n }\n\n return val\n}\n\nBuffer.prototype.readUInt8 = function readUInt8 (offset, noAssert) {\n if (!noAssert) checkOffset(offset, 1, this.length)\n return this[offset]\n}\n\nBuffer.prototype.readUInt16LE = function readUInt16LE (offset, noAssert) {\n if (!noAssert) checkOffset(offset, 2, this.length)\n return this[offset] | (this[offset + 1] << 8)\n}\n\nBuffer.prototype.readUInt16BE = function readUInt16BE (offset, noAssert) {\n if (!noAssert) checkOffset(offset, 2, this.length)\n return (this[offset] << 8) | this[offset + 1]\n}\n\nBuffer.prototype.readUInt32LE = function readUInt32LE (offset, noAssert) {\n if (!noAssert) checkOffset(offset, 4, this.length)\n\n return ((this[offset]) |\n (this[offset + 1] << 8) |\n (this[offset + 2] << 16)) +\n (this[offset + 3] * 0x1000000)\n}\n\nBuffer.prototype.readUInt32BE = function readUInt32BE (offset, noAssert) {\n if (!noAssert) checkOffset(offset, 4, this.length)\n\n return (this[offset] * 0x1000000) +\n ((this[offset + 1] << 16) |\n (this[offset + 2] << 8) |\n this[offset + 3])\n}\n\nBuffer.prototype.readIntLE = function readIntLE (offset, byteLength, noAssert) {\n offset = offset | 0\n byteLength = byteLength | 0\n if (!noAssert) checkOffset(offset, byteLength, this.length)\n\n var val = this[offset]\n var mul = 1\n var i = 0\n while (++i < byteLength && (mul *= 0x100)) {\n val += this[offset + i] * mul\n }\n mul *= 0x80\n\n if (val >= mul) val -= Math.pow(2, 8 * byteLength)\n\n return val\n}\n\nBuffer.prototype.readIntBE = function readIntBE (offset, byteLength, noAssert) {\n offset = offset | 0\n byteLength = byteLength | 0\n if (!noAssert) checkOffset(offset, byteLength, this.length)\n\n var i = byteLength\n var mul = 1\n var val = this[offset + --i]\n while (i > 0 && (mul *= 0x100)) {\n val += this[offset + --i] * mul\n }\n mul *= 0x80\n\n if (val >= mul) val -= Math.pow(2, 8 * byteLength)\n\n return val\n}\n\nBuffer.prototype.readInt8 = function readInt8 (offset, noAssert) {\n if (!noAssert) checkOffset(offset, 1, this.length)\n if (!(this[offset] & 0x80)) return (this[offset])\n return ((0xff - this[offset] + 1) * -1)\n}\n\nBuffer.prototype.readInt16LE = function readInt16LE (offset, noAssert) {\n if (!noAssert) checkOffset(offset, 2, this.length)\n var val = this[offset] | (this[offset + 1] << 8)\n return (val & 0x8000) ? val | 0xFFFF0000 : val\n}\n\nBuffer.prototype.readInt16BE = function readInt16BE (offset, noAssert) {\n if (!noAssert) checkOffset(offset, 2, this.length)\n var val = this[offset + 1] | (this[offset] << 8)\n return (val & 0x8000) ? val | 0xFFFF0000 : val\n}\n\nBuffer.prototype.readInt32LE = function readInt32LE (offset, noAssert) {\n if (!noAssert) checkOffset(offset, 4, this.length)\n\n return (this[offset]) |\n (this[offset + 1] << 8) |\n (this[offset + 2] << 16) |\n (this[offset + 3] << 24)\n}\n\nBuffer.prototype.readInt32BE = function readInt32BE (offset, noAssert) {\n if (!noAssert) checkOffset(offset, 4, this.length)\n\n return (this[offset] << 24) |\n (this[offset + 1] << 16) |\n (this[offset + 2] << 8) |\n (this[offset + 3])\n}\n\nBuffer.prototype.readFloatLE = function readFloatLE (offset, noAssert) {\n if (!noAssert) checkOffset(offset, 4, this.length)\n return ieee754.read(this, offset, true, 23, 4)\n}\n\nBuffer.prototype.readFloatBE = function readFloatBE (offset, noAssert) {\n if (!noAssert) checkOffset(offset, 4, this.length)\n return ieee754.read(this, offset, false, 23, 4)\n}\n\nBuffer.prototype.readDoubleLE = function readDoubleLE (offset, noAssert) {\n if (!noAssert) checkOffset(offset, 8, this.length)\n return ieee754.read(this, offset, true, 52, 8)\n}\n\nBuffer.prototype.readDoubleBE = function readDoubleBE (offset, noAssert) {\n if (!noAssert) checkOffset(offset, 8, this.length)\n return ieee754.read(this, offset, false, 52, 8)\n}\n\nfunction checkInt (buf, value, offset, ext, max, min) {\n if (!Buffer.isBuffer(buf)) throw new TypeError('\"buffer\" argument must be a Buffer instance')\n if (value > max || value < min) throw new RangeError('\"value\" argument is out of bounds')\n if (offset + ext > buf.length) throw new RangeError('Index out of range')\n}\n\nBuffer.prototype.writeUIntLE = function writeUIntLE (value, offset, byteLength, noAssert) {\n value = +value\n offset = offset | 0\n byteLength = byteLength | 0\n if (!noAssert) {\n var maxBytes = Math.pow(2, 8 * byteLength) - 1\n checkInt(this, value, offset, byteLength, maxBytes, 0)\n }\n\n var mul = 1\n var i = 0\n this[offset] = value & 0xFF\n while (++i < byteLength && (mul *= 0x100)) {\n this[offset + i] = (value / mul) & 0xFF\n }\n\n return offset + byteLength\n}\n\nBuffer.prototype.writeUIntBE = function writeUIntBE (value, offset, byteLength, noAssert) {\n value = +value\n offset = offset | 0\n byteLength = byteLength | 0\n if (!noAssert) {\n var maxBytes = Math.pow(2, 8 * byteLength) - 1\n checkInt(this, value, offset, byteLength, maxBytes, 0)\n }\n\n var i = byteLength - 1\n var mul = 1\n this[offset + i] = value & 0xFF\n while (--i >= 0 && (mul *= 0x100)) {\n this[offset + i] = (value / mul) & 0xFF\n }\n\n return offset + byteLength\n}\n\nBuffer.prototype.writeUInt8 = function writeUInt8 (value, offset, noAssert) {\n value = +value\n offset = offset | 0\n if (!noAssert) checkInt(this, value, offset, 1, 0xff, 0)\n if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value)\n this[offset] = (value & 0xff)\n return offset + 1\n}\n\nfunction objectWriteUInt16 (buf, value, offset, littleEndian) {\n if (value < 0) value = 0xffff + value + 1\n for (var i = 0, j = Math.min(buf.length - offset, 2); i < j; ++i) {\n buf[offset + i] = (value & (0xff << (8 * (littleEndian ? i : 1 - i)))) >>>\n (littleEndian ? i : 1 - i) * 8\n }\n}\n\nBuffer.prototype.writeUInt16LE = function writeUInt16LE (value, offset, noAssert) {\n value = +value\n offset = offset | 0\n if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)\n if (Buffer.TYPED_ARRAY_SUPPORT) {\n this[offset] = (value & 0xff)\n this[offset + 1] = (value >>> 8)\n } else {\n objectWriteUInt16(this, value, offset, true)\n }\n return offset + 2\n}\n\nBuffer.prototype.writeUInt16BE = function writeUInt16BE (value, offset, noAssert) {\n value = +value\n offset = offset | 0\n if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)\n if (Buffer.TYPED_ARRAY_SUPPORT) {\n this[offset] = (value >>> 8)\n this[offset + 1] = (value & 0xff)\n } else {\n objectWriteUInt16(this, value, offset, false)\n }\n return offset + 2\n}\n\nfunction objectWriteUInt32 (buf, value, offset, littleEndian) {\n if (value < 0) value = 0xffffffff + value + 1\n for (var i = 0, j = Math.min(buf.length - offset, 4); i < j; ++i) {\n buf[offset + i] = (value >>> (littleEndian ? i : 3 - i) * 8) & 0xff\n }\n}\n\nBuffer.prototype.writeUInt32LE = function writeUInt32LE (value, offset, noAssert) {\n value = +value\n offset = offset | 0\n if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)\n if (Buffer.TYPED_ARRAY_SUPPORT) {\n this[offset + 3] = (value >>> 24)\n this[offset + 2] = (value >>> 16)\n this[offset + 1] = (value >>> 8)\n this[offset] = (value & 0xff)\n } else {\n objectWriteUInt32(this, value, offset, true)\n }\n return offset + 4\n}\n\nBuffer.prototype.writeUInt32BE = function writeUInt32BE (value, offset, noAssert) {\n value = +value\n offset = offset | 0\n if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)\n if (Buffer.TYPED_ARRAY_SUPPORT) {\n this[offset] = (value >>> 24)\n this[offset + 1] = (value >>> 16)\n this[offset + 2] = (value >>> 8)\n this[offset + 3] = (value & 0xff)\n } else {\n objectWriteUInt32(this, value, offset, false)\n }\n return offset + 4\n}\n\nBuffer.prototype.writeIntLE = function writeIntLE (value, offset, byteLength, noAssert) {\n value = +value\n offset = offset | 0\n if (!noAssert) {\n var limit = Math.pow(2, 8 * byteLength - 1)\n\n checkInt(this, value, offset, byteLength, limit - 1, -limit)\n }\n\n var i = 0\n var mul = 1\n var sub = 0\n this[offset] = value & 0xFF\n while (++i < byteLength && (mul *= 0x100)) {\n if (value < 0 && sub === 0 && this[offset + i - 1] !== 0) {\n sub = 1\n }\n this[offset + i] = ((value / mul) >> 0) - sub & 0xFF\n }\n\n return offset + byteLength\n}\n\nBuffer.prototype.writeIntBE = function writeIntBE (value, offset, byteLength, noAssert) {\n value = +value\n offset = offset | 0\n if (!noAssert) {\n var limit = Math.pow(2, 8 * byteLength - 1)\n\n checkInt(this, value, offset, byteLength, limit - 1, -limit)\n }\n\n var i = byteLength - 1\n var mul = 1\n var sub = 0\n this[offset + i] = value & 0xFF\n while (--i >= 0 && (mul *= 0x100)) {\n if (value < 0 && sub === 0 && this[offset + i + 1] !== 0) {\n sub = 1\n }\n this[offset + i] = ((value / mul) >> 0) - sub & 0xFF\n }\n\n return offset + byteLength\n}\n\nBuffer.prototype.writeInt8 = function writeInt8 (value, offset, noAssert) {\n value = +value\n offset = offset | 0\n if (!noAssert) checkInt(this, value, offset, 1, 0x7f, -0x80)\n if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value)\n if (value < 0) value = 0xff + value + 1\n this[offset] = (value & 0xff)\n return offset + 1\n}\n\nBuffer.prototype.writeInt16LE = function writeInt16LE (value, offset, noAssert) {\n value = +value\n offset = offset | 0\n if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000)\n if (Buffer.TYPED_ARRAY_SUPPORT) {\n this[offset] = (value & 0xff)\n this[offset + 1] = (value >>> 8)\n } else {\n objectWriteUInt16(this, value, offset, true)\n }\n return offset + 2\n}\n\nBuffer.prototype.writeInt16BE = function writeInt16BE (value, offset, noAssert) {\n value = +value\n offset = offset | 0\n if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000)\n if (Buffer.TYPED_ARRAY_SUPPORT) {\n this[offset] = (value >>> 8)\n this[offset + 1] = (value & 0xff)\n } else {\n objectWriteUInt16(this, value, offset, false)\n }\n return offset + 2\n}\n\nBuffer.prototype.writeInt32LE = function writeInt32LE (value, offset, noAssert) {\n value = +value\n offset = offset | 0\n if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)\n if (Buffer.TYPED_ARRAY_SUPPORT) {\n this[offset] = (value & 0xff)\n this[offset + 1] = (value >>> 8)\n this[offset + 2] = (value >>> 16)\n this[offset + 3] = (value >>> 24)\n } else {\n objectWriteUInt32(this, value, offset, true)\n }\n return offset + 4\n}\n\nBuffer.prototype.writeInt32BE = function writeInt32BE (value, offset, noAssert) {\n value = +value\n offset = offset | 0\n if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)\n if (value < 0) value = 0xffffffff + value + 1\n if (Buffer.TYPED_ARRAY_SUPPORT) {\n this[offset] = (value >>> 24)\n this[offset + 1] = (value >>> 16)\n this[offset + 2] = (value >>> 8)\n this[offset + 3] = (value & 0xff)\n } else {\n objectWriteUInt32(this, value, offset, false)\n }\n return offset + 4\n}\n\nfunction checkIEEE754 (buf, value, offset, ext, max, min) {\n if (offset + ext > buf.length) throw new RangeError('Index out of range')\n if (offset < 0) throw new RangeError('Index out of range')\n}\n\nfunction writeFloat (buf, value, offset, littleEndian, noAssert) {\n if (!noAssert) {\n checkIEEE754(buf, value, offset, 4, 3.4028234663852886e+38, -3.4028234663852886e+38)\n }\n ieee754.write(buf, value, offset, littleEndian, 23, 4)\n return offset + 4\n}\n\nBuffer.prototype.writeFloatLE = function writeFloatLE (value, offset, noAssert) {\n return writeFloat(this, value, offset, true, noAssert)\n}\n\nBuffer.prototype.writeFloatBE = function writeFloatBE (value, offset, noAssert) {\n return writeFloat(this, value, offset, false, noAssert)\n}\n\nfunction writeDouble (buf, value, offset, littleEndian, noAssert) {\n if (!noAssert) {\n checkIEEE754(buf, value, offset, 8, 1.7976931348623157E+308, -1.7976931348623157E+308)\n }\n ieee754.write(buf, value, offset, littleEndian, 52, 8)\n return offset + 8\n}\n\nBuffer.prototype.writeDoubleLE = function writeDoubleLE (value, offset, noAssert) {\n return writeDouble(this, value, offset, true, noAssert)\n}\n\nBuffer.prototype.writeDoubleBE = function writeDoubleBE (value, offset, noAssert) {\n return writeDouble(this, value, offset, false, noAssert)\n}\n\n// copy(targetBuffer, targetStart=0, sourceStart=0, sourceEnd=buffer.length)\nBuffer.prototype.copy = function copy (target, targetStart, start, end) {\n if (!start) start = 0\n if (!end && end !== 0) end = this.length\n if (targetStart >= target.length) targetStart = target.length\n if (!targetStart) targetStart = 0\n if (end > 0 && end < start) end = start\n\n // Copy 0 bytes; we're done\n if (end === start) return 0\n if (target.length === 0 || this.length === 0) return 0\n\n // Fatal error conditions\n if (targetStart < 0) {\n throw new RangeError('targetStart out of bounds')\n }\n if (start < 0 || start >= this.length) throw new RangeError('sourceStart out of bounds')\n if (end < 0) throw new RangeError('sourceEnd out of bounds')\n\n // Are we oob?\n if (end > this.length) end = this.length\n if (target.length - targetStart < end - start) {\n end = target.length - targetStart + start\n }\n\n var len = end - start\n var i\n\n if (this === target && start < targetStart && targetStart < end) {\n // descending copy from end\n for (i = len - 1; i >= 0; --i) {\n target[i + targetStart] = this[i + start]\n }\n } else if (len < 1000 || !Buffer.TYPED_ARRAY_SUPPORT) {\n // ascending copy from start\n for (i = 0; i < len; ++i) {\n target[i + targetStart] = this[i + start]\n }\n } else {\n Uint8Array.prototype.set.call(\n target,\n this.subarray(start, start + len),\n targetStart\n )\n }\n\n return len\n}\n\n// Usage:\n// buffer.fill(number[, offset[, end]])\n// buffer.fill(buffer[, offset[, end]])\n// buffer.fill(string[, offset[, end]][, encoding])\nBuffer.prototype.fill = function fill (val, start, end, encoding) {\n // Handle string cases:\n if (typeof val === 'string') {\n if (typeof start === 'string') {\n encoding = start\n start = 0\n end = this.length\n } else if (typeof end === 'string') {\n encoding = end\n end = this.length\n }\n if (val.length === 1) {\n var code = val.charCodeAt(0)\n if (code < 256) {\n val = code\n }\n }\n if (encoding !== undefined && typeof encoding !== 'string') {\n throw new TypeError('encoding must be a string')\n }\n if (typeof encoding === 'string' && !Buffer.isEncoding(encoding)) {\n throw new TypeError('Unknown encoding: ' + encoding)\n }\n } else if (typeof val === 'number') {\n val = val & 255\n }\n\n // Invalid ranges are not set to a default, so can range check early.\n if (start < 0 || this.length < start || this.length < end) {\n throw new RangeError('Out of range index')\n }\n\n if (end <= start) {\n return this\n }\n\n start = start >>> 0\n end = end === undefined ? this.length : end >>> 0\n\n if (!val) val = 0\n\n var i\n if (typeof val === 'number') {\n for (i = start; i < end; ++i) {\n this[i] = val\n }\n } else {\n var bytes = Buffer.isBuffer(val)\n ? val\n : utf8ToBytes(new Buffer(val, encoding).toString())\n var len = bytes.length\n for (i = 0; i < end - start; ++i) {\n this[i + start] = bytes[i % len]\n }\n }\n\n return this\n}\n\n// HELPER FUNCTIONS\n// ================\n\nvar INVALID_BASE64_RE = /[^+\\/0-9A-Za-z-_]/g\n\nfunction base64clean (str) {\n // Node strips out invalid characters like \\n and \\t from the string, base64-js does not\n str = stringtrim(str).replace(INVALID_BASE64_RE, '')\n // Node converts strings with length < 2 to ''\n if (str.length < 2) return ''\n // Node allows for non-padded base64 strings (missing trailing ===), base64-js does not\n while (str.length % 4 !== 0) {\n str = str + '='\n }\n return str\n}\n\nfunction stringtrim (str) {\n if (str.trim) return str.trim()\n return str.replace(/^\\s+|\\s+$/g, '')\n}\n\nfunction toHex (n) {\n if (n < 16) return '0' + n.toString(16)\n return n.toString(16)\n}\n\nfunction utf8ToBytes (string, units) {\n units = units || Infinity\n var codePoint\n var length = string.length\n var leadSurrogate = null\n var bytes = []\n\n for (var i = 0; i < length; ++i) {\n codePoint = string.charCodeAt(i)\n\n // is surrogate component\n if (codePoint > 0xD7FF && codePoint < 0xE000) {\n // last char was a lead\n if (!leadSurrogate) {\n // no lead yet\n if (codePoint > 0xDBFF) {\n // unexpected trail\n if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n continue\n } else if (i + 1 === length) {\n // unpaired lead\n if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n continue\n }\n\n // valid lead\n leadSurrogate = codePoint\n\n continue\n }\n\n // 2 leads in a row\n if (codePoint < 0xDC00) {\n if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n leadSurrogate = codePoint\n continue\n }\n\n // valid surrogate pair\n codePoint = (leadSurrogate - 0xD800 << 10 | codePoint - 0xDC00) + 0x10000\n } else if (leadSurrogate) {\n // valid bmp char, but last char was a lead\n if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n }\n\n leadSurrogate = null\n\n // encode utf8\n if (codePoint < 0x80) {\n if ((units -= 1) < 0) break\n bytes.push(codePoint)\n } else if (codePoint < 0x800) {\n if ((units -= 2) < 0) break\n bytes.push(\n codePoint >> 0x6 | 0xC0,\n codePoint & 0x3F | 0x80\n )\n } else if (codePoint < 0x10000) {\n if ((units -= 3) < 0) break\n bytes.push(\n codePoint >> 0xC | 0xE0,\n codePoint >> 0x6 & 0x3F | 0x80,\n codePoint & 0x3F | 0x80\n )\n } else if (codePoint < 0x110000) {\n if ((units -= 4) < 0) break\n bytes.push(\n codePoint >> 0x12 | 0xF0,\n codePoint >> 0xC & 0x3F | 0x80,\n codePoint >> 0x6 & 0x3F | 0x80,\n codePoint & 0x3F | 0x80\n )\n } else {\n throw new Error('Invalid code point')\n }\n }\n\n return bytes\n}\n\nfunction asciiToBytes (str) {\n var byteArray = []\n for (var i = 0; i < str.length; ++i) {\n // Node's code seems to be doing this and not & 0x7F..\n byteArray.push(str.charCodeAt(i) & 0xFF)\n }\n return byteArray\n}\n\nfunction utf16leToBytes (str, units) {\n var c, hi, lo\n var byteArray = []\n for (var i = 0; i < str.length; ++i) {\n if ((units -= 2) < 0) break\n\n c = str.charCodeAt(i)\n hi = c >> 8\n lo = c % 256\n byteArray.push(lo)\n byteArray.push(hi)\n }\n\n return byteArray\n}\n\nfunction base64ToBytes (str) {\n return base64.toByteArray(base64clean(str))\n}\n\nfunction blitBuffer (src, dst, offset, length) {\n for (var i = 0; i < length; ++i) {\n if ((i + offset >= dst.length) || (i >= src.length)) break\n dst[i + offset] = src[i]\n }\n return i\n}\n\nfunction isnan (val) {\n return val !== val // eslint-disable-line no-self-compare\n}\n","/**\n * This is the web browser implementation of `debug()`.\n *\n * Expose `debug()` as the module.\n */\n\nexports = module.exports = require('./debug');\nexports.log = log;\nexports.formatArgs = formatArgs;\nexports.save = save;\nexports.load = load;\nexports.useColors = useColors;\nexports.storage = 'undefined' != typeof chrome\n && 'undefined' != typeof chrome.storage\n ? chrome.storage.local\n : localstorage();\n\n/**\n * Colors.\n */\n\nexports.colors = [\n 'lightseagreen',\n 'forestgreen',\n 'goldenrod',\n 'dodgerblue',\n 'darkorchid',\n 'crimson'\n];\n\n/**\n * Currently only WebKit-based Web Inspectors, Firefox >= v31,\n * and the Firebug extension (any Firefox version) are known\n * to support \"%c\" CSS customizations.\n *\n * TODO: add a `localStorage` variable to explicitly enable/disable colors\n */\n\nfunction useColors() {\n // NB: In an Electron preload script, document will be defined but not fully\n // initialized. Since we know we're in Chrome, we'll just detect this case\n // explicitly\n if (typeof window !== 'undefined' && window && typeof window.process !== 'undefined' && window.process.type === 'renderer') {\n return true;\n }\n\n // is webkit? http://stackoverflow.com/a/16459606/376773\n // document is undefined in react-native: https://github.com/facebook/react-native/pull/1632\n return (typeof document !== 'undefined' && document && 'WebkitAppearance' in document.documentElement.style) ||\n // is firebug? http://stackoverflow.com/a/398120/376773\n (typeof window !== 'undefined' && window && window.console && (console.firebug || (console.exception && console.table))) ||\n // is firefox >= v31?\n // https://developer.mozilla.org/en-US/docs/Tools/Web_Console#Styling_messages\n (typeof navigator !== 'undefined' && navigator && navigator.userAgent && navigator.userAgent.toLowerCase().match(/firefox\\/(\\d+)/) && parseInt(RegExp.$1, 10) >= 31) ||\n // double check webkit in userAgent just in case we are in a worker\n (typeof navigator !== 'undefined' && navigator && navigator.userAgent && navigator.userAgent.toLowerCase().match(/applewebkit\\/(\\d+)/));\n}\n\n/**\n * Map %j to `JSON.stringify()`, since no Web Inspectors do that by default.\n */\n\nexports.formatters.j = function(v) {\n try {\n return JSON.stringify(v);\n } catch (err) {\n return '[UnexpectedJSONParseError]: ' + err.message;\n }\n};\n\n\n/**\n * Colorize log arguments if enabled.\n *\n * @api public\n */\n\nfunction formatArgs(args) {\n var useColors = this.useColors;\n\n args[0] = (useColors ? '%c' : '')\n + this.namespace\n + (useColors ? ' %c' : ' ')\n + args[0]\n + (useColors ? '%c ' : ' ')\n + '+' + exports.humanize(this.diff);\n\n if (!useColors) return;\n\n var c = 'color: ' + this.color;\n args.splice(1, 0, c, 'color: inherit')\n\n // the final \"%c\" is somewhat tricky, because there could be other\n // arguments passed either before or after the %c, so we need to\n // figure out the correct index to insert the CSS into\n var index = 0;\n var lastC = 0;\n args[0].replace(/%[a-zA-Z%]/g, function(match) {\n if ('%%' === match) return;\n index++;\n if ('%c' === match) {\n // we only are interested in the *last* %c\n // (the user may have provided their own)\n lastC = index;\n }\n });\n\n args.splice(lastC, 0, c);\n}\n\n/**\n * Invokes `console.log()` when available.\n * No-op when `console.log` is not a \"function\".\n *\n * @api public\n */\n\nfunction log() {\n // this hackery is required for IE8/9, where\n // the `console.log` function doesn't have 'apply'\n return 'object' === typeof console\n && console.log\n && Function.prototype.apply.call(console.log, console, arguments);\n}\n\n/**\n * Save `namespaces`.\n *\n * @param {String} namespaces\n * @api private\n */\n\nfunction save(namespaces) {\n try {\n if (null == namespaces) {\n exports.storage.removeItem('debug');\n } else {\n exports.storage.debug = namespaces;\n }\n } catch(e) {}\n}\n\n/**\n * Load `namespaces`.\n *\n * @return {String} returns the previously persisted debug modes\n * @api private\n */\n\nfunction load() {\n try {\n return exports.storage.debug;\n } catch(e) {}\n\n // If debug isn't set in LS, and we're in Electron, try to load $DEBUG\n if (typeof process !== 'undefined' && 'env' in process) {\n return process.env.DEBUG;\n }\n}\n\n/**\n * Enable namespaces listed in `localStorage.debug` initially.\n */\n\nexports.enable(load());\n\n/**\n * Localstorage attempts to return the localstorage.\n *\n * This is necessary because safari throws\n * when a user disables cookies/localstorage\n * and you attempt to access it.\n *\n * @return {LocalStorage}\n * @api private\n */\n\nfunction localstorage() {\n try {\n return window.localStorage;\n } catch (e) {}\n}\n","\n/**\n * This is the common logic for both the Node.js and web browser\n * implementations of `debug()`.\n *\n * Expose `debug()` as the module.\n */\n\nexports = module.exports = createDebug.debug = createDebug.default = createDebug;\nexports.coerce = coerce;\nexports.disable = disable;\nexports.enable = enable;\nexports.enabled = enabled;\nexports.humanize = require('ms');\n\n/**\n * The currently active debug mode names, and names to skip.\n */\n\nexports.names = [];\nexports.skips = [];\n\n/**\n * Map of special \"%n\" handling functions, for the debug \"format\" argument.\n *\n * Valid key names are a single, lower or upper-case letter, i.e. \"n\" and \"N\".\n */\n\nexports.formatters = {};\n\n/**\n * Previous log timestamp.\n */\n\nvar prevTime;\n\n/**\n * Select a color.\n * @param {String} namespace\n * @return {Number}\n * @api private\n */\n\nfunction selectColor(namespace) {\n var hash = 0, i;\n\n for (i in namespace) {\n hash = ((hash << 5) - hash) + namespace.charCodeAt(i);\n hash |= 0; // Convert to 32bit integer\n }\n\n return exports.colors[Math.abs(hash) % exports.colors.length];\n}\n\n/**\n * Create a debugger with the given `namespace`.\n *\n * @param {String} namespace\n * @return {Function}\n * @api public\n */\n\nfunction createDebug(namespace) {\n\n function debug() {\n // disabled?\n if (!debug.enabled) return;\n\n var self = debug;\n\n // set `diff` timestamp\n var curr = +new Date();\n var ms = curr - (prevTime || curr);\n self.diff = ms;\n self.prev = prevTime;\n self.curr = curr;\n prevTime = curr;\n\n // turn the `arguments` into a proper Array\n var args = new Array(arguments.length);\n for (var i = 0; i < args.length; i++) {\n args[i] = arguments[i];\n }\n\n args[0] = exports.coerce(args[0]);\n\n if ('string' !== typeof args[0]) {\n // anything else let's inspect with %O\n args.unshift('%O');\n }\n\n // apply any `formatters` transformations\n var index = 0;\n args[0] = args[0].replace(/%([a-zA-Z%])/g, function(match, format) {\n // if we encounter an escaped % then don't increase the array index\n if (match === '%%') return match;\n index++;\n var formatter = exports.formatters[format];\n if ('function' === typeof formatter) {\n var val = args[index];\n match = formatter.call(self, val);\n\n // now we need to remove `args[index]` since it's inlined in the `format`\n args.splice(index, 1);\n index--;\n }\n return match;\n });\n\n // apply env-specific formatting (colors, etc.)\n exports.formatArgs.call(self, args);\n\n var logFn = debug.log || exports.log || console.log.bind(console);\n logFn.apply(self, args);\n }\n\n debug.namespace = namespace;\n debug.enabled = exports.enabled(namespace);\n debug.useColors = exports.useColors();\n debug.color = selectColor(namespace);\n\n // env-specific initialization logic for debug instances\n if ('function' === typeof exports.init) {\n exports.init(debug);\n }\n\n return debug;\n}\n\n/**\n * Enables a debug mode by namespaces. This can include modes\n * separated by a colon and wildcards.\n *\n * @param {String} namespaces\n * @api public\n */\n\nfunction enable(namespaces) {\n exports.save(namespaces);\n\n var split = (namespaces || '').split(/[\\s,]+/);\n var len = split.length;\n\n for (var i = 0; i < len; i++) {\n if (!split[i]) continue; // ignore empty strings\n namespaces = split[i].replace(/\\*/g, '.*?');\n if (namespaces[0] === '-') {\n exports.skips.push(new RegExp('^' + namespaces.substr(1) + '$'));\n } else {\n exports.names.push(new RegExp('^' + namespaces + '$'));\n }\n }\n}\n\n/**\n * Disable debug output.\n *\n * @api public\n */\n\nfunction disable() {\n exports.enable('');\n}\n\n/**\n * Returns true if the given mode name is enabled, false otherwise.\n *\n * @param {String} name\n * @return {Boolean}\n * @api public\n */\n\nfunction enabled(name) {\n var i, len;\n for (i = 0, len = exports.skips.length; i < len; i++) {\n if (exports.skips[i].test(name)) {\n return false;\n }\n }\n for (i = 0, len = exports.names.length; i < len; i++) {\n if (exports.names[i].test(name)) {\n return true;\n }\n }\n return false;\n}\n\n/**\n * Coerce `val`.\n *\n * @param {Mixed} val\n * @return {Mixed}\n * @api private\n */\n\nfunction coerce(val) {\n if (val instanceof Error) return val.stack || val.message;\n return val;\n}\n","exports.read = function (buffer, offset, isLE, mLen, nBytes) {\n var e, m\n var eLen = nBytes * 8 - mLen - 1\n var eMax = (1 << eLen) - 1\n var eBias = eMax >> 1\n var nBits = -7\n var i = isLE ? (nBytes - 1) : 0\n var d = isLE ? -1 : 1\n var s = buffer[offset + i]\n\n i += d\n\n e = s & ((1 << (-nBits)) - 1)\n s >>= (-nBits)\n nBits += eLen\n for (; nBits > 0; e = e * 256 + buffer[offset + i], i += d, nBits -= 8) {}\n\n m = e & ((1 << (-nBits)) - 1)\n e >>= (-nBits)\n nBits += mLen\n for (; nBits > 0; m = m * 256 + buffer[offset + i], i += d, nBits -= 8) {}\n\n if (e === 0) {\n e = 1 - eBias\n } else if (e === eMax) {\n return m ? NaN : ((s ? -1 : 1) * Infinity)\n } else {\n m = m + Math.pow(2, mLen)\n e = e - eBias\n }\n return (s ? -1 : 1) * m * Math.pow(2, e - mLen)\n}\n\nexports.write = function (buffer, value, offset, isLE, mLen, nBytes) {\n var e, m, c\n var eLen = nBytes * 8 - mLen - 1\n var eMax = (1 << eLen) - 1\n var eBias = eMax >> 1\n var rt = (mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0)\n var i = isLE ? 0 : (nBytes - 1)\n var d = isLE ? 1 : -1\n var s = value < 0 || (value === 0 && 1 / value < 0) ? 1 : 0\n\n value = Math.abs(value)\n\n if (isNaN(value) || value === Infinity) {\n m = isNaN(value) ? 1 : 0\n e = eMax\n } else {\n e = Math.floor(Math.log(value) / Math.LN2)\n if (value * (c = Math.pow(2, -e)) < 1) {\n e--\n c *= 2\n }\n if (e + eBias >= 1) {\n value += rt / c\n } else {\n value += rt * Math.pow(2, 1 - eBias)\n }\n if (value * c >= 2) {\n e++\n c /= 2\n }\n\n if (e + eBias >= eMax) {\n m = 0\n e = eMax\n } else if (e + eBias >= 1) {\n m = (value * c - 1) * Math.pow(2, mLen)\n e = e + eBias\n } else {\n m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen)\n e = 0\n }\n }\n\n for (; mLen >= 8; buffer[offset + i] = m & 0xff, i += d, m /= 256, mLen -= 8) {}\n\n e = (e << mLen) | m\n eLen += mLen\n for (; eLen > 0; buffer[offset + i] = e & 0xff, i += d, e /= 256, eLen -= 8) {}\n\n buffer[offset + i - d] |= s * 128\n}\n","var toString = {}.toString;\n\nmodule.exports = Array.isArray || function (arr) {\n return toString.call(arr) == '[object Array]';\n};\n","/*\n * $Id: base64.js,v 2.15 2014/04/05 12:58:57 dankogai Exp dankogai $\n *\n * Licensed under the MIT license.\n * http://opensource.org/licenses/mit-license\n *\n * References:\n * http://en.wikipedia.org/wiki/Base64\n */\n\n(function(global) {\n 'use strict';\n // existing version for noConflict()\n var _Base64 = global.Base64;\n var version = \"2.1.9\";\n // if node.js, we use Buffer\n var buffer;\n if (typeof module !== 'undefined' && module.exports) {\n try {\n buffer = require('buffer').Buffer;\n } catch (err) {}\n }\n // constants\n var b64chars\n = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';\n var b64tab = function(bin) {\n var t = {};\n for (var i = 0, l = bin.length; i < l; i++) t[bin.charAt(i)] = i;\n return t;\n }(b64chars);\n var fromCharCode = String.fromCharCode;\n // encoder stuff\n var cb_utob = function(c) {\n if (c.length < 2) {\n var cc = c.charCodeAt(0);\n return cc < 0x80 ? c\n : cc < 0x800 ? (fromCharCode(0xc0 | (cc >>> 6))\n + fromCharCode(0x80 | (cc & 0x3f)))\n : (fromCharCode(0xe0 | ((cc >>> 12) & 0x0f))\n + fromCharCode(0x80 | ((cc >>> 6) & 0x3f))\n + fromCharCode(0x80 | ( cc & 0x3f)));\n } else {\n var cc = 0x10000\n + (c.charCodeAt(0) - 0xD800) * 0x400\n + (c.charCodeAt(1) - 0xDC00);\n return (fromCharCode(0xf0 | ((cc >>> 18) & 0x07))\n + fromCharCode(0x80 | ((cc >>> 12) & 0x3f))\n + fromCharCode(0x80 | ((cc >>> 6) & 0x3f))\n + fromCharCode(0x80 | ( cc & 0x3f)));\n }\n };\n var re_utob = /[\\uD800-\\uDBFF][\\uDC00-\\uDFFFF]|[^\\x00-\\x7F]/g;\n var utob = function(u) {\n return u.replace(re_utob, cb_utob);\n };\n var cb_encode = function(ccc) {\n var padlen = [0, 2, 1][ccc.length % 3],\n ord = ccc.charCodeAt(0) << 16\n | ((ccc.length > 1 ? ccc.charCodeAt(1) : 0) << 8)\n | ((ccc.length > 2 ? ccc.charCodeAt(2) : 0)),\n chars = [\n b64chars.charAt( ord >>> 18),\n b64chars.charAt((ord >>> 12) & 63),\n padlen >= 2 ? '=' : b64chars.charAt((ord >>> 6) & 63),\n padlen >= 1 ? '=' : b64chars.charAt(ord & 63)\n ];\n return chars.join('');\n };\n var btoa = global.btoa ? function(b) {\n return global.btoa(b);\n } : function(b) {\n return b.replace(/[\\s\\S]{1,3}/g, cb_encode);\n };\n var _encode = buffer ? function (u) {\n return (u.constructor === buffer.constructor ? u : new buffer(u))\n .toString('base64')\n }\n : function (u) { return btoa(utob(u)) }\n ;\n var encode = function(u, urisafe) {\n return !urisafe\n ? _encode(String(u))\n : _encode(String(u)).replace(/[+\\/]/g, function(m0) {\n return m0 == '+' ? '-' : '_';\n }).replace(/=/g, '');\n };\n var encodeURI = function(u) { return encode(u, true) };\n // decoder stuff\n var re_btou = new RegExp([\n '[\\xC0-\\xDF][\\x80-\\xBF]',\n '[\\xE0-\\xEF][\\x80-\\xBF]{2}',\n '[\\xF0-\\xF7][\\x80-\\xBF]{3}'\n ].join('|'), 'g');\n var cb_btou = function(cccc) {\n switch(cccc.length) {\n case 4:\n var cp = ((0x07 & cccc.charCodeAt(0)) << 18)\n | ((0x3f & cccc.charCodeAt(1)) << 12)\n | ((0x3f & cccc.charCodeAt(2)) << 6)\n | (0x3f & cccc.charCodeAt(3)),\n offset = cp - 0x10000;\n return (fromCharCode((offset >>> 10) + 0xD800)\n + fromCharCode((offset & 0x3FF) + 0xDC00));\n case 3:\n return fromCharCode(\n ((0x0f & cccc.charCodeAt(0)) << 12)\n | ((0x3f & cccc.charCodeAt(1)) << 6)\n | (0x3f & cccc.charCodeAt(2))\n );\n default:\n return fromCharCode(\n ((0x1f & cccc.charCodeAt(0)) << 6)\n | (0x3f & cccc.charCodeAt(1))\n );\n }\n };\n var btou = function(b) {\n return b.replace(re_btou, cb_btou);\n };\n var cb_decode = function(cccc) {\n var len = cccc.length,\n padlen = len % 4,\n n = (len > 0 ? b64tab[cccc.charAt(0)] << 18 : 0)\n | (len > 1 ? b64tab[cccc.charAt(1)] << 12 : 0)\n | (len > 2 ? b64tab[cccc.charAt(2)] << 6 : 0)\n | (len > 3 ? b64tab[cccc.charAt(3)] : 0),\n chars = [\n fromCharCode( n >>> 16),\n fromCharCode((n >>> 8) & 0xff),\n fromCharCode( n & 0xff)\n ];\n chars.length -= [0, 0, 2, 1][padlen];\n return chars.join('');\n };\n var atob = global.atob ? function(a) {\n return global.atob(a);\n } : function(a){\n return a.replace(/[\\s\\S]{1,4}/g, cb_decode);\n };\n var _decode = buffer ? function(a) {\n return (a.constructor === buffer.constructor\n ? a : new buffer(a, 'base64')).toString();\n }\n : function(a) { return btou(atob(a)) };\n var decode = function(a){\n return _decode(\n String(a).replace(/[-_]/g, function(m0) { return m0 == '-' ? '+' : '/' })\n .replace(/[^A-Za-z0-9\\+\\/]/g, '')\n );\n };\n var noConflict = function() {\n var Base64 = global.Base64;\n global.Base64 = _Base64;\n return Base64;\n };\n // export Base64\n global.Base64 = {\n VERSION: version,\n atob: atob,\n btoa: btoa,\n fromBase64: decode,\n toBase64: encode,\n utob: utob,\n encode: encode,\n encodeURI: encodeURI,\n btou: btou,\n decode: decode,\n noConflict: noConflict\n };\n // if ES5 is available, make Base64.extendString() available\n if (typeof Object.defineProperty === 'function') {\n var noEnum = function(v){\n return {value:v,enumerable:false,writable:true,configurable:true};\n };\n global.Base64.extendString = function () {\n Object.defineProperty(\n String.prototype, 'fromBase64', noEnum(function () {\n return decode(this)\n }));\n Object.defineProperty(\n String.prototype, 'toBase64', noEnum(function (urisafe) {\n return encode(this, urisafe)\n }));\n Object.defineProperty(\n String.prototype, 'toBase64URI', noEnum(function () {\n return encode(this, true)\n }));\n };\n }\n // that's it!\n if (global['Meteor']) {\n Base64 = global.Base64; // for normal export in Meteor.js\n }\n})(this);\n","/**\n * Helpers.\n */\n\nvar s = 1000\nvar m = s * 60\nvar h = m * 60\nvar d = h * 24\nvar y = d * 365.25\n\n/**\n * Parse or format the given `val`.\n *\n * Options:\n *\n * - `long` verbose formatting [false]\n *\n * @param {String|Number} val\n * @param {Object} options\n * @throws {Error} throw an error if val is not a non-empty string or a number\n * @return {String|Number}\n * @api public\n */\n\nmodule.exports = function (val, options) {\n options = options || {}\n var type = typeof val\n if (type === 'string' && val.length > 0) {\n return parse(val)\n } else if (type === 'number' && isNaN(val) === false) {\n return options.long ?\n\t\t\tfmtLong(val) :\n\t\t\tfmtShort(val)\n }\n throw new Error('val is not a non-empty string or a valid number. val=' + JSON.stringify(val))\n}\n\n/**\n * Parse the given `str` and return milliseconds.\n *\n * @param {String} str\n * @return {Number}\n * @api private\n */\n\nfunction parse(str) {\n str = String(str)\n if (str.length > 10000) {\n return\n }\n var match = /^((?:\\d+)?\\.?\\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|years?|yrs?|y)?$/i.exec(str)\n if (!match) {\n return\n }\n var n = parseFloat(match[1])\n var type = (match[2] || 'ms').toLowerCase()\n switch (type) {\n case 'years':\n case 'year':\n case 'yrs':\n case 'yr':\n case 'y':\n return n * y\n case 'days':\n case 'day':\n case 'd':\n return n * d\n case 'hours':\n case 'hour':\n case 'hrs':\n case 'hr':\n case 'h':\n return n * h\n case 'minutes':\n case 'minute':\n case 'mins':\n case 'min':\n case 'm':\n return n * m\n case 'seconds':\n case 'second':\n case 'secs':\n case 'sec':\n case 's':\n return n * s\n case 'milliseconds':\n case 'millisecond':\n case 'msecs':\n case 'msec':\n case 'ms':\n return n\n default:\n return undefined\n }\n}\n\n/**\n * Short format for `ms`.\n *\n * @param {Number} ms\n * @return {String}\n * @api private\n */\n\nfunction fmtShort(ms) {\n if (ms >= d) {\n return Math.round(ms / d) + 'd'\n }\n if (ms >= h) {\n return Math.round(ms / h) + 'h'\n }\n if (ms >= m) {\n return Math.round(ms / m) + 'm'\n }\n if (ms >= s) {\n return Math.round(ms / s) + 's'\n }\n return ms + 'ms'\n}\n\n/**\n * Long format for `ms`.\n *\n * @param {Number} ms\n * @return {String}\n * @api private\n */\n\nfunction fmtLong(ms) {\n return plural(ms, d, 'day') ||\n plural(ms, h, 'hour') ||\n plural(ms, m, 'minute') ||\n plural(ms, s, 'second') ||\n ms + ' ms'\n}\n\n/**\n * Pluralization helper.\n */\n\nfunction plural(ms, n, name) {\n if (ms < n) {\n return\n }\n if (ms < n * 1.5) {\n return Math.floor(ms / n) + ' ' + name\n }\n return Math.ceil(ms / n) + ' ' + name + 's'\n}\n","// shim for using process in browser\nvar process = module.exports = {};\n\n// cached from whatever global is present so that test runners that stub it\n// don't break things. But we need to wrap it in a try catch in case it is\n// wrapped in strict mode code which doesn't define any globals. It's inside a\n// function because try/catches deoptimize in certain engines.\n\nvar cachedSetTimeout;\nvar cachedClearTimeout;\n\nfunction defaultSetTimout() {\n throw new Error('setTimeout has not been defined');\n}\nfunction defaultClearTimeout () {\n throw new Error('clearTimeout has not been defined');\n}\n(function () {\n try {\n if (typeof setTimeout === 'function') {\n cachedSetTimeout = setTimeout;\n } else {\n cachedSetTimeout = defaultSetTimout;\n }\n } catch (e) {\n cachedSetTimeout = defaultSetTimout;\n }\n try {\n if (typeof clearTimeout === 'function') {\n cachedClearTimeout = clearTimeout;\n } else {\n cachedClearTimeout = defaultClearTimeout;\n }\n } catch (e) {\n cachedClearTimeout = defaultClearTimeout;\n }\n} ())\nfunction runTimeout(fun) {\n if (cachedSetTimeout === setTimeout) {\n //normal enviroments in sane situations\n return setTimeout(fun, 0);\n }\n // if setTimeout wasn't available but was latter defined\n if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {\n cachedSetTimeout = setTimeout;\n return setTimeout(fun, 0);\n }\n try {\n // when when somebody has screwed with setTimeout but no I.E. maddness\n return cachedSetTimeout(fun, 0);\n } catch(e){\n try {\n // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally\n return cachedSetTimeout.call(null, fun, 0);\n } catch(e){\n // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error\n return cachedSetTimeout.call(this, fun, 0);\n }\n }\n\n\n}\nfunction runClearTimeout(marker) {\n if (cachedClearTimeout === clearTimeout) {\n //normal enviroments in sane situations\n return clearTimeout(marker);\n }\n // if clearTimeout wasn't available but was latter defined\n if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {\n cachedClearTimeout = clearTimeout;\n return clearTimeout(marker);\n }\n try {\n // when when somebody has screwed with setTimeout but no I.E. maddness\n return cachedClearTimeout(marker);\n } catch (e){\n try {\n // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally\n return cachedClearTimeout.call(null, marker);\n } catch (e){\n // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error.\n // Some versions of I.E. have different rules for clearTimeout vs setTimeout\n return cachedClearTimeout.call(this, marker);\n }\n }\n\n\n\n}\nvar queue = [];\nvar draining = false;\nvar currentQueue;\nvar queueIndex = -1;\n\nfunction cleanUpNextTick() {\n if (!draining || !currentQueue) {\n return;\n }\n draining = false;\n if (currentQueue.length) {\n queue = currentQueue.concat(queue);\n } else {\n queueIndex = -1;\n }\n if (queue.length) {\n drainQueue();\n }\n}\n\nfunction drainQueue() {\n if (draining) {\n return;\n }\n var timeout = runTimeout(cleanUpNextTick);\n draining = true;\n\n var len = queue.length;\n while(len) {\n currentQueue = queue;\n queue = [];\n while (++queueIndex < len) {\n if (currentQueue) {\n currentQueue[queueIndex].run();\n }\n }\n queueIndex = -1;\n len = queue.length;\n }\n currentQueue = null;\n draining = false;\n runClearTimeout(timeout);\n}\n\nprocess.nextTick = function (fun) {\n var args = new Array(arguments.length - 1);\n if (arguments.length > 1) {\n for (var i = 1; i < arguments.length; i++) {\n args[i - 1] = arguments[i];\n }\n }\n queue.push(new Item(fun, args));\n if (queue.length === 1 && !draining) {\n runTimeout(drainQueue);\n }\n};\n\n// v8 likes predictible objects\nfunction Item(fun, array) {\n this.fun = fun;\n this.array = array;\n}\nItem.prototype.run = function () {\n this.fun.apply(null, this.array);\n};\nprocess.title = 'browser';\nprocess.browser = true;\nprocess.env = {};\nprocess.argv = [];\nprocess.version = ''; // empty string to avoid regexp issues\nprocess.versions = {};\n\nfunction noop() {}\n\nprocess.on = noop;\nprocess.addListener = noop;\nprocess.once = noop;\nprocess.off = noop;\nprocess.removeListener = noop;\nprocess.removeAllListeners = noop;\nprocess.emit = noop;\n\nprocess.binding = function (name) {\n throw new Error('process.binding is not supported');\n};\n\nprocess.cwd = function () { return '/' };\nprocess.chdir = function (dir) {\n throw new Error('process.chdir is not supported');\n};\nprocess.umask = function() { return 0; };\n","/*! https://mths.be/utf8js v2.1.2 by @mathias */\n;(function(root) {\n\n\t// Detect free variables `exports`\n\tvar freeExports = typeof exports == 'object' && exports;\n\n\t// Detect free variable `module`\n\tvar freeModule = typeof module == 'object' && module &&\n\t\tmodule.exports == freeExports && module;\n\n\t// Detect free variable `global`, from Node.js or Browserified code,\n\t// and use it as `root`\n\tvar freeGlobal = typeof global == 'object' && global;\n\tif (freeGlobal.global === freeGlobal || freeGlobal.window === freeGlobal) {\n\t\troot = freeGlobal;\n\t}\n\n\t/*--------------------------------------------------------------------------*/\n\n\tvar stringFromCharCode = String.fromCharCode;\n\n\t// Taken from https://mths.be/punycode\n\tfunction ucs2decode(string) {\n\t\tvar output = [];\n\t\tvar counter = 0;\n\t\tvar length = string.length;\n\t\tvar value;\n\t\tvar extra;\n\t\twhile (counter < length) {\n\t\t\tvalue = string.charCodeAt(counter++);\n\t\t\tif (value >= 0xD800 && value <= 0xDBFF && counter < length) {\n\t\t\t\t// high surrogate, and there is a next character\n\t\t\t\textra = string.charCodeAt(counter++);\n\t\t\t\tif ((extra & 0xFC00) == 0xDC00) { // low surrogate\n\t\t\t\t\toutput.push(((value & 0x3FF) << 10) + (extra & 0x3FF) + 0x10000);\n\t\t\t\t} else {\n\t\t\t\t\t// unmatched surrogate; only append this code unit, in case the next\n\t\t\t\t\t// code unit is the high surrogate of a surrogate pair\n\t\t\t\t\toutput.push(value);\n\t\t\t\t\tcounter--;\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\toutput.push(value);\n\t\t\t}\n\t\t}\n\t\treturn output;\n\t}\n\n\t// Taken from https://mths.be/punycode\n\tfunction ucs2encode(array) {\n\t\tvar length = array.length;\n\t\tvar index = -1;\n\t\tvar value;\n\t\tvar output = '';\n\t\twhile (++index < length) {\n\t\t\tvalue = array[index];\n\t\t\tif (value > 0xFFFF) {\n\t\t\t\tvalue -= 0x10000;\n\t\t\t\toutput += stringFromCharCode(value >>> 10 & 0x3FF | 0xD800);\n\t\t\t\tvalue = 0xDC00 | value & 0x3FF;\n\t\t\t}\n\t\t\toutput += stringFromCharCode(value);\n\t\t}\n\t\treturn output;\n\t}\n\n\tfunction checkScalarValue(codePoint) {\n\t\tif (codePoint >= 0xD800 && codePoint <= 0xDFFF) {\n\t\t\tthrow Error(\n\t\t\t\t'Lone surrogate U+' + codePoint.toString(16).toUpperCase() +\n\t\t\t\t' is not a scalar value'\n\t\t\t);\n\t\t}\n\t}\n\t/*--------------------------------------------------------------------------*/\n\n\tfunction createByte(codePoint, shift) {\n\t\treturn stringFromCharCode(((codePoint >> shift) & 0x3F) | 0x80);\n\t}\n\n\tfunction encodeCodePoint(codePoint) {\n\t\tif ((codePoint & 0xFFFFFF80) == 0) { // 1-byte sequence\n\t\t\treturn stringFromCharCode(codePoint);\n\t\t}\n\t\tvar symbol = '';\n\t\tif ((codePoint & 0xFFFFF800) == 0) { // 2-byte sequence\n\t\t\tsymbol = stringFromCharCode(((codePoint >> 6) & 0x1F) | 0xC0);\n\t\t}\n\t\telse if ((codePoint & 0xFFFF0000) == 0) { // 3-byte sequence\n\t\t\tcheckScalarValue(codePoint);\n\t\t\tsymbol = stringFromCharCode(((codePoint >> 12) & 0x0F) | 0xE0);\n\t\t\tsymbol += createByte(codePoint, 6);\n\t\t}\n\t\telse if ((codePoint & 0xFFE00000) == 0) { // 4-byte sequence\n\t\t\tsymbol = stringFromCharCode(((codePoint >> 18) & 0x07) | 0xF0);\n\t\t\tsymbol += createByte(codePoint, 12);\n\t\t\tsymbol += createByte(codePoint, 6);\n\t\t}\n\t\tsymbol += stringFromCharCode((codePoint & 0x3F) | 0x80);\n\t\treturn symbol;\n\t}\n\n\tfunction utf8encode(string) {\n\t\tvar codePoints = ucs2decode(string);\n\t\tvar length = codePoints.length;\n\t\tvar index = -1;\n\t\tvar codePoint;\n\t\tvar byteString = '';\n\t\twhile (++index < length) {\n\t\t\tcodePoint = codePoints[index];\n\t\t\tbyteString += encodeCodePoint(codePoint);\n\t\t}\n\t\treturn byteString;\n\t}\n\n\t/*--------------------------------------------------------------------------*/\n\n\tfunction readContinuationByte() {\n\t\tif (byteIndex >= byteCount) {\n\t\t\tthrow Error('Invalid byte index');\n\t\t}\n\n\t\tvar continuationByte = byteArray[byteIndex] & 0xFF;\n\t\tbyteIndex++;\n\n\t\tif ((continuationByte & 0xC0) == 0x80) {\n\t\t\treturn continuationByte & 0x3F;\n\t\t}\n\n\t\t// If we end up here, it’s not a continuation byte\n\t\tthrow Error('Invalid continuation byte');\n\t}\n\n\tfunction decodeSymbol() {\n\t\tvar byte1;\n\t\tvar byte2;\n\t\tvar byte3;\n\t\tvar byte4;\n\t\tvar codePoint;\n\n\t\tif (byteIndex > byteCount) {\n\t\t\tthrow Error('Invalid byte index');\n\t\t}\n\n\t\tif (byteIndex == byteCount) {\n\t\t\treturn false;\n\t\t}\n\n\t\t// Read first byte\n\t\tbyte1 = byteArray[byteIndex] & 0xFF;\n\t\tbyteIndex++;\n\n\t\t// 1-byte sequence (no continuation bytes)\n\t\tif ((byte1 & 0x80) == 0) {\n\t\t\treturn byte1;\n\t\t}\n\n\t\t// 2-byte sequence\n\t\tif ((byte1 & 0xE0) == 0xC0) {\n\t\t\tbyte2 = readContinuationByte();\n\t\t\tcodePoint = ((byte1 & 0x1F) << 6) | byte2;\n\t\t\tif (codePoint >= 0x80) {\n\t\t\t\treturn codePoint;\n\t\t\t} else {\n\t\t\t\tthrow Error('Invalid continuation byte');\n\t\t\t}\n\t\t}\n\n\t\t// 3-byte sequence (may include unpaired surrogates)\n\t\tif ((byte1 & 0xF0) == 0xE0) {\n\t\t\tbyte2 = readContinuationByte();\n\t\t\tbyte3 = readContinuationByte();\n\t\t\tcodePoint = ((byte1 & 0x0F) << 12) | (byte2 << 6) | byte3;\n\t\t\tif (codePoint >= 0x0800) {\n\t\t\t\tcheckScalarValue(codePoint);\n\t\t\t\treturn codePoint;\n\t\t\t} else {\n\t\t\t\tthrow Error('Invalid continuation byte');\n\t\t\t}\n\t\t}\n\n\t\t// 4-byte sequence\n\t\tif ((byte1 & 0xF8) == 0xF0) {\n\t\t\tbyte2 = readContinuationByte();\n\t\t\tbyte3 = readContinuationByte();\n\t\t\tbyte4 = readContinuationByte();\n\t\t\tcodePoint = ((byte1 & 0x07) << 0x12) | (byte2 << 0x0C) |\n\t\t\t\t(byte3 << 0x06) | byte4;\n\t\t\tif (codePoint >= 0x010000 && codePoint <= 0x10FFFF) {\n\t\t\t\treturn codePoint;\n\t\t\t}\n\t\t}\n\n\t\tthrow Error('Invalid UTF-8 detected');\n\t}\n\n\tvar byteArray;\n\tvar byteCount;\n\tvar byteIndex;\n\tfunction utf8decode(byteString) {\n\t\tbyteArray = ucs2decode(byteString);\n\t\tbyteCount = byteArray.length;\n\t\tbyteIndex = 0;\n\t\tvar codePoints = [];\n\t\tvar tmp;\n\t\twhile ((tmp = decodeSymbol()) !== false) {\n\t\t\tcodePoints.push(tmp);\n\t\t}\n\t\treturn ucs2encode(codePoints);\n\t}\n\n\t/*--------------------------------------------------------------------------*/\n\n\tvar utf8 = {\n\t\t'version': '2.1.2',\n\t\t'encode': utf8encode,\n\t\t'decode': utf8decode\n\t};\n\n\t// Some AMD build optimizers, like r.js, check for specific condition patterns\n\t// like the following:\n\tif (\n\t\ttypeof define == 'function' &&\n\t\ttypeof define.amd == 'object' &&\n\t\tdefine.amd\n\t) {\n\t\tdefine(function() {\n\t\t\treturn utf8;\n\t\t});\n\t}\telse if (freeExports && !freeExports.nodeType) {\n\t\tif (freeModule) { // in Node.js or RingoJS v0.8.0+\n\t\t\tfreeModule.exports = utf8;\n\t\t} else { // in Narwhal or RingoJS v0.7.0-\n\t\t\tvar object = {};\n\t\t\tvar hasOwnProperty = object.hasOwnProperty;\n\t\t\tfor (var key in utf8) {\n\t\t\t\thasOwnProperty.call(utf8, key) && (freeExports[key] = utf8[key]);\n\t\t\t}\n\t\t}\n\t} else { // in Rhino or a web browser\n\t\troot.utf8 = utf8;\n\t}\n\n}(this));\n"],"preExistingComment":"//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["node_modules/browser-pack/_prelude.js","lib/Gist.js","lib/GitHub.js","lib/Issue.js","lib/Markdown.js","lib/Organization.js","lib/Project.js","lib/RateLimit.js","lib/Repository.js","lib/Requestable.js","lib/Search.js","lib/Team.js","lib/User.js","node_modules/axios/index.js","node_modules/axios/lib/adapters/xhr.js","node_modules/axios/lib/axios.js","node_modules/axios/lib/cancel/Cancel.js","node_modules/axios/lib/cancel/CancelToken.js","node_modules/axios/lib/cancel/isCancel.js","node_modules/axios/lib/core/Axios.js","node_modules/axios/lib/core/InterceptorManager.js","node_modules/axios/lib/core/createError.js","node_modules/axios/lib/core/dispatchRequest.js","node_modules/axios/lib/core/enhanceError.js","node_modules/axios/lib/core/settle.js","node_modules/axios/lib/core/transformData.js","node_modules/axios/lib/defaults.js","node_modules/axios/lib/helpers/bind.js","node_modules/axios/lib/helpers/btoa.js","node_modules/axios/lib/helpers/buildURL.js","node_modules/axios/lib/helpers/combineURLs.js","node_modules/axios/lib/helpers/cookies.js","node_modules/axios/lib/helpers/isAbsoluteURL.js","node_modules/axios/lib/helpers/isURLSameOrigin.js","node_modules/axios/lib/helpers/normalizeHeaderName.js","node_modules/axios/lib/helpers/parseHeaders.js","node_modules/axios/lib/helpers/spread.js","node_modules/axios/lib/utils.js","node_modules/base64-js/index.js","node_modules/buffer/index.js","node_modules/debug/src/browser.js","node_modules/debug/src/debug.js","node_modules/ieee754/index.js","node_modules/isarray/index.js","node_modules/js-base64/base64.js","node_modules/ms/index.js","node_modules/process/browser.js","node_modules/utf8/utf8.js"],"names":[],"mappings":"AAAA;;;;;ACOA;;;;;;;;;;+eAPA;;;;;;;AASA;;;IAGM,I;;;AACH;;;;;;AAMA,gBAAY,EAAZ,EAAgB,IAAhB,EAAsB,OAAtB,EAA+B;AAAA;;AAAA,4GACtB,IADsB,EAChB,OADgB;;AAE5B,UAAK,IAAL,GAAY,EAAZ;AAF4B;AAG9B;;AAED;;;;;;;;;;yBAMK,E,EAAI;AACN,aAAO,KAAK,QAAL,CAAc,KAAd,cAA+B,KAAK,IAApC,EAA4C,IAA5C,EAAkD,EAAlD,CAAP;AACF;;AAED;;;;;;;;;;2BAOO,I,EAAM,E,EAAI;AAAA;;AACd,aAAO,KAAK,QAAL,CAAc,MAAd,EAAsB,QAAtB,EAAgC,IAAhC,EAAsC,EAAtC,EACH,IADG,CACE,UAAC,QAAD,EAAc;AACjB,eAAK,IAAL,GAAY,SAAS,IAAT,CAAc,EAA1B;AACA,eAAO,QAAP;AACF,OAJG,CAAP;AAKF;;AAED;;;;;;;;;4BAMO,E,EAAI;AACR,aAAO,KAAK,QAAL,CAAc,QAAd,cAAkC,KAAK,IAAvC,EAA+C,IAA/C,EAAqD,EAArD,CAAP;AACF;;AAED;;;;;;;;;yBAMK,E,EAAI;AACN,aAAO,KAAK,QAAL,CAAc,MAAd,cAAgC,KAAK,IAArC,aAAmD,IAAnD,EAAyD,EAAzD,CAAP;AACF;;AAED;;;;;;;;;;2BAOO,I,EAAM,E,EAAI;AACd,aAAO,KAAK,QAAL,CAAc,OAAd,cAAiC,KAAK,IAAtC,EAA8C,IAA9C,EAAoD,EAApD,CAAP;AACF;;AAED;;;;;;;;;yBAMK,E,EAAI;AACN,aAAO,KAAK,QAAL,CAAc,KAAd,cAA+B,KAAK,IAApC,YAAiD,IAAjD,EAAuD,EAAvD,CAAP;AACF;;AAED;;;;;;;;;2BAMO,E,EAAI;AACR,aAAO,KAAK,QAAL,CAAc,QAAd,cAAkC,KAAK,IAAvC,YAAoD,IAApD,EAA0D,EAA1D,CAAP;AACF;;AAED;;;;;;;;;8BAMU,E,EAAI;AACX,aAAO,KAAK,gBAAL,aAAgC,KAAK,IAArC,YAAkD,IAAlD,EAAwD,EAAxD,CAAP;AACF;;AAED;;;;;;;;;gCAMY,E,EAAI;AACb,aAAO,KAAK,gBAAL,aAAgC,KAAK,IAArC,eAAqD,IAArD,EAA2D,EAA3D,CAAP;AACF;;AAED;;;;;;;;;;gCAOY,Q,EAAU,E,EAAI;AACvB,aAAO,KAAK,QAAL,CAAc,KAAd,cAA+B,KAAK,IAApC,SAA4C,QAA5C,EAAwD,IAAxD,EAA8D,EAA9D,CAAP;AACF;;AAED;;;;;;;;;iCAMa,E,EAAI;AACd,aAAO,KAAK,gBAAL,aAAgC,KAAK,IAArC,gBAAsD,IAAtD,EAA4D,EAA5D,CAAP;AACF;;AAED;;;;;;;;;;+BAOW,O,EAAS,E,EAAI;AACrB,aAAO,KAAK,QAAL,CAAc,KAAd,cAA+B,KAAK,IAApC,kBAAqD,OAArD,EAAgE,IAAhE,EAAsE,EAAtE,CAAP;AACF;;AAED;;;;;;;;;;kCAOc,O,EAAS,E,EAAI;AACxB,aAAO,KAAK,QAAL,CAAc,MAAd,cAAgC,KAAK,IAArC,gBAAsD,EAAC,MAAM,OAAP,EAAtD,EAAuE,EAAvE,CAAP;AACF;;AAED;;;;;;;;;;;gCAQY,O,EAAS,I,EAAM,E,EAAI;AAC5B,aAAO,KAAK,QAAL,CAAc,OAAd,cAAiC,KAAK,IAAtC,kBAAuD,OAAvD,EAAkE,EAAC,MAAM,IAAP,EAAlE,EAAgF,EAAhF,CAAP;AACF;;AAED;;;;;;;;;;kCAOc,O,EAAS,E,EAAI;AACxB,aAAO,KAAK,QAAL,CAAc,QAAd,cAAkC,KAAK,IAAvC,kBAAwD,OAAxD,EAAmE,IAAnE,EAAyE,EAAzE,CAAP;AACF;;;;;;AAGJ,OAAO,OAAP,GAAiB,IAAjB;;;;;qjBC3LA;;;;;;AAMA;;AAEA;;;;AACA;;;;AACA;;;;AACA;;;;AACA;;;;AACA;;;;AACA;;;;AACA;;;;AACA;;;;AACA;;;;;;;;AAEA;;;IAGM,M;AACH;;;;;;AAMA,kBAAY,IAAZ,EAAsD;AAAA,QAApC,OAAoC,uEAA1B,wBAA0B;;AAAA;;AACnD,SAAK,SAAL,GAAiB,OAAjB;AACA,SAAK,MAAL,GAAc,QAAQ,EAAtB;AACF;;AAED;;;;;;;;;4BAKQ,E,EAAI;AACT,aAAO,mBAAS,EAAT,EAAa,KAAK,MAAlB,EAA0B,KAAK,SAA/B,CAAP;AACF;;AAED;;;;;;;;;4BAMQ,I,EAAM;AACX,aAAO,mBAAS,IAAT,EAAe,KAAK,MAApB,EAA4B,KAAK,SAAjC,CAAP;AACF;;AAED;;;;;;;;oCAKgB,Y,EAAc;AAC3B,aAAO,2BAAiB,YAAjB,EAA+B,KAAK,MAApC,EAA4C,KAAK,SAAjD,CAAP;AACF;;AAED;;;;;;;;4BAKQ,M,EAAQ;AACb,aAAO,mBAAS,MAAT,EAAiB,KAAK,MAAtB,EAA8B,KAAK,SAAnC,CAAP;AACF;;AAED;;;;;;;;;4BAMQ,I,EAAM,I,EAAM;AACjB,aAAO,yBAAe,KAAK,YAAL,CAAkB,IAAlB,EAAwB,IAAxB,CAAf,EAA8C,KAAK,MAAnD,EAA2D,KAAK,SAAhE,CAAP;AACF;;AAED;;;;;;;;;8BAMU,I,EAAM,I,EAAM;AACnB,aAAO,oBAAU,KAAK,YAAL,CAAkB,IAAlB,EAAwB,IAAxB,CAAV,EAAyC,KAAK,MAA9C,EAAsD,KAAK,SAA3D,CAAP;AACF;;AAED;;;;;;;;2BAKO,K,EAAO;AACX,aAAO,qBAAW,KAAX,EAAkB,KAAK,MAAvB,EAA+B,KAAK,SAApC,CAAP;AACF;;AAED;;;;;;;mCAIe;AACZ,aAAO,wBAAc,KAAK,MAAnB,EAA2B,KAAK,SAAhC,CAAP;AACF;;AAED;;;;;;;kCAIc;AACX,aAAO,uBAAa,KAAK,MAAlB,EAA0B,KAAK,SAA/B,CAAP;AACF;;AAED;;;;;;;;+BAKW,E,EAAI;AACZ,aAAO,sBAAY,EAAZ,EAAgB,KAAK,MAArB,EAA6B,KAAK,SAAlC,CAAP;AACF;;AAED;;;;;;;;;iCAMa,I,EAAM,I,EAAM;AACtB,UAAI,WAAW,IAAf;;AAEA,UAAI,IAAJ,EAAU;AACP,mBAAc,IAAd,SAAsB,IAAtB;AACF;;AAED,aAAO,QAAP;AACF;;;;;;AAGJ,OAAO,OAAP,GAAiB,MAAjB;;;;;;;ACvIA;;;;;;;;;;+eAPA;;;;;;;AASA;;;IAGM,K;;;AACH;;;;;;AAMA,iBAAY,UAAZ,EAAwB,IAAxB,EAA8B,OAA9B,EAAuC;AAAA;;AAAA,8GAC9B,IAD8B,EACxB,OADwB;;AAEpC,UAAK,YAAL,GAAoB,UAApB;AAFoC;AAGtC;;AAED;;;;;;;;;;;gCAOY,S,EAAW,E,EAAI;AACxB,aAAO,KAAK,QAAL,CAAc,MAAd,cAAgC,KAAK,YAArC,cAA4D,SAA5D,EAAuE,EAAvE,CAAP;AACF;;AAED;;;;;;;;;;+BAOW,O,EAAS,E,EAAI;AACrB,aAAO,KAAK,gBAAL,aAAgC,KAAK,YAArC,cAA4D,OAA5D,EAAqE,EAArE,CAAP;AACF;;AAED;;;;;;;;;;oCAOgB,K,EAAO,E,EAAI;AACxB,aAAO,KAAK,QAAL,CAAc,KAAd,cAA+B,KAAK,YAApC,gBAA2D,KAA3D,cAA2E,IAA3E,EAAiF,EAAjF,CAAP;AACF;;AAED;;;;;;;;;;sCAOkB,K,EAAO,E,EAAI;AAC1B,aAAO,KAAK,QAAL,CAAc,KAAd,cAA+B,KAAK,YAApC,gBAA2D,KAA3D,gBAA6E,IAA7E,EAAmF,EAAnF,CAAP;AACF;;AAED;;;;;;;;;;oCAOgB,E,EAAI,E,EAAI;AACrB,aAAO,KAAK,QAAL,CAAc,KAAd,cAA+B,KAAK,YAApC,yBAAoE,EAApE,EAA0E,IAA1E,EAAgF,EAAhF,CAAP;AACF;;AAED;;;;;;;;;;;uCAQmB,K,EAAO,O,EAAS,E,EAAI;AACpC,aAAO,KAAK,QAAL,CAAc,MAAd,cAAgC,KAAK,YAArC,gBAA4D,KAA5D,gBAA8E,EAAC,MAAM,OAAP,EAA9E,EAA+F,EAA/F,CAAP;AACF;;AAED;;;;;;;;;;;qCAQiB,E,EAAI,O,EAAS,E,EAAI;AAC/B,aAAO,KAAK,QAAL,CAAc,OAAd,cAAiC,KAAK,YAAtC,yBAAsE,EAAtE,EAA4E,EAAC,MAAM,OAAP,EAA5E,EAA6F,EAA7F,CAAP;AACF;;AAED;;;;;;;;;;uCAOmB,E,EAAI,E,EAAI;AACxB,aAAO,KAAK,QAAL,CAAc,QAAd,cAAkC,KAAK,YAAvC,yBAAuE,EAAvE,EAA6E,IAA7E,EAAmF,EAAnF,CAAP;AACF;;AAED;;;;;;;;;;;8BAQU,K,EAAO,S,EAAW,E,EAAI;AAC7B,aAAO,KAAK,QAAL,CAAc,OAAd,cAAiC,KAAK,YAAtC,gBAA6D,KAA7D,EAAsE,SAAtE,EAAiF,EAAjF,CAAP;AACF;;AAED;;;;;;;;;;6BAOS,K,EAAO,E,EAAI;AACjB,aAAO,KAAK,QAAL,CAAc,KAAd,cAA+B,KAAK,YAApC,gBAA2D,KAA3D,EAAoE,IAApE,EAA0E,EAA1E,CAAP;AACF;;AAED;;;;;;;;;;mCAOe,O,EAAS,E,EAAI;AACzB,aAAO,KAAK,QAAL,CAAc,KAAd,cAA+B,KAAK,YAApC,kBAA+D,OAA/D,EAAwE,EAAxE,CAAP;AACF;;AAED;;;;;;;;;;iCAOa,S,EAAW,E,EAAI;AACzB,aAAO,KAAK,QAAL,CAAc,KAAd,cAA+B,KAAK,YAApC,oBAA+D,SAA/D,EAA4E,IAA5E,EAAkF,EAAlF,CAAP;AACF;;AAED;;;;;;;;;;oCAOgB,a,EAAe,E,EAAI;AAChC,aAAO,KAAK,QAAL,CAAc,MAAd,cAAgC,KAAK,YAArC,kBAAgE,aAAhE,EAA+E,EAA/E,CAAP;AACF;;AAED;;;;;;;;;;;kCAQc,S,EAAW,a,EAAe,E,EAAI;AACzC,aAAO,KAAK,QAAL,CAAc,OAAd,cAAiC,KAAK,YAAtC,oBAAiE,SAAjE,EAA8E,aAA9E,EAA6F,EAA7F,CAAP;AACF;;AAED;;;;;;;;;;oCAOgB,S,EAAW,E,EAAI;AAC5B,aAAO,KAAK,QAAL,CAAc,QAAd,cAAkC,KAAK,YAAvC,oBAAkE,SAAlE,EAA+E,IAA/E,EAAqF,EAArF,CAAP;AACF;;AAED;;;;;;;;;;gCAOY,S,EAAW,E,EAAI;AACxB,aAAO,KAAK,QAAL,CAAc,MAAd,cAAgC,KAAK,YAArC,cAA4D,SAA5D,EAAuE,EAAvE,CAAP;AACF;;AAEF;;;;;;;;;;+BAOY,O,EAAS,E,EAAI;AACrB,aAAO,KAAK,QAAL,CAAc,KAAd,cAA+B,KAAK,YAApC,cAA2D,OAA3D,EAAoE,EAApE,CAAP;AACF;;AAEF;;;;;;;;;;6BAOU,K,EAAO,E,EAAI;AACjB,aAAO,KAAK,QAAL,CAAc,KAAd,cAA+B,KAAK,YAApC,gBAA2D,KAA3D,EAAoE,IAApE,EAA0E,EAA1E,CAAP;AACF;;AAEF;;;;;;;;;;;8BAQW,K,EAAO,S,EAAW,E,EAAI;AAC7B,aAAO,KAAK,QAAL,CAAc,OAAd,cAAiC,KAAK,YAAtC,gBAA6D,KAA7D,EAAsE,SAAtE,EAAiF,EAAjF,CAAP;AACF;;AAEF;;;;;;;;;;gCAOa,K,EAAO,E,EAAI;AACpB,aAAO,KAAK,QAAL,CAAc,QAAd,cAAkC,KAAK,YAAvC,gBAA8D,KAA9D,EAAuE,IAAvE,EAA6E,EAA7E,CAAP;AACF;;;;;;AAGJ,OAAO,OAAP,GAAiB,KAAjB;;;;;;;ACnPA;;;;;;;;;;+eAPA;;;;;;;AASA;;;IAGM,Q;;;AACH;;;;;;AAMA,oBAAY,IAAZ,EAAkB,OAAlB,EAA2B;AAAA;;AAAA,+GAClB,IADkB,EACZ,OADY;AAE1B;;AAED;;;;;;;;;;;;;;2BAUO,O,EAAS,E,EAAI;AACjB,aAAO,KAAK,QAAL,CAAc,MAAd,EAAsB,WAAtB,EAAmC,OAAnC,EAA4C,EAA5C,CAAP;AACF;;;;;;AAGJ,OAAO,OAAP,GAAiB,QAAjB;;;;;;;AC/BA;;;;;;;;;;+eAPA;;;;;;;AASA;;;IAGM,Y;;;AACH;;;;;;AAMA,wBAAY,YAAZ,EAA0B,IAA1B,EAAgC,OAAhC,EAAyC;AAAA;;AAAA,4HAChC,IADgC,EAC1B,OAD0B;;AAEtC,UAAK,MAAL,GAAc,YAAd;AAFsC;AAGxC;;AAED;;;;;;;;;;;+BAOW,O,EAAS,E,EAAI;AACrB,aAAO,KAAK,QAAL,CAAc,MAAd,aAA+B,KAAK,MAApC,aAAoD,OAApD,EAA6D,EAA7D,CAAP;AACF;;AAED;;;;;;;;;6BAMS,E,EAAI;AACV,UAAI,iBAAiB,KAAK,uBAAL,CAA6B,EAAC,WAAW,MAAZ,EAA7B,CAArB;;AAEA,aAAO,KAAK,gBAAL,YAA+B,KAAK,MAApC,aAAoD,cAApD,EAAoE,EAApE,CAAP;AACF;;AAED;;;;;;;;;6BAMS,Q,EAAU,E,EAAI;AACpB,aAAO,KAAK,gBAAL,YAA+B,KAAK,MAApC,iBAAsD,QAAtD,EAAkE,IAAlE,EAAwE,EAAxE,CAAP;AACF;;AAED;;;;;;;;;;;;gCASY,O,EAAS,E,EAAI;AACtB,aAAO,KAAK,QAAL,CAAc,KAAd,aAA8B,KAAK,MAAnC,eAAqD,OAArD,EAA8D,EAA9D,CAAP;AACF;;AAED;;;;;;;;;6BAMS,E,EAAI;AACV,aAAO,KAAK,gBAAL,YAA+B,KAAK,MAApC,aAAoD,SAApD,EAA+D,EAA/D,CAAP;AACF;;AAED;;;;;;;;;;;;;;;+BAYW,O,EAAS,E,EAAI;AACrB,aAAO,KAAK,QAAL,CAAc,MAAd,aAA+B,KAAK,MAApC,aAAoD,OAApD,EAA6D,EAA7D,CAAP;AACF;;AAED;;;;;;;;;iCAMa,E,EAAI;AACd,aAAO,KAAK,gBAAL,YAA+B,KAAK,MAApC,gBAAuD,EAAC,cAAc,iBAAf,EAAvD,EAA0F,EAA1F,CAAP;AACF;;AAED;;;;;;;;;;kCAOc,O,EAAS,E,EAAI;AACxB,gBAAU,WAAW,EAArB;AACA,cAAQ,YAAR,GAAuB,iBAAvB;AACA,aAAO,KAAK,QAAL,CAAc,MAAd,aAA+B,KAAK,MAApC,gBAAuD,OAAvD,EAAgE,EAAhE,CAAP;AACF;;;;;;AAGJ,OAAO,OAAP,GAAiB,YAAjB;;;;;;;ACjHA;;;;;;;;;;;;+eAPA;;;;;;;AASA;;;IAGM,O;;;AACH;;;;;;AAMA,oBAAY,EAAZ,EAAgB,IAAhB,EAAsB,OAAtB,EAA+B;AAAA;;AAAA,oHACtB,IADsB,EAChB,OADgB,EACP,iBADO;;AAE5B,YAAK,IAAL,GAAY,EAAZ;AAF4B;AAG9B;;AAED;;;;;;;;;;iCAMW,E,EAAI;AACZ,gBAAO,KAAK,QAAL,CAAc,KAAd,iBAAkC,KAAK,IAAvC,EAA+C,IAA/C,EAAqD,EAArD,CAAP;AACF;;AAED;;;;;;;;;;oCAOc,O,EAAS,E,EAAI;AACxB,gBAAO,KAAK,QAAL,CAAc,OAAd,iBAAoC,KAAK,IAAzC,EAAiD,OAAjD,EAA0D,EAA1D,CAAP;AACF;;AAED;;;;;;;;;oCAMc,E,EAAI;AACf,gBAAO,KAAK,QAAL,CAAc,QAAd,iBAAqC,KAAK,IAA1C,EAAkD,IAAlD,EAAwD,EAAxD,CAAP;AACF;;AAED;;;;;;;;;yCAMmB,E,EAAI;AACpB,gBAAO,KAAK,gBAAL,gBAAmC,KAAK,IAAxC,eAAwD,IAAxD,EAA8D,EAA9D,CAAP;AACF;;AAED;;;;;;;;;;uCAOiB,K,EAAO,E,EAAI;AACzB,gBAAO,KAAK,QAAL,CAAc,KAAd,yBAA0C,KAA1C,EAAmD,IAAnD,EAAyD,EAAzD,CAAP;AACF;;AAED;;;;;;;;;;0CAOoB,O,EAAS,E,EAAI;AAC9B,gBAAO,KAAK,QAAL,CAAc,MAAd,iBAAmC,KAAK,IAAxC,eAAwD,OAAxD,EAAiE,EAAjE,CAAP;AACF;;AAED;;;;;;;;;;;0CAQoB,K,EAAO,O,EAAS,E,EAAI;AACrC,gBAAO,KAAK,QAAL,CAAc,OAAd,yBAA4C,KAA5C,EAAqD,OAArD,EAA8D,EAA9D,CAAP;AACF;;AAED;;;;;;;;;;0CAOoB,K,EAAO,E,EAAI;AAC5B,gBAAO,KAAK,QAAL,CAAc,QAAd,yBAA6C,KAA7C,EAAsD,IAAtD,EAA4D,EAA5D,CAAP;AACF;;AAED;;;;;;;;;;;;wCASkB,K,EAAO,Q,EAAU,E,EAAI;AACpC,gBAAO,KAAK,QAAL,CACJ,MADI,yBAEiB,KAFjB,aAGJ,EAAC,UAAU,QAAX,EAHI,EAIJ,EAJI,CAAP;AAMF;;AAEF;;;;;;;;;uCAMkB,E,EAAI;AAAA;;AAClB,gBAAO,KAAK,kBAAL,GACJ,IADI,CACC,gBAAY;AAAA,gBAAV,IAAU,QAAV,IAAU;;AACf,mBAAO,QAAQ,GAAR,CAAY,KAAK,GAAL,CAAS,UAAC,MAAD,EAAY;AACrC,sBAAO,OAAK,gBAAL,wBAA2C,OAAO,EAAlD,aAA8D,IAA9D,CAAP;AACF,aAFkB,CAAZ,CAAP;AAGF,UALI,EAKF,IALE,CAKG,UAAC,cAAD,EAAoB;AACzB,gBAAM,QAAQ,eAAe,MAAf,CAAsB,UAAC,IAAD,SAAkB;AAAA,mBAAV,IAAU,SAAV,IAAU;;AACnD,oBAAK,IAAL,gCAAa,IAAb;AACA,sBAAO,IAAP;AACF,aAHa,EAGX,EAHW,CAAd;AAIA,gBAAI,EAAJ,EAAQ;AACL,kBAAG,IAAH,EAAS,KAAT;AACF;AACD,mBAAO,KAAP;AACF,UAdI,EAcF,KAdE,CAcI,UAAC,GAAD,EAAS;AACf,gBAAI,EAAJ,EAAQ;AACL,kBAAG,GAAH;AACA;AACF;AACD,kBAAM,GAAN;AACF,UApBI,CAAP;AAqBF;;AAED;;;;;;;;;;sCAOgB,K,EAAO,E,EAAI;AACxB,gBAAO,KAAK,gBAAL,wBAA2C,KAA3C,aAA0D,IAA1D,EAAgE,EAAhE,CAAP;AACF;;AAED;;;;;;;;;;qCAOe,M,EAAQ,E,EAAI;AACxB,gBAAO,KAAK,QAAL,CAAc,KAAd,+BAAgD,MAAhD,EAA0D,IAA1D,EAAgE,EAAhE,CAAP;AACF;;AAED;;;;;;;;;;;wCAQkB,K,EAAO,O,EAAS,E,EAAI;AACnC,gBAAO,KAAK,QAAL,CAAc,MAAd,yBAA2C,KAA3C,aAA0D,OAA1D,EAAmE,EAAnE,CAAP;AACF;;AAED;;;;;;;;;;;wCAQkB,M,EAAQ,O,EAAS,E,EAAI;AACpC,gBAAO,KAAK,QAAL,CAAc,OAAd,+BAAkD,MAAlD,EAA4D,OAA5D,EAAqE,EAArE,CAAP;AACF;;AAED;;;;;;;;;;wCAOkB,M,EAAQ,E,EAAI;AAC3B,gBAAO,KAAK,QAAL,CAAc,QAAd,+BAAmD,MAAnD,EAA6D,IAA7D,EAAmE,EAAnE,CAAP;AACF;;AAED;;;;;;;;;;;;;sCAUgB,M,EAAQ,Q,EAAU,K,EAAO,E,EAAI;AAC1C,gBAAO,KAAK,QAAL,CACJ,MADI,+BAEuB,MAFvB,aAGJ,EAAC,UAAU,QAAX,EAAqB,WAAW,KAAhC,EAHI,EAGoC;AACxC,WAJI,CAAP;AAMF;;;;;;AAGJ,OAAO,OAAP,GAAiB,OAAjB;;;;;;;ACpOA;;;;;;;;;;+eAPA;;;;;;;AASA;;;IAGM,S;;;AACH;;;;;;AAMA,qBAAY,IAAZ,EAAkB,OAAlB,EAA2B;AAAA;;AAAA,iHAClB,IADkB,EACZ,OADY;AAE1B;;AAED;;;;;;;;;;iCAMa,E,EAAI;AACd,aAAO,KAAK,QAAL,CAAc,KAAd,EAAqB,aAArB,EAAoC,IAApC,EAA0C,EAA1C,CAAP;AACF;;;;;;AAGJ,OAAO,OAAP,GAAiB,SAAjB;;;;;;;;;;AC3BA;;;;AACA;;;;AACA;;AAGA;;;;;;;;;;+eAZA;;;;;;;AAaA,IAAM,MAAM,qBAAM,mBAAN,CAAZ;;AAEA;;;;IAGM,U;;;AACH;;;;;;AAMA,uBAAY,QAAZ,EAAsB,IAAtB,EAA4B,OAA5B,EAAqC;AAAA;;AAAA,0HAC5B,IAD4B,EACtB,OADsB;;AAElC,YAAK,UAAL,GAAkB,QAAlB;AACA,YAAK,aAAL,GAAqB;AAClB,iBAAQ,IADU;AAElB,cAAK;AAFa,OAArB;AAHkC;AAOpC;;AAED;;;;;;;;;;;6BAOO,G,EAAK,E,EAAI;AACb,gBAAO,KAAK,QAAL,CAAc,KAAd,cAA+B,KAAK,UAApC,kBAA2D,GAA3D,EAAkE,IAAlE,EAAwE,EAAxE,CAAP;AACF;;AAED;;;;;;;;;;gCAOU,O,EAAS,E,EAAI;AACpB,gBAAO,KAAK,QAAL,CAAc,MAAd,cAAgC,KAAK,UAArC,gBAA4D,OAA5D,EAAqE,EAArE,CAAP;AACF;;AAED;;;;;;;;;;gCAOU,G,EAAK,E,EAAI;AAChB,gBAAO,KAAK,QAAL,CAAc,QAAd,cAAkC,KAAK,UAAvC,kBAA8D,GAA9D,EAAqE,IAArE,EAA2E,EAA3E,CAAP;AACF;;AAED;;;;;;;;;iCAMW,E,EAAI;AACZ,gBAAO,KAAK,QAAL,CAAc,QAAd,cAAkC,KAAK,UAAvC,EAAqD,IAArD,EAA2D,EAA3D,CAAP;AACF;;AAED;;;;;;;;;+BAMS,E,EAAI;AACV,gBAAO,KAAK,QAAL,CAAc,KAAd,cAA+B,KAAK,UAApC,YAAuD,IAAvD,EAA6D,EAA7D,CAAP;AACF;;AAED;;;;;;;;;;uCAOiB,O,EAAS,E,EAAI;AAC3B,mBAAU,WAAW,EAArB;AACA,gBAAO,KAAK,QAAL,CAAc,KAAd,cAA+B,KAAK,UAApC,aAAwD,OAAxD,EAAiE,EAAjE,CAAP;AACF;;AAED;;;;;;;;;;qCAOe,M,EAAQ,E,EAAI;AACxB,gBAAO,KAAK,QAAL,CAAc,KAAd,cAA+B,KAAK,UAApC,eAAwD,MAAxD,EAAkE,IAAlE,EAAwE,EAAxE,CAAP;AACF;;AAED;;;;;;;;;;2CAOqB,M,EAAQ,E,EAAI;AAC9B,gBAAO,KAAK,QAAL,CAAc,KAAd,cAA+B,KAAK,UAApC,eAAwD,MAAxD,aAAwE,IAAxE,EAA8E,EAA9E,CAAP;AACF;;AAED;;;;;;;;;;;sCAQgB,I,EAAM,I,EAAM,E,EAAI;AAC7B,gBAAO,KAAK,QAAL,CAAc,KAAd,cAA+B,KAAK,UAApC,iBAA0D,IAA1D,WAAoE,IAApE,EAA4E,IAA5E,EAAkF,EAAlF,CAAP;AACF;;AAED;;;;;;;;;mCAMa,E,EAAI;AACd,gBAAO,KAAK,QAAL,CAAc,KAAd,cAA+B,KAAK,UAApC,gBAA2D,IAA3D,EAAiE,EAAjE,CAAP;AACF;;AAED;;;;;;;;;;8BAOQ,G,EAAK,E,EAAI;AACd,gBAAO,KAAK,QAAL,CAAc,KAAd,cAA+B,KAAK,UAApC,mBAA4D,GAA5D,EAAmE,IAAnE,EAAyE,EAAzE,EAA6E,KAA7E,CAAP;AACF;;AAED;;;;;;;;;;gCAOU,M,EAAQ,E,EAAI;AACnB,gBAAO,KAAK,QAAL,CAAc,KAAd,cAA+B,KAAK,UAApC,kBAA2D,MAA3D,EAAqE,IAArE,EAA2E,EAA3E,CAAP;AACF;;AAED;;;;;;;;;;gCAOU,G,EAAK,E,EAAI;AAChB,gBAAO,KAAK,QAAL,CAAc,KAAd,cAA+B,KAAK,UAApC,qBAA8D,GAA9D,EAAqE,IAArE,EAA2E,EAA3E,CAAP;AACF;;AAED;;;;;;;;;;;;;;;kCAYY,O,EAAS,E,EAAI;AACtB,mBAAU,WAAW,EAArB;;AAEA,iBAAQ,KAAR,GAAgB,KAAK,UAAL,CAAgB,QAAQ,KAAxB,CAAhB;AACA,iBAAQ,KAAR,GAAgB,KAAK,UAAL,CAAgB,QAAQ,KAAxB,CAAhB;;AAEA,gBAAO,KAAK,QAAL,CAAc,KAAd,cAA+B,KAAK,UAApC,eAA0D,OAA1D,EAAmE,EAAnE,CAAP;AACF;;AAEA;;;;;;;;;;sCAOe,G,EAAK,E,EAAI;AACtB,eAAM,OAAO,EAAb;AACA,gBAAO,KAAK,QAAL,CAAc,KAAd,cAA+B,KAAK,UAApC,iBAA0D,GAA1D,EAAiE,IAAjE,EAAuE,EAAvE,CAAP;AACF;;AAED;;;;;;;;;;;6BAQO,M,EAAQ,I,EAAM,E,EAAI;AACtB,kBAAS,mBAAiB,MAAjB,GAA4B,EAArC;AACA,gBAAO,KAAK,QAAL,CAAc,KAAd,cAA+B,KAAK,UAApC,kBAA2D,IAA3D,GAAkE,MAAlE,EAA4E,IAA5E,EAAkF,EAAlF,CAAP;AACF;;AAED;;;;;;;;;;mCAOa,G,EAAK,E,EAAI;AACnB,gBAAO,KAAK,QAAL,CAAc,KAAd,cAA+B,KAAK,UAApC,iBAA0D,GAA1D,gBAA0E,IAA1E,EAAgF,EAAhF,CAAP;AACF;;AAED;;;;;;;;;;8BAOQ,O,EAAS,E,EAAI;AAClB,gBAAO,KAAK,QAAL,CAAc,KAAd,cAA+B,KAAK,UAApC,mBAA4D,OAA5D,EAAuE,IAAvE,EAA6E,EAA7E,CAAP;AACF;;AAED;;;;;;;;;;iCAOW,O,EAAS,E,EAAI;AACrB,aAAI,WAAW,KAAK,iBAAL,CAAuB,OAAvB,CAAf;;AAEA,aAAI,iBAAJ,EAAuB,QAAvB;AACA,gBAAO,KAAK,QAAL,CAAc,MAAd,cAAgC,KAAK,UAArC,iBAA6D,QAA7D,EAAuE,EAAvE,CAAP;AACF;;AAED;;;;;;;;wCAKkB,O,EAAS;AACxB,aAAI,OAAO,OAAP,KAAmB,QAAvB,EAAiC;AAC9B,gBAAI,oBAAJ;AACA,mBAAO;AACJ,wBAAS,cAAK,MAAL,CAAY,OAAZ,CADL;AAEJ,yBAAU;AAFN,aAAP;AAKF,UAPD,MAOO,IAAI,OAAO,MAAP,KAAkB,WAAlB,IAAiC,mBAAmB,MAAxD,EAAgE;AACpE,gBAAI,yBAAJ;AACA,mBAAO;AACJ,wBAAS,QAAQ,QAAR,CAAiB,QAAjB,CADL;AAEJ,yBAAU;AAFN,aAAP;AAKF,UAPM,MAOA,IAAI,OAAO,IAAP,KAAgB,WAAhB,IAA+B,mBAAmB,IAAtD,EAA4D;AAChE,gBAAI,gCAAJ;AACA,mBAAO;AACJ,wBAAS,eAAO,MAAP,CAAc,OAAd,CADL;AAEJ,yBAAU;AAFN,aAAP;AAKF,UAPM,MAOA;AAAE;AACN,4DAA6C,OAA7C,yCAA6C,OAA7C,YAAyD,KAAK,SAAL,CAAe,OAAf,CAAzD;AACA,kBAAM,IAAI,KAAJ,CAAU,mFAAV,CAAN;AACF;AACH;;AAED;;;;;;;;;;;;;iCAUW,W,EAAa,I,EAAM,O,EAAS,E,EAAI;AACxC,aAAI,UAAU;AACX,uBAAW,WADA,EACa;AACxB,kBAAM,CAAC;AACJ,qBAAM,IADF;AAEJ,oBAAK,OAFD;AAGJ,qBAAM,QAHF;AAIJ,qBAAM;AAJF,aAAD;AAFK,UAAd;;AAUA,gBAAO,KAAK,QAAL,CAAc,MAAd,cAAgC,KAAK,UAArC,iBAA6D,OAA7D,EAAsE,EAAtE,CAAP;AACF;;AAED;;;;;;;;;;;iCAQW,I,EAAM,O,EAAS,E,EAAI;AAC3B,gBAAO,KAAK,QAAL,CAAc,MAAd,cAAgC,KAAK,UAArC,iBAA6D;AACjE,sBADiE;AAEjE,uBAAW,OAFsD,EAA7D,EAGJ,EAHI,CAAP;AAIF;;AAED;;;;;;;;;;;;6BASO,M,EAAQ,I,EAAM,O,EAAS,E,EAAI;AAAA;;AAC/B,aAAI,OAAO;AACR,4BADQ;AAER,sBAFQ;AAGR,qBAAS,CAAC,MAAD;AAHD,UAAX;;AAMA,gBAAO,KAAK,QAAL,CAAc,MAAd,cAAgC,KAAK,UAArC,mBAA+D,IAA/D,EAAqE,EAArE,EACH,IADG,CACE,UAAC,QAAD,EAAc;AACjB,mBAAK,aAAL,CAAmB,GAAnB,GAAyB,SAAS,IAAT,CAAc,GAAvC,CADiB,CAC2B;AAC5C,mBAAO,QAAP;AACF,UAJG,CAAP;AAKF;;AAED;;;;;;;;;;;;iCASW,G,EAAK,S,EAAW,K,EAAO,E,EAAI;AACnC,gBAAO,KAAK,QAAL,CAAc,OAAd,cAAiC,KAAK,UAAtC,kBAA6D,GAA7D,EAAoE;AACxE,iBAAK,SADmE;AAExE,mBAAO;AAFiE,UAApE,EAGJ,EAHI,CAAP;AAIF;;AAED;;;;;;;;;;;;;;;mCAYa,S,EAAW,O,EAAS,E,EAAI;AAClC,gBAAO,KAAK,QAAL,CAAc,MAAd,cAAgC,KAAK,UAArC,kBAA4D,SAA5D,EAAyE,OAAzE,EAAkF,EAAlF,CAAP;AACF;;AAED;;;;;;;;;;;;;;;;;;uCAeiB,O,EAAS,E,EAAI;AAC3B,gBAAO,KAAK,QAAL,CAAc,OAAd,cAAiC,KAAK,UAAtC,EAAoD,OAApD,EAA6D,EAA7D,CAAP;AACF;;AAEF;;;;;;;;;iCAMY,E,EAAI;AACZ,gBAAO,KAAK,QAAL,CAAc,KAAd,cAA+B,KAAK,UAApC,EAAkD,IAAlD,EAAwD,EAAxD,CAAP;AACF;;AAED;;;;;;;;;sCAMgB,E,EAAI;AACjB,gBAAO,KAAK,QAAL,CAAc,KAAd,cAA+B,KAAK,UAApC,oBAA+D,IAA/D,EAAqE,EAArE,CAAP;AACF;;AAED;;;;;;;;;0CAMoB,E,EAAI;AACrB,gBAAO,KAAK,QAAL,CAAc,KAAd,cAA+B,KAAK,UAApC,0BAAqE,IAArE,EAA2E,EAA3E,CAAP;AACF;;AAED;;;;;;;;;;uCAOiB,E,EAAI;AAClB,gBAAO,KAAK,QAAL,CAAc,KAAd,cAA+B,KAAK,UAApC,qBAAgE,IAAhE,EAAsE,EAAtE,CAAP;AACF;;AAED;;;;;;;;;;qCAOe,Q,EAAU,E,EAAI;AAC1B,gBAAO,KAAK,QAAL,CAAc,KAAd,cAA+B,KAAK,UAApC,uBAAgE,QAAhE,EAA4E,IAA5E,EAAkF,EAAlF,CAAP;AACF;;AAED;;;;;;;;;;;;kCASY,G,EAAK,I,EAAM,G,EAAK,E,EAAI;AAC7B,gBAAO,YAAU,UAAU,IAAV,CAAV,GAA8B,EAArC;AACA,gBAAO,KAAK,QAAL,CAAc,KAAd,cAA+B,KAAK,UAApC,kBAA2D,IAA3D,EAAmE;AACvE;AADuE,UAAnE,EAEJ,EAFI,EAEA,GAFA,CAAP;AAGF;;AAED;;;;;;;;;;;gCAQU,G,EAAK,G,EAAK,E,EAAI;AACrB,gBAAO,KAAK,QAAL,CAAc,KAAd,cAA+B,KAAK,UAApC,cAAyD;AAC7D;AAD6D,UAAzD,EAEJ,EAFI,EAEA,GAFA,CAAP;AAGF;;AAED;;;;;;;;;2BAMK,E,EAAI;AACN,gBAAO,KAAK,QAAL,CAAc,MAAd,cAAgC,KAAK,UAArC,aAAyD,IAAzD,EAA+D,EAA/D,CAAP;AACF;;AAED;;;;;;;;;gCAMU,E,EAAI;AACX,gBAAO,KAAK,QAAL,CAAc,KAAd,cAA+B,KAAK,UAApC,aAAwD,IAAxD,EAA8D,EAA9D,CAAP;AACF;;AAED;;;;;;;;;;mCAOa,S,EAAW,S,EAAW,E,EAAI;AAAA;;AACpC,aAAI,OAAO,SAAP,KAAqB,UAAzB,EAAqC;AAClC,iBAAK,SAAL;AACA,wBAAY,SAAZ;AACA,wBAAY,QAAZ;AACF;;AAED,gBAAO,KAAK,MAAL,YAAqB,SAArB,EACH,IADG,CACE,UAAC,QAAD,EAAc;AACjB,gBAAI,MAAM,SAAS,IAAT,CAAc,MAAd,CAAqB,GAA/B;AACA,mBAAO,OAAK,SAAL,CAAe;AACnB,uBADmB;AAEnB,oCAAmB;AAFA,aAAf,EAGJ,EAHI,CAAP;AAIF,UAPG,CAAP;AAQF;;AAED;;;;;;;;;;wCAOkB,O,EAAS,E,EAAI;AAC5B,gBAAO,KAAK,QAAL,CAAc,MAAd,cAAgC,KAAK,UAArC,aAAyD,OAAzD,EAAkE,EAAlE,CAAP;AACF;;AAED;;;;;;;;;;;wCAQkB,M,EAAQ,O,EAAS,E,EAAI;AACpC,gBAAO,KAAK,QAAL,CAAc,OAAd,cAAiC,KAAK,UAAtC,eAA0D,MAA1D,EAAoE,OAApE,EAA6E,EAA7E,CAAP;AACF;;AAED;;;;;;;;;gCAMU,E,EAAI;AACX,gBAAO,KAAK,QAAL,CAAc,KAAd,cAA+B,KAAK,UAApC,aAAwD,IAAxD,EAA8D,EAA9D,CAAP;AACF;;AAED;;;;;;;;;;8BAOQ,E,EAAI,E,EAAI;AACb,gBAAO,KAAK,QAAL,CAAc,KAAd,cAA+B,KAAK,UAApC,eAAwD,EAAxD,EAA8D,IAA9D,EAAoE,EAApE,CAAP;AACF;;AAED;;;;;;;;;;iCAOW,O,EAAS,E,EAAI;AACrB,gBAAO,KAAK,QAAL,CAAc,MAAd,cAAgC,KAAK,UAArC,aAAyD,OAAzD,EAAkE,EAAlE,CAAP;AACF;;AAED;;;;;;;;;;;iCAQW,E,EAAI,O,EAAS,E,EAAI;AACzB,gBAAO,KAAK,QAAL,CAAc,OAAd,cAAiC,KAAK,UAAtC,eAA0D,EAA1D,EAAgE,OAAhE,EAAyE,EAAzE,CAAP;AACF;;AAED;;;;;;;;;;iCAOW,E,EAAI,E,EAAI;AAChB,gBAAO,KAAK,QAAL,CAAc,QAAd,cAAkC,KAAK,UAAvC,eAA2D,EAA3D,EAAiE,IAAjE,EAAuE,EAAvE,CAAP;AACF;;AAED;;;;;;;;;+BAMS,E,EAAI;AACV,gBAAO,KAAK,QAAL,CAAc,KAAd,cAA+B,KAAK,UAApC,YAAuD,IAAvD,EAA6D,EAA7D,CAAP;AACF;;AAED;;;;;;;;;;6BAOO,E,EAAI,E,EAAI;AACZ,gBAAO,KAAK,QAAL,CAAc,KAAd,cAA+B,KAAK,UAApC,cAAuD,EAAvD,EAA6D,IAA7D,EAAmE,EAAnE,CAAP;AACF;;AAED;;;;;;;;;;gCAOU,O,EAAS,E,EAAI;AACpB,gBAAO,KAAK,QAAL,CAAc,MAAd,cAAgC,KAAK,UAArC,YAAwD,OAAxD,EAAiE,EAAjE,CAAP;AACF;;AAED;;;;;;;;;;gCAOU,E,EAAI,E,EAAI;AACf,gBAAO,KAAK,QAAL,CAAc,QAAd,cAAkC,KAAK,UAAvC,cAA0D,EAA1D,EAAgE,IAAhE,EAAsE,EAAtE,CAAP;AACF;;AAED;;;;;;;;;;;iCAQW,M,EAAQ,I,EAAM,E,EAAI;AAAA;;AAC1B,gBAAO,KAAK,MAAL,CAAY,MAAZ,EAAoB,IAApB,EACH,IADG,CACE,UAAC,QAAD,EAAc;AACjB,gBAAM,eAAe;AAClB,kDAAgC,IAAhC,OADkB;AAElB,oBAAK,SAAS,IAAT,CAAc,GAFD;AAGlB;AAHkB,aAArB;AAKA,mBAAO,OAAK,QAAL,CAAc,QAAd,cAAkC,OAAK,UAAvC,kBAA8D,IAA9D,EAAsE,YAAtE,EAAoF,EAApF,CAAP;AACF,UARG,CAAP;AASF;;AAED;;;;;;;;;;;2BAQK,M,EAAQ,O,EAAS,O,EAAS,E,EAAI;AAAA;;AAChC,aAAI,eAAJ;AACA,gBAAO,KAAK,MAAL,YAAqB,MAArB,EACH,IADG,CACE;AAAA,gBAAS,MAAT,QAAE,IAAF,CAAS,MAAT;AAAA,mBAAsB,OAAK,OAAL,CAAgB,OAAO,GAAvB,qBAAtB;AAAA,UADF,EAEH,IAFG,CAEE,iBAAyB;AAAA,mCAAvB,IAAuB;AAAA,gBAAhB,IAAgB,cAAhB,IAAgB;AAAA,gBAAV,GAAU,cAAV,GAAU;;AAC5B,qBAAS,GAAT;AACA,gBAAI,UAAU,KAAK,GAAL,CAAS,UAAC,GAAD,EAAS;AAC7B,mBAAI,IAAI,IAAJ,KAAa,OAAjB,EAA0B;AACvB,sBAAI,IAAJ,GAAW,OAAX;AACF;AACD,mBAAI,IAAI,IAAJ,KAAa,MAAjB,EAAyB;AACtB,yBAAO,IAAI,GAAX;AACF;AACD,sBAAO,GAAP;AACF,aARa,CAAd;AASA,mBAAO,OAAK,UAAL,CAAgB,OAAhB,CAAP;AACF,UAdG,EAeH,IAfG,CAeE;AAAA,gBAAQ,IAAR,SAAE,IAAF;AAAA,mBAAkB,OAAK,MAAL,CAAY,MAAZ,EAAoB,KAAK,GAAzB,iBAA0C,OAA1C,gBAA0D,OAA1D,QAAlB;AAAA,UAfF,EAgBH,IAhBG,CAgBE;AAAA,gBAAQ,MAAR,SAAE,IAAF;AAAA,mBAAoB,OAAK,UAAL,YAAyB,MAAzB,EAAmC,OAAO,GAA1C,EAA+C,IAA/C,EAAqD,EAArD,CAApB;AAAA,UAhBF,CAAP;AAiBF;;AAED;;;;;;;;;;;;;;;;;gCAcU,M,EAAQ,I,EAAM,O,EAAS,O,EAAS,O,EAAS,E,EAAI;AAAA;;AACpD,aAAI,OAAO,OAAP,KAAmB,UAAvB,EAAmC;AAChC,iBAAK,OAAL;AACA,sBAAU,EAAV;AACF;AACD,aAAI,WAAW,OAAO,UAAU,IAAV,CAAP,GAAyB,EAAxC;AACA,aAAI,eAAe,QAAQ,MAAR,KAAmB,KAAtC;AACA,aAAI,SAAS;AACV,0BADU;AAEV,4BAFU;AAGV,oBAAQ,QAAQ,MAHN;AAIV,uBAAW,QAAQ,SAJT;AAKV,qBAAS,eAAe,eAAO,MAAP,CAAc,OAAd,CAAf,GAAwC;AALvC,UAAb;;AAQA,gBAAO,KAAK,MAAL,CAAY,MAAZ,EAAoB,QAApB,EACH,IADG,CACE,UAAC,QAAD,EAAc;AACjB,mBAAO,GAAP,GAAa,SAAS,IAAT,CAAc,GAA3B;AACA,mBAAO,OAAK,QAAL,CAAc,KAAd,cAA+B,OAAK,UAApC,kBAA2D,QAA3D,EAAuE,MAAvE,EAA+E,EAA/E,CAAP;AACF,UAJG,EAID,YAAM;AACN,mBAAO,OAAK,QAAL,CAAc,KAAd,cAA+B,OAAK,UAApC,kBAA2D,QAA3D,EAAuE,MAAvE,EAA+E,EAA/E,CAAP;AACF,UANG,CAAP;AAOF;;AAED;;;;;;;;;;gCAOU,E,EAAI;AACX,gBAAO,KAAK,gBAAL,oBAAuC,KAAK,UAA5C,EAA0D,IAA1D,EAAgE,EAAhE,CAAP;AACF;;AAED;;;;;;;;;2BAMK,E,EAAI;AACN,gBAAO,KAAK,QAAL,CAAc,KAAd,qBAAsC,KAAK,UAA3C,EAAyD,IAAzD,EAA+D,EAA/D,CAAP;AACF;;AAED;;;;;;;;;6BAMO,E,EAAI;AACR,gBAAO,KAAK,QAAL,CAAc,QAAd,qBAAyC,KAAK,UAA9C,EAA4D,IAA5D,EAAkE,EAAlE,CAAP;AACF;;AAED;;;;;;;;;;oCAOc,O,EAAS,E,EAAI;AACxB,gBAAO,KAAK,QAAL,CAAc,MAAd,cAAgC,KAAK,UAArC,gBAA4D,OAA5D,EAAqE,EAArE,CAAP;AACF;;AAED;;;;;;;;;;;oCAQc,E,EAAI,O,EAAS,E,EAAI;AAC5B,gBAAO,KAAK,QAAL,CAAc,OAAd,cAAiC,KAAK,UAAtC,kBAA6D,EAA7D,EAAmE,OAAnE,EAA4E,EAA5E,CAAP;AACF;;AAED;;;;;;;;;mCAMa,E,EAAI;AACd,gBAAO,KAAK,QAAL,CAAc,KAAd,cAA+B,KAAK,UAApC,gBAA2D,IAA3D,EAAiE,EAAjE,CAAP;AACF;;AAED;;;;;;;;;;iCAOW,E,EAAI,E,EAAI;AAChB,gBAAO,KAAK,QAAL,CAAc,KAAd,cAA+B,KAAK,UAApC,kBAA2D,EAA3D,EAAiE,IAAjE,EAAuE,EAAvE,CAAP;AACF;;AAED;;;;;;;;;;oCAOc,E,EAAI,E,EAAI;AACnB,gBAAO,KAAK,QAAL,CAAc,QAAd,cAAkC,KAAK,UAAvC,kBAA8D,EAA9D,EAAoE,IAApE,EAA0E,EAA1E,CAAP;AACF;;AAED;;;;;;;;;;;uCAQiB,M,EAAQ,O,EAAS,E,EAAI;AACnC,gBAAO,KAAK,QAAL,CAAc,KAAd,cAA+B,KAAK,UAApC,eAAwD,MAAxD,aAAwE,OAAxE,EAAiF,EAAjF,CAAP;AACF;;AAED;;;;;;;;;mCAMa,E,EAAI;AACd,gBAAO,KAAK,gBAAL,aAAgC,KAAK,UAArC,gBAA4D,EAAC,cAAc,iBAAf,EAA5D,EAA+F,EAA/F,CAAP;AACF;;AAED;;;;;;;;;;oCAOc,O,EAAS,E,EAAI;AACxB,mBAAU,WAAW,EAArB;AACA,iBAAQ,YAAR,GAAuB,iBAAvB;AACA,gBAAO,KAAK,QAAL,CAAc,MAAd,cAAgC,KAAK,UAArC,gBAA4D,OAA5D,EAAqE,EAArE,CAAP;AACF;;;;;;AAIJ,OAAO,OAAP,GAAiB,UAAjB;;;;;;;;;;;ACt1BA;;;;AACA;;;;AACA;;;;;;;;;;+eATA;;;;;;;AAWA,IAAM,MAAM,qBAAM,gBAAN,CAAZ;;AAEA;;;;IAGM,a;;;AACH;;;;;;AAMA,0BAAY,OAAZ,EAAqB,IAArB,EAA2B,QAA3B,EAAqC;AAAA;;AAAA,gIAC5B,OAD4B;;AAElC,YAAK,IAAL,GAAY,IAAZ;AACA,YAAK,OAAL,GAAe,SAAS,MAAxB;AACA,YAAK,QAAL,GAAgB,CAAC,YAAY,EAAb,EAAiB,QAAjB,IAA6B,QAA7C;AACA,YAAK,MAAL,GAAc,SAAS,MAAvB;AALkC;AAMpC;;;EAbwB,K;;AAgB5B;;;;;IAGM,W;AACH;;;;;;;AAOA;;;;;;;AAOA,wBAAY,IAAZ,EAAkB,OAAlB,EAA2B,YAA3B,EAAyC;AAAA;;AACtC,WAAK,SAAL,GAAiB,WAAW,wBAA5B;AACA,WAAK,MAAL,GAAc;AACX,gBAAO,KAAK,KADD;AAEX,mBAAU,KAAK,QAFJ;AAGX,mBAAU,KAAK;AAHJ,OAAd;AAKA,WAAK,cAAL,GAAsB,gBAAgB,IAAtC;;AAEA,UAAI,KAAK,KAAT,EAAgB;AACb,cAAK,qBAAL,GAA6B,WAAW,KAAK,KAA7C;AACF,OAFD,MAEO,IAAI,KAAK,QAAL,IAAiB,KAAK,QAA1B,EAAoC;AACxC,cAAK,qBAAL,GAA6B,WAAW,eAAO,MAAP,CAAc,KAAK,QAAL,GAAgB,GAAhB,GAAsB,KAAK,QAAzC,CAAxC;AACF;AACH;;AAED;;;;;;;;;;+BAMS,I,EAAM;AACZ,aAAI,MAAM,IAAV;;AAEA,aAAI,KAAK,OAAL,CAAa,IAAb,MAAuB,CAAC,CAA5B,EAA+B;AAC5B,kBAAM,KAAK,SAAL,GAAiB,IAAvB;AACF;;AAED,aAAI,iBAAiB,eAAe,IAAI,IAAJ,GAAW,OAAX,EAApC;AACA,gBAAO,IAAI,OAAJ,CAAY,iBAAZ,EAA+B,cAA/B,CAAP;AACF;;AAED;;;;;;;;;;0CAOoB,G,EAAK,Y,EAAc;AACpC,aAAI,UAAU;AACX,4BAAgB,gCADL;AAEX,sBAAU,6BAA6B,gBAAgB,KAAK,cAAlD;AAFC,UAAd;;AAKA,aAAI,GAAJ,EAAS;AACN,oBAAQ,MAAR,IAAkB,MAAlB;AACF;AACD,iBAAQ,MAAR,IAAkB,OAAlB;;AAEA,aAAI,KAAK,qBAAT,EAAgC;AAC7B,oBAAQ,aAAR,GAAwB,KAAK,qBAA7B;AACF;;AAED,gBAAO,OAAP;AACF;;AAED;;;;;;;;;gDAM6C;AAAA,aAArB,cAAqB,uEAAJ,EAAI;;AAC1C,aAAI,EAAE,eAAe,UAAf,IAA6B,eAAe,WAA9C,CAAJ,EAAgE;AAC7D,2BAAe,IAAf,GAAsB,eAAe,IAAf,IAAuB,KAA7C;AACF;AACD,wBAAe,IAAf,GAAsB,eAAe,IAAf,IAAuB,SAA7C;AACA,wBAAe,QAAf,GAA0B,eAAe,QAAf,IAA2B,KAArD,CAL0C,CAKkB;;AAE5D,gBAAO,cAAP;AACF;;AAED;;;;;;;;iCAKW,I,EAAM;AACd,aAAI,QAAS,gBAAgB,IAA7B,EAAoC;AACjC,mBAAO,KAAK,WAAL,EAAP;AACF;;AAED,gBAAO,IAAP;AACF;;AAED;;;;;;;AAOA;;;;;;;;;;;;;;+BAWS,M,EAAQ,I,EAAM,I,EAAM,E,EAAI,G,EAAK;AACnC,aAAM,MAAM,KAAK,QAAL,CAAc,IAAd,CAAZ;;AAEA,aAAM,eAAe,CAAC,QAAQ,EAAT,EAAa,YAAlC;AACA,aAAI,YAAJ,EAAkB;AACf,mBAAO,KAAK,YAAZ;AACF;AACD,aAAM,UAAU,KAAK,mBAAL,CAAyB,GAAzB,EAA8B,YAA9B,CAAhB;;AAEA,aAAI,cAAc,EAAlB;;AAEA,aAAM,wBAAwB,QAAS,QAAO,IAAP,yCAAO,IAAP,OAAgB,QAAzB,IAAsC,gBAAgB,MAAhB,CAApE;AACA,aAAI,qBAAJ,EAA2B;AACxB,0BAAc,IAAd;AACA,mBAAO,SAAP;AACF;;AAED,aAAM,SAAS;AACZ,iBAAK,GADO;AAEZ,oBAAQ,MAFI;AAGZ,qBAAS,OAHG;AAIZ,oBAAQ,WAJI;AAKZ,kBAAM,IALM;AAMZ,0BAAc,MAAM,MAAN,GAAe;AANjB,UAAf;;AASA,aAAO,OAAO,MAAd,YAA2B,OAAO,GAAlC;AACA,aAAM,iBAAiB,qBAAM,MAAN,EAAc,KAAd,CAAoB,qBAAqB,EAArB,EAAyB,IAAzB,CAApB,CAAvB;;AAEA,aAAI,EAAJ,EAAQ;AACL,2BAAe,IAAf,CAAoB,UAAC,QAAD,EAAc;AAC/B,mBAAI,SAAS,IAAT,IAAiB,OAAO,IAAP,CAAY,SAAS,IAArB,EAA2B,MAA3B,GAAoC,CAAzD,EAA4D;AACzD;AACA,qBAAG,IAAH,EAAS,SAAS,IAAlB,EAAwB,QAAxB;AACF,gBAHD,MAGO,IAAI,OAAO,MAAP,KAAkB,KAAlB,IAA2B,OAAO,IAAP,CAAY,SAAS,IAArB,EAA2B,MAA3B,GAAoC,CAAnE,EAAsE;AAC1E;AACA,qBAAG,IAAH,EAAU,SAAS,MAAT,GAAkB,GAA5B,EAAkC,QAAlC;AACF,gBAHM,MAGA;AACJ,qBAAG,IAAH,EAAS,SAAS,IAAlB,EAAwB,QAAxB;AACF;AACH,aAVD;AAWF;;AAED,gBAAO,cAAP;AACF;;AAED;;;;;;;;;;;uCAQiB,I,EAAM,I,EAAM,E,EAAoB;AAAA,aAAhB,MAAgB,uEAAP,KAAO;;AAC9C,gBAAO,KAAK,QAAL,CAAc,MAAd,EAAsB,IAAtB,EAA4B,IAA5B,EACH,IADG,CACE,SAAS,OAAT,CAAiB,QAAjB,EAA2B;AAC9B,gBAAI,EAAJ,EAAQ;AACL,kBAAG,IAAH,EAAS,IAAT,EAAe,QAAf;AACF;AACD,mBAAO,IAAP;AACF,UANG,EAMD,SAAS,OAAT,CAAiB,QAAjB,EAA2B;AAC3B,gBAAI,SAAS,QAAT,CAAkB,MAAlB,KAA6B,GAAjC,EAAsC;AACnC,mBAAI,EAAJ,EAAQ;AACL,qBAAG,IAAH,EAAS,KAAT,EAAgB,QAAhB;AACF;AACD,sBAAO,KAAP;AACF;;AAED,gBAAI,EAAJ,EAAQ;AACL,kBAAG,QAAH;AACF;AACD,kBAAM,QAAN;AACF,UAlBG,CAAP;AAmBF;;AAED;;;;;;;;;;;;;uCAUiB,I,EAAM,O,EAAS,E,EAAI,O,EAAS;AAAA;;AAC1C,mBAAU,WAAW,EAArB;;AAEA,gBAAO,KAAK,QAAL,CAAc,KAAd,EAAqB,IAArB,EAA2B,OAA3B,EACH,IADG,CACE,UAAC,QAAD,EAAc;AAAA;;AACjB,gBAAI,kBAAJ;AACA,gBAAI,SAAS,IAAT,YAAyB,KAA7B,EAAoC;AACjC,2BAAY,SAAS,IAArB;AACF,aAFD,MAEO,IAAI,SAAS,IAAT,CAAc,KAAd,YAA+B,KAAnC,EAA0C;AAC9C,2BAAY,SAAS,IAAT,CAAc,KAA1B;AACF,aAFM,MAEA;AACJ,mBAAI,+CAA6C,SAAS,IAAtD,uBAAJ;AACA,qBAAM,IAAI,aAAJ,CAAkB,OAAlB,EAA2B,IAA3B,EAAiC,QAAjC,CAAN;AACF;AACD,iCAAQ,IAAR,oCAAgB,SAAhB;;AAEA,gBAAM,UAAU,YAAY,SAAS,OAAT,CAAiB,IAA7B,CAAhB;AACA,gBAAI,WAAW,OAAO,QAAQ,IAAf,KAAwB,QAAvC,EAAiD;AAC9C,2CAA0B,OAA1B;AACA,sBAAO,OAAK,gBAAL,CAAsB,OAAtB,EAA+B,OAA/B,EAAwC,EAAxC,EAA4C,OAA5C,CAAP;AACF;;AAED,gBAAI,EAAJ,EAAQ;AACL,kBAAG,IAAH,EAAS,OAAT,EAAkB,QAAlB;AACF;;AAED,qBAAS,IAAT,GAAgB,OAAhB;AACA,mBAAO,QAAP;AACF,UAzBG,EAyBD,KAzBC,CAyBK,qBAAqB,EAArB,EAAyB,IAAzB,CAzBL,CAAP;AA0BF;;;;;;AAGJ,OAAO,OAAP,GAAiB,WAAjB;;AAEA;AACA;AACA;AACA,IAAM,uBAAuB,CAAC,KAAD,EAAQ,MAAR,EAAgB,QAAhB,CAA7B;AACA,SAAS,eAAT,CAAyB,MAAzB,EAAiC;AAC9B,UAAO,qBAAqB,OAArB,CAA6B,MAA7B,MAAyC,CAAC,CAAjD;AACF;;AAED,SAAS,WAAT,GAAuC;AAAA,OAAlB,WAAkB,uEAAJ,EAAI;;AACpC,OAAM,QAAQ,YAAY,KAAZ,CAAkB,SAAlB,CAAd,CADoC,CACQ;AAC5C,UAAO,MAAM,MAAN,CAAa,UAAS,OAAT,EAAkB,IAAlB,EAAwB;AACzC,UAAI,KAAK,MAAL,CAAY,YAAZ,MAA8B,CAAC,CAAnC,EAAsC;AACnC,gBAAO,CAAC,KAAK,KAAL,CAAW,QAAX,KAAwB,EAAzB,EAA6B,CAA7B,CAAP;AACF;;AAED,aAAO,OAAP;AACF,IANM,EAMJ,SANI,CAAP;AAOF;;AAED,SAAS,oBAAT,CAA8B,EAA9B,EAAkC,IAAlC,EAAwC;AACrC,UAAO,SAAS,OAAT,CAAiB,MAAjB,EAAyB;AAC7B,UAAI,cAAJ;AACA,UAAI,OAAO,cAAP,CAAsB,QAAtB,CAAJ,EAAqC;AAAA,gCAC8B,MAD9B,CAC3B,QAD2B;AAAA,aAChB,MADgB,oBAChB,MADgB;AAAA,aACR,UADQ,oBACR,UADQ;AAAA,8BAC8B,MAD9B,CACK,MADL;AAAA,aACc,MADd,kBACc,MADd;AAAA,aACsB,GADtB,kBACsB,GADtB;;AAElC,aAAI,UAAc,MAAd,8BAA6C,MAA7C,SAAuD,GAAvD,WAAgE,UAAhE,MAAJ;AACA,iBAAQ,IAAI,aAAJ,CAAkB,OAAlB,EAA2B,IAA3B,EAAiC,MAAjC,CAAR;AACA,aAAO,OAAP,SAAkB,KAAK,SAAL,CAAe,OAAO,IAAtB,CAAlB;AACF,OALD,MAKO;AACJ,iBAAQ,MAAR;AACF;AACD,UAAI,EAAJ,EAAQ;AACL,aAAI,yBAAJ;AACA,YAAG,KAAH;AACF,OAHD,MAGO;AACJ,aAAI,gBAAJ;AACA,eAAM,KAAN;AACF;AACH,IAjBD;AAkBF;;;;;;;AClTD;;;;AACA;;;;;;;;;;+eARA;;;;;;;AASA,IAAM,MAAM,qBAAM,eAAN,CAAZ;;AAEA;;;;IAGM,M;;;AACH;;;;;;AAMA,kBAAY,QAAZ,EAAsB,IAAtB,EAA4B,OAA5B,EAAqC;AAAA;;AAAA,gHAC5B,IAD4B,EACtB,OADsB;;AAElC,UAAK,UAAL,GAAkB,MAAK,uBAAL,CAA6B,QAA7B,CAAlB;AAFkC;AAGpC;;AAED;;;;;;;;;AASA;;;;;;;;;;;;4BAQQ,I,EAAwC;AAAA;;AAAA,UAAlC,WAAkC,uEAApB,EAAoB;AAAA,UAAhB,EAAgB,uEAAX,SAAW;;AAC7C,UAAI,iBAAiB,EAArB;AACA,aAAO,IAAP,CAAY,KAAK,UAAjB,EAA6B,OAA7B,CAAqC,UAAC,IAAD,EAAU;AAC5C,uBAAe,IAAf,IAAuB,OAAK,UAAL,CAAgB,IAAhB,CAAvB;AACF,OAFD;AAGA,aAAO,IAAP,CAAY,WAAZ,EAAyB,OAAzB,CAAiC,UAAC,IAAD,EAAU;AACxC,uBAAe,IAAf,IAAuB,YAAY,IAAZ,CAAvB;AACF,OAFD;;AAIA,yBAAiB,IAAjB,qBAAuC,cAAvC;AACA,aAAO,KAAK,gBAAL,cAAiC,IAAjC,EAAyC,cAAzC,EAAyD,EAAzD,CAAP;AACF;;AAED;;;;;;;;;;oCAOgB,O,EAAS,E,EAAI;AAC1B,aAAO,KAAK,OAAL,CAAa,cAAb,EAA6B,OAA7B,EAAsC,EAAtC,CAAP;AACF;;AAED;;;;;;;;;;4BAOQ,O,EAAS,E,EAAI;AAClB,aAAO,KAAK,OAAL,CAAa,MAAb,EAAqB,OAArB,EAA8B,EAA9B,CAAP;AACF;;AAED;;;;;;;;;;8BAOU,O,EAAS,E,EAAI;AACpB,aAAO,KAAK,OAAL,CAAa,QAAb,EAAuB,OAAvB,EAAgC,EAAhC,CAAP;AACF;;AAED;;;;;;;;;;6BAOS,O,EAAS,E,EAAI;AACnB,aAAO,KAAK,OAAL,CAAa,OAAb,EAAsB,OAAtB,EAA+B,EAA/B,CAAP;AACF;;;;;;AAGJ,OAAO,OAAP,GAAiB,MAAjB;;;;;;;AC9FA;;;;AACA;;;;;;;;;;+eARA;;;;;;;AASA,IAAM,MAAM,qBAAM,aAAN,CAAZ;;AAEA;;;;IAGM,I;;;AACH;;;;;;AAMA,gBAAY,MAAZ,EAAoB,IAApB,EAA0B,OAA1B,EAAmC;AAAA;;AAAA,4GAC1B,IAD0B,EACpB,OADoB;;AAEhC,UAAK,QAAL,GAAgB,MAAhB;AAFgC;AAGlC;;AAED;;;;;;;;;;4BAMQ,E,EAAI;AACT,6BAAqB,KAAK,QAA1B;AACA,aAAO,KAAK,QAAL,CAAc,KAAd,cAA+B,KAAK,QAApC,EAAgD,SAAhD,EAA2D,EAA3D,CAAP;AACF;;AAED;;;;;;;;;8BAMU,E,EAAI;AACX,8CAAsC,KAAK,QAA3C;AACA,aAAO,KAAK,gBAAL,aAAgC,KAAK,QAArC,aAAuD,SAAvD,EAAkE,EAAlE,CAAP;AACF;;AAED;;;;;;;;;;;;;;;6BAYS,O,EAAS,E,EAAI;AACnB,4BAAoB,KAAK,QAAzB;AACA,aAAO,KAAK,QAAL,CAAc,OAAd,cAAiC,KAAK,QAAtC,EAAkD,OAAlD,EAA2D,EAA3D,CAAP;AACF;;AAED;;;;;;;;;;;gCAQY,O,EAAS,E,EAAI;AACtB,uCAA+B,KAAK,QAApC;AACA,aAAO,KAAK,gBAAL,aAAgC,KAAK,QAArC,eAAyD,OAAzD,EAAkE,EAAlE,CAAP;AACF;;AAED;;;;;;;;;;kCAOc,Q,EAAU,E,EAAI;AACzB,0CAAkC,QAAlC,iBAAsD,KAAK,QAA3D;AACA,aAAO,KAAK,QAAL,CAAc,KAAd,cAA+B,KAAK,QAApC,qBAA4D,QAA5D,EAAwE,SAAxE,EAAmF,EAAnF,CAAP;AACF;;AAED;;;;;;;;;;;;;kCAUc,Q,EAAU,O,EAAS,E,EAAI;AAClC,2BAAmB,QAAnB,iBAAuC,KAAK,QAA5C;AACA,aAAO,KAAK,QAAL,CAAc,KAAd,cAA+B,KAAK,QAApC,qBAA4D,QAA5D,EAAwE,OAAxE,EAAiF,EAAjF,CAAP;AACF;;AAED;;;;;;;;;;;kCAQc,K,EAAO,I,EAAM,E,EAAI;AAC5B,+CAAuC,KAAK,QAA5C,kBAAiE,KAAjE,SAA0E,IAA1E;AACA,aAAO,KAAK,gBAAL,aAAgC,KAAK,QAArC,eAAuD,KAAvD,SAAgE,IAAhE,EAAwE,SAAxE,EAAmF,EAAnF,CAAP;AACF;;AAED;;;;;;;;;;;;;;+BAWW,K,EAAO,I,EAAM,O,EAAS,E,EAAI;AAClC,0DAAkD,KAAK,QAAvD,kBAA4E,KAA5E,SAAqF,IAArF;AACA,aAAO,KAAK,gBAAL,aAAgC,KAAK,QAArC,eAAuD,KAAvD,SAAgE,IAAhE,EAAwE,OAAxE,EAAiF,EAAjF,EAAqF,KAArF,CAAP;AACF;;AAED;;;;;;;;;;;iCAQa,K,EAAO,I,EAAM,E,EAAI;AAC3B,8CAAsC,KAAK,QAA3C,kBAAgE,KAAhE,SAAyE,IAAzE;AACA,aAAO,KAAK,gBAAL,aAAgC,KAAK,QAArC,eAAuD,KAAvD,SAAgE,IAAhE,EAAwE,SAAxE,EAAmF,EAAnF,EAAuF,QAAvF,CAAP;AACF;;AAED;;;;;;;;;+BAMW,E,EAAI;AACZ,6BAAqB,KAAK,QAA1B;AACA,aAAO,KAAK,gBAAL,aAAgC,KAAK,QAArC,EAAiD,SAAjD,EAA4D,EAA5D,EAAgE,QAAhE,CAAP;AACF;;;;;;AAGJ,OAAO,OAAP,GAAiB,IAAjB;;;;;;;ACxJA;;;;AACA;;;;;;;;;;+eARA;;;;;;;AASA,IAAM,MAAM,qBAAM,aAAN,CAAZ;;AAEA;;;;IAGM,I;;;AACH;;;;;;AAMA,iBAAY,QAAZ,EAAsB,IAAtB,EAA4B,OAA5B,EAAqC;AAAA;;AAAA,8GAC5B,IAD4B,EACtB,OADsB;;AAElC,YAAK,MAAL,GAAc,QAAd;AAFkC;AAGpC;;AAED;;;;;;;;;;qCAMe,Q,EAAU;AACtB,aAAI,KAAK,MAAT,EAAiB;AACd,mBAAO,uBACM,KAAK,MADX,SACqB,QADrB,eAEM,KAAK,MAFlB;AAKF,UAND,MAMO;AAAE;AACN,oBAAQ,QAAR;AACG,oBAAK,EAAL;AACG,yBAAO,OAAP;;AAEH,oBAAK,eAAL;AACA,oBAAK,OAAL;AACG,+BAAW,QAAX;;AAEH;AACG,oCAAgB,QAAhB;AATN;AAWF;AACH;;AAED;;;;;;;;;;gCAOU,O,EAAS,E,EAAI;AACpB,aAAI,OAAO,OAAP,KAAmB,UAAvB,EAAmC;AAChC,iBAAK,OAAL;AACA,sBAAU,EAAV;AACF;;AAED,mBAAU,KAAK,uBAAL,CAA6B,OAA7B,CAAV;;AAEA,sDAA2C,KAAK,SAAL,CAAe,OAAf,CAA3C;AACA,gBAAO,KAAK,gBAAL,CAAsB,KAAK,cAAL,CAAoB,OAApB,CAAtB,EAAoD,OAApD,EAA6D,EAA7D,CAAP;AACF;;AAED;;;;;;;;;+BAMS,E,EAAI;AACV,gBAAO,KAAK,QAAL,CAAc,KAAd,EAAqB,KAAK,cAAL,CAAoB,MAApB,CAArB,EAAkD,IAAlD,EAAwD,EAAxD,CAAP;AACF;;AAED;;;;;;;;;gCAMU,E,EAAI;AACX,gBAAO,KAAK,QAAL,CAAc,KAAd,EAAqB,KAAK,cAAL,CAAoB,OAApB,CAArB,EAAmD,IAAnD,EAAyD,EAAzD,CAAP;AACF;;AAED;;;;;;;;;uCAMiB,E,EAAI;AAClB,gBAAO,KAAK,QAAL,CAAc,KAAd,EAAqB,KAAK,cAAL,CAAoB,eAApB,CAArB,EAA2D,IAA3D,EAAiE,EAAjE,CAAP;AACF;;AAED;;;;;;;;;uCAMiB,E,EAAI;AAClB,gBAAO,KAAK,QAAL,CAAc,KAAd,EAAqB,KAAK,cAAL,CAAoB,OAApB,CAArB,EAAmD,IAAnD,EAAyD,EAAzD,CAAP;AACF;;AAED;;;;;;;;;;wCAOkB,O,EAAS,E,EAAI;AAC5B,mBAAU,WAAW,EAArB;AACA,aAAI,OAAO,OAAP,KAAmB,UAAvB,EAAmC;AAChC,iBAAK,OAAL;AACA,sBAAU,EAAV;AACF;;AAED,iBAAQ,KAAR,GAAgB,KAAK,UAAL,CAAgB,QAAQ,KAAxB,CAAhB;AACA,iBAAQ,MAAR,GAAiB,KAAK,UAAL,CAAgB,QAAQ,MAAxB,CAAjB;;AAEA,gBAAO,KAAK,QAAL,CAAc,KAAd,EAAqB,KAAK,cAAL,CAAoB,eAApB,CAArB,EAA2D,OAA3D,EAAoE,EAApE,CAAP;AACF;;AAED;;;;;;;;;iCAMW,E,EAAI;AACZ,gBAAO,KAAK,QAAL,CAAc,KAAd,EAAqB,KAAK,cAAL,CAAoB,EAApB,CAArB,EAA8C,IAA9C,EAAoD,EAApD,CAAP;AACF;;AAED;;;;;;;;;uCAMiB,E,EAAI;AAClB,aAAI,iBAAiB,KAAK,uBAAL,EAArB;AACA,gBAAO,KAAK,gBAAL,CAAsB,KAAK,cAAL,CAAoB,SAApB,CAAtB,EAAsD,cAAtD,EAAsE,EAAtE,CAAP;AACF;;AAED;;;;;;;;;gCAMU,E,EAAI;AACX,gBAAO,KAAK,QAAL,CAAc,KAAd,EAAqB,cAArB,EAAqC,IAArC,EAA2C,EAA3C,CAAP;AACF;;AAED;;;;;;;;;;6BAOO,Q,EAAU,E,EAAI;AAClB,gBAAO,KAAK,QAAL,CAAc,KAAd,uBAAwC,KAAK,MAA7C,EAAuD,IAAvD,EAA6D,EAA7D,CAAP;AACF;;AAED;;;;;;;;;;+BAOS,Q,EAAU,E,EAAI;AACpB,gBAAO,KAAK,QAAL,CAAc,QAAd,uBAA2C,KAAK,MAAhD,EAA0D,IAA1D,EAAgE,EAAhE,CAAP;AACF;;AAED;;;;;;;;;;iCAOW,O,EAAS,E,EAAI;AACrB,gBAAO,KAAK,QAAL,CAAc,MAAd,EAAsB,aAAtB,EAAqC,OAArC,EAA8C,EAA9C,CAAP;AACF;;;;;;AAGJ,OAAO,OAAP,GAAiB,IAAjB;;;ACtMA;;;ACAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;ACjLA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACpDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACnBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACzDA;AACA;AACA;AACA;AACA;AACA;;ACLA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACrFA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACpDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC/EA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACnBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACzBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;ACpBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;AC7FA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACXA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACpCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACpEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACZA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACrDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACdA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACpEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACZA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACr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lHA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;AC7vDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;ACtLA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACvMA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACpFA;AACA;AACA;AACA;AACA;AACA;;ACLA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AClMA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACrJA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;ACpLA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA","file":"generated.js","sourceRoot":"","sourcesContent":["(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require==\"function\"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error(\"Cannot find module '\"+o+\"'\");throw f.code=\"MODULE_NOT_FOUND\",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require==\"function\"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})","/**\n * @file\n * @copyright  2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license    Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n *             Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\n\n/**\n * A Gist can retrieve and modify gists.\n */\nclass Gist extends Requestable {\n   /**\n    * Create a Gist.\n    * @param {string} id - the id of the gist (not required when creating a gist)\n    * @param {Requestable.auth} [auth] - information required to authenticate to Github\n    * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n    */\n   constructor(id, auth, apiBase) {\n      super(auth, apiBase);\n      this.__id = id;\n   }\n\n   /**\n    * Fetch a gist.\n    * @see https://developer.github.com/v3/gists/#get-a-single-gist\n    * @param {Requestable.callback} [cb] - will receive the gist\n    * @return {Promise} - the Promise for the http request\n    */\n   read(cb) {\n      return this._request('GET', `/gists/${this.__id}`, null, cb);\n   }\n\n   /**\n    * Create a new gist.\n    * @see https://developer.github.com/v3/gists/#create-a-gist\n    * @param {Object} gist - the data for the new gist\n    * @param {Requestable.callback} [cb] - will receive the new gist upon creation\n    * @return {Promise} - the Promise for the http request\n    */\n   create(gist, cb) {\n      return this._request('POST', '/gists', gist, cb)\n         .then((response) => {\n            this.__id = response.data.id;\n            return response;\n         });\n   }\n\n   /**\n    * Delete a gist.\n    * @see https://developer.github.com/v3/gists/#delete-a-gist\n    * @param {Requestable.callback} [cb] - will receive true if the request succeeds\n    * @return {Promise} - the Promise for the http request\n    */\n   delete(cb) {\n      return this._request('DELETE', `/gists/${this.__id}`, null, cb);\n   }\n\n   /**\n    * Fork a gist.\n    * @see https://developer.github.com/v3/gists/#fork-a-gist\n    * @param {Requestable.callback} [cb] - the function that will receive the gist\n    * @return {Promise} - the Promise for the http request\n    */\n   fork(cb) {\n      return this._request('POST', `/gists/${this.__id}/forks`, null, cb);\n   }\n\n   /**\n    * Update a gist.\n    * @see https://developer.github.com/v3/gists/#edit-a-gist\n    * @param {Object} gist - the new data for the gist\n    * @param {Requestable.callback} [cb] - the function that receives the API result\n    * @return {Promise} - the Promise for the http request\n    */\n   update(gist, cb) {\n      return this._request('PATCH', `/gists/${this.__id}`, gist, cb);\n   }\n\n   /**\n    * Star a gist.\n    * @see https://developer.github.com/v3/gists/#star-a-gist\n    * @param {Requestable.callback} [cb] - will receive true if the request is successful\n    * @return {Promise} - the Promise for the http request\n    */\n   star(cb) {\n      return this._request('PUT', `/gists/${this.__id}/star`, null, cb);\n   }\n\n   /**\n    * Unstar a gist.\n    * @see https://developer.github.com/v3/gists/#unstar-a-gist\n    * @param {Requestable.callback} [cb] - will receive true if the request is successful\n    * @return {Promise} - the Promise for the http request\n    */\n   unstar(cb) {\n      return this._request('DELETE', `/gists/${this.__id}/star`, null, cb);\n   }\n\n   /**\n    * Check if a gist is starred by the user.\n    * @see https://developer.github.com/v3/gists/#check-if-a-gist-is-starred\n    * @param {Requestable.callback} [cb] - will receive true if the gist is starred and false if the gist is not starred\n    * @return {Promise} - the Promise for the http request\n    */\n   isStarred(cb) {\n      return this._request204or404(`/gists/${this.__id}/star`, null, cb);\n   }\n\n   /**\n    * List the gist's commits\n    * @see https://developer.github.com/v3/gists/#list-gist-commits\n    * @param {Requestable.callback} [cb] - will receive the array of commits\n    * @return {Promise} - the Promise for the http request\n    */\n   listCommits(cb) {\n      return this._requestAllPages(`/gists/${this.__id}/commits`, null, cb);\n   }\n\n   /**\n    * Fetch one of the gist's revision.\n    * @see https://developer.github.com/v3/gists/#get-a-specific-revision-of-a-gist\n    * @param {string} revision - the id of the revision\n    * @param {Requestable.callback} [cb] - will receive the revision\n    * @return {Promise} - the Promise for the http request\n    */\n   getRevision(revision, cb) {\n      return this._request('GET', `/gists/${this.__id}/${revision}`, null, cb);\n   }\n\n   /**\n    * List the gist's comments\n    * @see https://developer.github.com/v3/gists/comments/#list-comments-on-a-gist\n    * @param {Requestable.callback} [cb] - will receive the array of comments\n    * @return {Promise} - the promise for the http request\n    */\n   listComments(cb) {\n      return this._requestAllPages(`/gists/${this.__id}/comments`, null, cb);\n   }\n\n   /**\n    * Fetch one of the gist's comments\n    * @see https://developer.github.com/v3/gists/comments/#get-a-single-comment\n    * @param {number} comment - the id of the comment\n    * @param {Requestable.callback} [cb] - will receive the comment\n    * @return {Promise} - the Promise for the http request\n    */\n   getComment(comment, cb) {\n      return this._request('GET', `/gists/${this.__id}/comments/${comment}`, null, cb);\n   }\n\n   /**\n    * Comment on a gist\n    * @see https://developer.github.com/v3/gists/comments/#create-a-comment\n    * @param {string} comment - the comment to add\n    * @param {Requestable.callback} [cb] - the function that receives the API result\n    * @return {Promise} - the Promise for the http request\n    */\n   createComment(comment, cb) {\n      return this._request('POST', `/gists/${this.__id}/comments`, {body: comment}, cb);\n   }\n\n   /**\n    * Edit a comment on the gist\n    * @see https://developer.github.com/v3/gists/comments/#edit-a-comment\n    * @param {number} comment - the id of the comment\n    * @param {string} body - the new comment\n    * @param {Requestable.callback} [cb] - will receive the modified comment\n    * @return {Promise} - the promise for the http request\n    */\n   editComment(comment, body, cb) {\n      return this._request('PATCH', `/gists/${this.__id}/comments/${comment}`, {body: body}, cb);\n   }\n\n   /**\n    * Delete a comment on the gist.\n    * @see https://developer.github.com/v3/gists/comments/#delete-a-comment\n    * @param {number} comment - the id of the comment\n    * @param {Requestable.callback} [cb] - will receive true if the request succeeds\n    * @return {Promise} - the Promise for the http request\n    */\n   deleteComment(comment, cb) {\n      return this._request('DELETE', `/gists/${this.__id}/comments/${comment}`, null, cb);\n   }\n}\n\nmodule.exports = Gist;\n","/**\n * @file\n * @copyright  2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license    Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n *             Github.js is freely distributable.\n */\n/* eslint valid-jsdoc: [\"error\", {\"requireReturnDescription\": false}] */\n\nimport Gist from './Gist';\nimport User from './User';\nimport Issue from './Issue';\nimport Search from './Search';\nimport RateLimit from './RateLimit';\nimport Repository from './Repository';\nimport Organization from './Organization';\nimport Team from './Team';\nimport Markdown from './Markdown';\nimport Project from './Project';\n\n/**\n * GitHub encapsulates the functionality to create various API wrapper objects.\n */\nclass GitHub {\n   /**\n    * Create a new GitHub.\n    * @param {Requestable.auth} [auth] - the credentials to authenticate to Github. If auth is\n    *                                  not provided requests will be made unauthenticated\n    * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n    */\n   constructor(auth, apiBase = 'https://api.github.com') {\n      this.__apiBase = apiBase;\n      this.__auth = auth || {};\n   }\n\n   /**\n    * Create a new Gist wrapper\n    * @param {number} [id] - the id for the gist, leave undefined when creating a new gist\n    * @return {Gist}\n    */\n   getGist(id) {\n      return new Gist(id, this.__auth, this.__apiBase);\n   }\n\n   /**\n    * Create a new User wrapper\n    * @param {string} [user] - the name of the user to get information about\n    *                        leave undefined for the authenticated user\n    * @return {User}\n    */\n   getUser(user) {\n      return new User(user, this.__auth, this.__apiBase);\n   }\n\n   /**\n    * Create a new Organization wrapper\n    * @param {string} organization - the name of the organization\n    * @return {Organization}\n    */\n   getOrganization(organization) {\n      return new Organization(organization, this.__auth, this.__apiBase);\n   }\n\n   /**\n    * create a new Team wrapper\n    * @param {string} teamId - the name of the team\n    * @return {team}\n    */\n   getTeam(teamId) {\n      return new Team(teamId, this.__auth, this.__apiBase);\n   }\n\n   /**\n    * Create a new Repository wrapper\n    * @param {string} user - the user who owns the respository\n    * @param {string} repo - the name of the repository\n    * @return {Repository}\n    */\n   getRepo(user, repo) {\n      return new Repository(this._getFullName(user, repo), this.__auth, this.__apiBase);\n   }\n\n   /**\n    * Create a new Issue wrapper\n    * @param {string} user - the user who owns the respository\n    * @param {string} repo - the name of the repository\n    * @return {Issue}\n    */\n   getIssues(user, repo) {\n      return new Issue(this._getFullName(user, repo), this.__auth, this.__apiBase);\n   }\n\n   /**\n    * Create a new Search wrapper\n    * @param {string} query - the query to search for\n    * @return {Search}\n    */\n   search(query) {\n      return new Search(query, this.__auth, this.__apiBase);\n   }\n\n   /**\n    * Create a new RateLimit wrapper\n    * @return {RateLimit}\n    */\n   getRateLimit() {\n      return new RateLimit(this.__auth, this.__apiBase);\n   }\n\n   /**\n    * Create a new Markdown wrapper\n    * @return {Markdown}\n    */\n   getMarkdown() {\n      return new Markdown(this.__auth, this.__apiBase);\n   }\n\n   /**\n    * Create a new Project wrapper\n    * @param {string} id - the id of the project\n    * @return {Markdown}\n    */\n   getProject(id) {\n      return new Project(id, this.__auth, this.__apiBase);\n   }\n\n   /**\n    * Computes the full repository name\n    * @param {string} user - the username (or the full name)\n    * @param {string} repo - the repository name, must not be passed if `user` is the full name\n    * @return {string} the repository's full name\n    */\n   _getFullName(user, repo) {\n      let fullname = user;\n\n      if (repo) {\n         fullname = `${user}/${repo}`;\n      }\n\n      return fullname;\n   }\n}\n\nmodule.exports = GitHub;\n","/**\n * @file\n * @copyright  2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license    Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n *             Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\n\n/**\n * Issue wraps the functionality to get issues for repositories\n */\nclass Issue extends Requestable {\n   /**\n    * Create a new Issue\n    * @param {string} repository - the full name of the repository (`:user/:repo`) to get issues for\n    * @param {Requestable.auth} [auth] - information required to authenticate to Github\n    * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n    */\n   constructor(repository, auth, apiBase) {\n      super(auth, apiBase);\n      this.__repository = repository;\n   }\n\n   /**\n    * Create a new issue\n    * @see https://developer.github.com/v3/issues/#create-an-issue\n    * @param {Object} issueData - the issue to create\n    * @param {Requestable.callback} [cb] - will receive the created issue\n    * @return {Promise} - the promise for the http request\n    */\n   createIssue(issueData, cb) {\n      return this._request('POST', `/repos/${this.__repository}/issues`, issueData, cb);\n   }\n\n   /**\n    * List the issues for the repository\n    * @see https://developer.github.com/v3/issues/#list-issues-for-a-repository\n    * @param {Object} options - filtering options\n    * @param {Requestable.callback} [cb] - will receive the array of issues\n    * @return {Promise} - the promise for the http request\n    */\n   listIssues(options, cb) {\n      return this._requestAllPages(`/repos/${this.__repository}/issues`, options, cb);\n   }\n\n   /**\n    * List the events for an issue\n    * @see https://developer.github.com/v3/issues/events/#list-events-for-an-issue\n    * @param {number} issue - the issue to get events for\n    * @param {Requestable.callback} [cb] - will receive the list of events\n    * @return {Promise} - the promise for the http request\n    */\n   listIssueEvents(issue, cb) {\n      return this._request('GET', `/repos/${this.__repository}/issues/${issue}/events`, null, cb);\n   }\n\n   /**\n    * List comments on an issue\n    * @see https://developer.github.com/v3/issues/comments/#list-comments-on-an-issue\n    * @param {number} issue - the id of the issue to get comments from\n    * @param {Requestable.callback} [cb] - will receive the comments\n    * @return {Promise} - the promise for the http request\n    */\n   listIssueComments(issue, cb) {\n      return this._request('GET', `/repos/${this.__repository}/issues/${issue}/comments`, null, cb);\n   }\n\n   /**\n    * Get a single comment on an issue\n    * @see https://developer.github.com/v3/issues/comments/#get-a-single-comment\n    * @param {number} id - the comment id to get\n    * @param {Requestable.callback} [cb] - will receive the comment\n    * @return {Promise} - the promise for the http request\n    */\n   getIssueComment(id, cb) {\n      return this._request('GET', `/repos/${this.__repository}/issues/comments/${id}`, null, cb);\n   }\n\n   /**\n    * Comment on an issue\n    * @see https://developer.github.com/v3/issues/comments/#create-a-comment\n    * @param {number} issue - the id of the issue to comment on\n    * @param {string} comment - the comment to add\n    * @param {Requestable.callback} [cb] - will receive the created comment\n    * @return {Promise} - the promise for the http request\n    */\n   createIssueComment(issue, comment, cb) {\n      return this._request('POST', `/repos/${this.__repository}/issues/${issue}/comments`, {body: comment}, cb);\n   }\n\n   /**\n    * Edit a comment on an issue\n    * @see https://developer.github.com/v3/issues/comments/#edit-a-comment\n    * @param {number} id - the comment id to edit\n    * @param {string} comment - the comment to edit\n    * @param {Requestable.callback} [cb] - will receive the edited comment\n    * @return {Promise} - the promise for the http request\n    */\n   editIssueComment(id, comment, cb) {\n      return this._request('PATCH', `/repos/${this.__repository}/issues/comments/${id}`, {body: comment}, cb);\n   }\n\n   /**\n    * Delete a comment on an issue\n    * @see https://developer.github.com/v3/issues/comments/#delete-a-comment\n    * @param {number} id - the comment id to delete\n    * @param {Requestable.callback} [cb] - will receive true if the request is successful\n    * @return {Promise} - the promise for the http request\n    */\n   deleteIssueComment(id, cb) {\n      return this._request('DELETE', `/repos/${this.__repository}/issues/comments/${id}`, null, cb);\n   }\n\n   /**\n    * Edit an issue\n    * @see https://developer.github.com/v3/issues/#edit-an-issue\n    * @param {number} issue - the issue number to edit\n    * @param {Object} issueData - the new issue data\n    * @param {Requestable.callback} [cb] - will receive the modified issue\n    * @return {Promise} - the promise for the http request\n    */\n   editIssue(issue, issueData, cb) {\n      return this._request('PATCH', `/repos/${this.__repository}/issues/${issue}`, issueData, cb);\n   }\n\n   /**\n    * Get a particular issue\n    * @see https://developer.github.com/v3/issues/#get-a-single-issue\n    * @param {number} issue - the issue number to fetch\n    * @param {Requestable.callback} [cb] - will receive the issue\n    * @return {Promise} - the promise for the http request\n    */\n   getIssue(issue, cb) {\n      return this._request('GET', `/repos/${this.__repository}/issues/${issue}`, null, cb);\n   }\n\n   /**\n    * List the milestones for the repository\n    * @see https://developer.github.com/v3/issues/milestones/#list-milestones-for-a-repository\n    * @param {Object} options - filtering options\n    * @param {Requestable.callback} [cb] - will receive the array of milestones\n    * @return {Promise} - the promise for the http request\n    */\n   listMilestones(options, cb) {\n      return this._request('GET', `/repos/${this.__repository}/milestones`, options, cb);\n   }\n\n   /**\n    * Get a milestone\n    * @see https://developer.github.com/v3/issues/milestones/#get-a-single-milestone\n    * @param {string} milestone - the id of the milestone to fetch\n    * @param {Requestable.callback} [cb] - will receive the milestone\n    * @return {Promise} - the promise for the http request\n    */\n   getMilestone(milestone, cb) {\n      return this._request('GET', `/repos/${this.__repository}/milestones/${milestone}`, null, cb);\n   }\n\n   /**\n    * Create a new milestone\n    * @see https://developer.github.com/v3/issues/milestones/#create-a-milestone\n    * @param {Object} milestoneData - the milestone definition\n    * @param {Requestable.callback} [cb] - will receive the milestone\n    * @return {Promise} - the promise for the http request\n    */\n   createMilestone(milestoneData, cb) {\n      return this._request('POST', `/repos/${this.__repository}/milestones`, milestoneData, cb);\n   }\n\n   /**\n    * Edit a milestone\n    * @see https://developer.github.com/v3/issues/milestones/#update-a-milestone\n    * @param {string} milestone - the id of the milestone to edit\n    * @param {Object} milestoneData - the updates to make to the milestone\n    * @param {Requestable.callback} [cb] - will receive the updated milestone\n    * @return {Promise} - the promise for the http request\n    */\n   editMilestone(milestone, milestoneData, cb) {\n      return this._request('PATCH', `/repos/${this.__repository}/milestones/${milestone}`, milestoneData, cb);\n   }\n\n   /**\n    * Delete a milestone (this is distinct from closing a milestone)\n    * @see https://developer.github.com/v3/issues/milestones/#delete-a-milestone\n    * @param {string} milestone - the id of the milestone to delete\n    * @param {Requestable.callback} [cb] - will receive the status\n    * @return {Promise} - the promise for the http request\n    */\n   deleteMilestone(milestone, cb) {\n      return this._request('DELETE', `/repos/${this.__repository}/milestones/${milestone}`, null, cb);\n   }\n\n   /**\n    * Create a new label\n    * @see https://developer.github.com/v3/issues/labels/#create-a-label\n    * @param {Object} labelData - the label definition\n    * @param {Requestable.callback} [cb] - will receive the object representing the label\n    * @return {Promise} - the promise for the http request\n    */\n   createLabel(labelData, cb) {\n      return this._request('POST', `/repos/${this.__repository}/labels`, labelData, cb);\n   }\n\n  /**\n   * List the labels for the repository\n   * @see https://developer.github.com/v3/issues/labels/#list-all-labels-for-this-repository\n   * @param {Object} options - filtering options\n   * @param {Requestable.callback} [cb] - will receive the array of labels\n   * @return {Promise} - the promise for the http request\n   */\n   listLabels(options, cb) {\n      return this._request('GET', `/repos/${this.__repository}/labels`, options, cb);\n   }\n\n  /**\n   * Get a label\n   * @see https://developer.github.com/v3/issues/labels/#get-a-single-label\n   * @param {string} label - the name of the label to fetch\n   * @param {Requestable.callback} [cb] - will receive the label\n   * @return {Promise} - the promise for the http request\n   */\n   getLabel(label, cb) {\n      return this._request('GET', `/repos/${this.__repository}/labels/${label}`, null, cb);\n   }\n\n  /**\n   * Edit a label\n   * @see https://developer.github.com/v3/issues/labels/#update-a-label\n   * @param {string} label - the name of the label to edit\n   * @param {Object} labelData - the updates to make to the label\n   * @param {Requestable.callback} [cb] - will receive the updated label\n   * @return {Promise} - the promise for the http request\n   */\n   editLabel(label, labelData, cb) {\n      return this._request('PATCH', `/repos/${this.__repository}/labels/${label}`, labelData, cb);\n   }\n\n  /**\n   * Delete a label\n   * @see https://developer.github.com/v3/issues/labels/#delete-a-label\n   * @param {string} label - the name of the label to delete\n   * @param {Requestable.callback} [cb] - will receive the status\n   * @return {Promise} - the promise for the http request\n   */\n   deleteLabel(label, cb) {\n      return this._request('DELETE', `/repos/${this.__repository}/labels/${label}`, null, cb);\n   }\n}\n\nmodule.exports = Issue;\n","/**\n * @file\n * @copyright  2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license    Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n *             Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\n\n/**\n * Renders html from Markdown text\n */\nclass Markdown extends Requestable {\n   /**\n    * construct a Markdown\n    * @param {Requestable.auth} auth - the credentials to authenticate to GitHub\n    * @param {string} [apiBase] - the base Github API URL\n    * @return {Promise} - the promise for the http request\n    */\n   constructor(auth, apiBase) {\n      super(auth, apiBase);\n   }\n\n   /**\n    * Render html from Markdown text.\n    * @see https://developer.github.com/v3/markdown/#render-an-arbitrary-markdown-document\n    * @param {Object} options - conversion options\n    * @param {string} [options.text] - the markdown text to convert\n    * @param {string} [options.mode=markdown] - can be either `markdown` or `gfm`\n    * @param {string} [options.context] - repository name if mode is gfm\n    * @param {Requestable.callback} [cb] - will receive the converted html\n    * @return {Promise} - the promise for the http request\n    */\n   render(options, cb) {\n      return this._request('POST', '/markdown', options, cb);\n   }\n}\n\nmodule.exports = Markdown;\n","/**\n * @file\n * @copyright  2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license    Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n *             Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\n\n/**\n * Organization encapsulates the functionality to create repositories in organizations\n */\nclass Organization extends Requestable {\n   /**\n    * Create a new Organization\n    * @param {string} organization - the name of the organization\n    * @param {Requestable.auth} [auth] - information required to authenticate to Github\n    * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n    */\n   constructor(organization, auth, apiBase) {\n      super(auth, apiBase);\n      this.__name = organization;\n   }\n\n   /**\n    * Create a repository in an organization\n    * @see https://developer.github.com/v3/repos/#create\n    * @param {Object} options - the repository definition\n    * @param {Requestable.callback} [cb] - will receive the created repository\n    * @return {Promise} - the promise for the http request\n    */\n   createRepo(options, cb) {\n      return this._request('POST', `/orgs/${this.__name}/repos`, options, cb);\n   }\n\n   /**\n    * List the repositories in an organization\n    * @see https://developer.github.com/v3/repos/#list-organization-repositories\n    * @param {Requestable.callback} [cb] - will receive the list of repositories\n    * @return {Promise} - the promise for the http request\n    */\n   getRepos(cb) {\n      let requestOptions = this._getOptionsWithDefaults({direction: 'desc'});\n\n      return this._requestAllPages(`/orgs/${this.__name}/repos`, requestOptions, cb);\n   }\n\n   /**\n    * Query if the user is a member or not\n    * @param {string} username - the user in question\n    * @param {Requestable.callback} [cb] - will receive true if the user is a member\n    * @return {Promise} - the promise for the http request\n    */\n   isMember(username, cb) {\n      return this._request204or404(`/orgs/${this.__name}/members/${username}`, null, cb);\n   }\n\n   /**\n    * List the users who are members of the company\n    * @see https://developer.github.com/v3/orgs/members/#members-list\n    * @param {object} options - filtering options\n    * @param {string} [options.filter=all] - can be either `2fa_disabled` or `all`\n    * @param {string} [options.role=all] - can be one of: `all`, `admin`, or `member`\n    * @param {Requestable.callback} [cb] - will receive the list of users\n    * @return {Promise} - the promise for the http request\n    */\n   listMembers(options, cb) {\n      return this._request('GET', `/orgs/${this.__name}/members`, options, cb);\n   }\n\n   /**\n    * List the Teams in the Organization\n    * @see https://developer.github.com/v3/orgs/teams/#list-teams\n    * @param {Requestable.callback} [cb] - will receive the list of teams\n    * @return {Promise} - the promise for the http request\n    */\n   getTeams(cb) {\n      return this._requestAllPages(`/orgs/${this.__name}/teams`, undefined, cb);\n   }\n\n   /**\n    * Create a team\n    * @see https://developer.github.com/v3/orgs/teams/#create-team\n    * @param {object} options - Team creation parameters\n    * @param {string} options.name - The name of the team\n    * @param {string} [options.description] - Team description\n    * @param {string} [options.repo_names] - Repos to add the team to\n    * @param {string} [options.privacy=secret] - The level of privacy the team should have. Can be either one\n    * of: `secret`, or `closed`\n    * @param {Requestable.callback} [cb] - will receive the created team\n    * @return {Promise} - the promise for the http request\n    */\n   createTeam(options, cb) {\n      return this._request('POST', `/orgs/${this.__name}/teams`, options, cb);\n   }\n\n   /**\n    * Get information about all projects\n    * @see https://developer.github.com/v3/projects/#list-organization-projects\n    * @param {Requestable.callback} [cb] - will receive the list of projects\n    * @return {Promise} - the promise for the http request\n    */\n   listProjects(cb) {\n      return this._requestAllPages(`/orgs/${this.__name}/projects`, {AcceptHeader: 'inertia-preview'}, cb);\n   }\n\n   /**\n    * Create a new project\n    * @see https://developer.github.com/v3/repos/projects/#create-a-project\n    * @param {Object} options - the description of the project\n    * @param {Requestable.callback} cb - will receive the newly created project\n    * @return {Promise} - the promise for the http request\n    */\n   createProject(options, cb) {\n      options = options || {};\n      options.AcceptHeader = 'inertia-preview';\n      return this._request('POST', `/orgs/${this.__name}/projects`, options, cb);\n   }\n}\n\nmodule.exports = Organization;\n","/**\n * @file\n * @copyright  2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license    Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n *             Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\n\n/**\n * Project encapsulates the functionality to create, query, and modify cards and columns.\n */\nclass Project extends Requestable {\n   /**\n    * Create a Project.\n    * @param {string} id - the id of the project\n    * @param {Requestable.auth} [auth] - information required to authenticate to Github\n    * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n    */\n   constructor(id, auth, apiBase) {\n      super(auth, apiBase, 'inertia-preview');\n      this.__id = id;\n   }\n\n   /**\n    * Get information about a project\n    * @see https://developer.github.com/v3/projects/#get-a-project\n    * @param {Requestable.callback} cb - will receive the project information\n    * @return {Promise} - the promise for the http request\n    */\n   getProject(cb) {\n      return this._request('GET', `/projects/${this.__id}`, null, cb);\n   }\n\n   /**\n    * Edit a project\n    * @see https://developer.github.com/v3/projects/#update-a-project\n    * @param {Object} options - the description of the project\n    * @param {Requestable.callback} cb - will receive the modified project\n    * @return {Promise} - the promise for the http request\n    */\n   updateProject(options, cb) {\n      return this._request('PATCH', `/projects/${this.__id}`, options, cb);\n   }\n\n   /**\n    * Delete a project\n    * @see https://developer.github.com/v3/projects/#delete-a-project\n    * @param {Requestable.callback} cb - will receive true if the operation is successful\n    * @return {Promise} - the promise for the http request\n    */\n   deleteProject(cb) {\n      return this._request('DELETE', `/projects/${this.__id}`, null, cb);\n   }\n\n   /**\n    * Get information about all columns of a project\n    * @see https://developer.github.com/v3/projects/columns/#list-project-columns\n    * @param {Requestable.callback} [cb] - will receive the list of columns\n    * @return {Promise} - the promise for the http request\n    */\n   listProjectColumns(cb) {\n      return this._requestAllPages(`/projects/${this.__id}/columns`, null, cb);\n   }\n\n   /**\n    * Get information about a column\n    * @see https://developer.github.com/v3/projects/columns/#get-a-project-column\n    * @param {string} colId - the id of the column\n    * @param {Requestable.callback} cb - will receive the column information\n    * @return {Promise} - the promise for the http request\n    */\n   getProjectColumn(colId, cb) {\n      return this._request('GET', `/projects/columns/${colId}`, null, cb);\n   }\n\n   /**\n    * Create a new column\n    * @see https://developer.github.com/v3/projects/columns/#create-a-project-column\n    * @param {Object} options - the description of the column\n    * @param {Requestable.callback} cb - will receive the newly created column\n    * @return {Promise} - the promise for the http request\n    */\n   createProjectColumn(options, cb) {\n      return this._request('POST', `/projects/${this.__id}/columns`, options, cb);\n   }\n\n   /**\n    * Edit a column\n    * @see https://developer.github.com/v3/projects/columns/#update-a-project-column\n    * @param {string} colId - the column id\n    * @param {Object} options - the description of the column\n    * @param {Requestable.callback} cb - will receive the modified column\n    * @return {Promise} - the promise for the http request\n    */\n   updateProjectColumn(colId, options, cb) {\n      return this._request('PATCH', `/projects/columns/${colId}`, options, cb);\n   }\n\n   /**\n    * Delete a column\n    * @see https://developer.github.com/v3/projects/columns/#delete-a-project-column\n    * @param {string} colId - the column to be deleted\n    * @param {Requestable.callback} cb - will receive true if the operation is successful\n    * @return {Promise} - the promise for the http request\n    */\n   deleteProjectColumn(colId, cb) {\n      return this._request('DELETE', `/projects/columns/${colId}`, null, cb);\n   }\n\n   /**\n    * Move a column\n    * @see https://developer.github.com/v3/projects/columns/#move-a-project-column\n    * @param {string} colId - the column to be moved\n    * @param {string} position - can be one of first, last, or after:<column-id>,\n    * where <column-id> is the id value of a column in the same project.\n    * @param {Requestable.callback} cb - will receive true if the operation is successful\n    * @return {Promise} - the promise for the http request\n    */\n   moveProjectColumn(colId, position, cb) {\n      return this._request(\n         'POST',\n         `/projects/columns/${colId}/moves`,\n         {position: position},\n         cb\n      );\n   }\n\n  /**\n   * Get information about all cards of a project\n   * @see https://developer.github.com/v3/projects/cards/#list-project-cards\n   * @param {Requestable.callback} [cb] - will receive the list of cards\n   * @return {Promise} - the promise for the http request\n   */\n   listProjectCards(cb) {\n      return this.listProjectColumns()\n        .then(({data}) => {\n           return Promise.all(data.map((column) => {\n              return this._requestAllPages(`/projects/columns/${column.id}/cards`, null);\n           }));\n        }).then((cardsInColumns) => {\n           const cards = cardsInColumns.reduce((prev, {data}) => {\n              prev.push(...data);\n              return prev;\n           }, []);\n           if (cb) {\n              cb(null, cards);\n           }\n           return cards;\n        }).catch((err) => {\n           if (cb) {\n              cb(err);\n              return;\n           }\n           throw err;\n        });\n   }\n\n   /**\n   * Get information about all cards of a column\n   * @see https://developer.github.com/v3/projects/cards/#list-project-cards\n   * @param {string} colId - the id of the column\n   * @param {Requestable.callback} [cb] - will receive the list of cards\n   * @return {Promise} - the promise for the http request\n   */\n   listColumnCards(colId, cb) {\n      return this._requestAllPages(`/projects/columns/${colId}/cards`, null, cb);\n   }\n\n   /**\n   * Get information about a card\n   * @see https://developer.github.com/v3/projects/cards/#get-a-project-card\n   * @param {string} cardId - the id of the card\n   * @param {Requestable.callback} cb - will receive the card information\n   * @return {Promise} - the promise for the http request\n   */\n   getProjectCard(cardId, cb) {\n      return this._request('GET', `/projects/columns/cards/${cardId}`, null, cb);\n   }\n\n   /**\n   * Create a new card\n   * @see https://developer.github.com/v3/projects/cards/#create-a-project-card\n   * @param {string} colId - the column id\n   * @param {Object} options - the description of the card\n   * @param {Requestable.callback} cb - will receive the newly created card\n   * @return {Promise} - the promise for the http request\n   */\n   createProjectCard(colId, options, cb) {\n      return this._request('POST', `/projects/columns/${colId}/cards`, options, cb);\n   }\n\n   /**\n   * Edit a card\n   * @see https://developer.github.com/v3/projects/cards/#update-a-project-card\n   * @param {string} cardId - the card id\n   * @param {Object} options - the description of the card\n   * @param {Requestable.callback} cb - will receive the modified card\n   * @return {Promise} - the promise for the http request\n   */\n   updateProjectCard(cardId, options, cb) {\n      return this._request('PATCH', `/projects/columns/cards/${cardId}`, options, cb);\n   }\n\n   /**\n   * Delete a card\n   * @see https://developer.github.com/v3/projects/cards/#delete-a-project-card\n   * @param {string} cardId - the card to be deleted\n   * @param {Requestable.callback} cb - will receive true if the operation is successful\n   * @return {Promise} - the promise for the http request\n   */\n   deleteProjectCard(cardId, cb) {\n      return this._request('DELETE', `/projects/columns/cards/${cardId}`, null, cb);\n   }\n\n   /**\n   * Move a card\n   * @see https://developer.github.com/v3/projects/cards/#move-a-project-card\n   * @param {string} cardId - the card to be moved\n   * @param {string} position - can be one of top, bottom, or after:<card-id>,\n   * where <card-id> is the id value of a card in the same project.\n   * @param {string} colId - the id value of a column in the same project.\n   * @param {Requestable.callback} cb - will receive true if the operation is successful\n   * @return {Promise} - the promise for the http request\n   */\n   moveProjectCard(cardId, position, colId, cb) {\n      return this._request(\n         'POST',\n         `/projects/columns/cards/${cardId}/moves`,\n         {position: position, column_id: colId}, // eslint-disable-line camelcase\n         cb\n      );\n   }\n}\n\nmodule.exports = Project;\n","/**\n * @file\n * @copyright  2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license    Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n *             Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\n\n/**\n * RateLimit allows users to query their rate-limit status\n */\nclass RateLimit extends Requestable {\n   /**\n    * construct a RateLimit\n    * @param {Requestable.auth} auth - the credentials to authenticate to GitHub\n    * @param {string} [apiBase] - the base Github API URL\n    * @return {Promise} - the promise for the http request\n    */\n   constructor(auth, apiBase) {\n      super(auth, apiBase);\n   }\n\n   /**\n    * Query the current rate limit\n    * @see https://developer.github.com/v3/rate_limit/\n    * @param {Requestable.callback} [cb] - will receive the rate-limit data\n    * @return {Promise} - the promise for the http request\n    */\n   getRateLimit(cb) {\n      return this._request('GET', '/rate_limit', null, cb);\n   }\n}\n\nmodule.exports = RateLimit;\n","/**\n * @file\n * @copyright  2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license    Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n *             Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\nimport Utf8 from 'utf8';\nimport {\n   Base64,\n} from 'js-base64';\nimport debug from 'debug';\nconst log = debug('github:repository');\n\n/**\n * Respository encapsulates the functionality to create, query, and modify files.\n */\nclass Repository extends Requestable {\n   /**\n    * Create a Repository.\n    * @param {string} fullname - the full name of the repository\n    * @param {Requestable.auth} [auth] - information required to authenticate to Github\n    * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n    */\n   constructor(fullname, auth, apiBase) {\n      super(auth, apiBase);\n      this.__fullname = fullname;\n      this.__currentTree = {\n         branch: null,\n         sha: null,\n      };\n   }\n\n   /**\n    * Get a reference\n    * @see https://developer.github.com/v3/git/refs/#get-a-reference\n    * @param {string} ref - the reference to get\n    * @param {Requestable.callback} [cb] - will receive the reference's refSpec or a list of refSpecs that match `ref`\n    * @return {Promise} - the promise for the http request\n    */\n   getRef(ref, cb) {\n      return this._request('GET', `/repos/${this.__fullname}/git/refs/${ref}`, null, cb);\n   }\n\n   /**\n    * Create a reference\n    * @see https://developer.github.com/v3/git/refs/#create-a-reference\n    * @param {Object} options - the object describing the ref\n    * @param {Requestable.callback} [cb] - will receive the ref\n    * @return {Promise} - the promise for the http request\n    */\n   createRef(options, cb) {\n      return this._request('POST', `/repos/${this.__fullname}/git/refs`, options, cb);\n   }\n\n   /**\n    * Delete a reference\n    * @see https://developer.github.com/v3/git/refs/#delete-a-reference\n    * @param {string} ref - the name of the ref to delte\n    * @param {Requestable.callback} [cb] - will receive true if the request is successful\n    * @return {Promise} - the promise for the http request\n    */\n   deleteRef(ref, cb) {\n      return this._request('DELETE', `/repos/${this.__fullname}/git/refs/${ref}`, null, cb);\n   }\n\n   /**\n    * Delete a repository\n    * @see https://developer.github.com/v3/repos/#delete-a-repository\n    * @param {Requestable.callback} [cb] - will receive true if the request is successful\n    * @return {Promise} - the promise for the http request\n    */\n   deleteRepo(cb) {\n      return this._request('DELETE', `/repos/${this.__fullname}`, null, cb);\n   }\n\n   /**\n    * List the tags on a repository\n    * @see https://developer.github.com/v3/repos/#list-tags\n    * @param {Requestable.callback} [cb] - will receive the tag data\n    * @return {Promise} - the promise for the http request\n    */\n   listTags(cb) {\n      return this._request('GET', `/repos/${this.__fullname}/tags`, null, cb);\n   }\n\n   /**\n    * List the open pull requests on the repository\n    * @see https://developer.github.com/v3/pulls/#list-pull-requests\n    * @param {Object} options - options to filter the search\n    * @param {Requestable.callback} [cb] - will receive the list of PRs\n    * @return {Promise} - the promise for the http request\n    */\n   listPullRequests(options, cb) {\n      options = options || {};\n      return this._request('GET', `/repos/${this.__fullname}/pulls`, options, cb);\n   }\n\n   /**\n    * Get information about a specific pull request\n    * @see https://developer.github.com/v3/pulls/#get-a-single-pull-request\n    * @param {number} number - the PR you wish to fetch\n    * @param {Requestable.callback} [cb] - will receive the PR from the API\n    * @return {Promise} - the promise for the http request\n    */\n   getPullRequest(number, cb) {\n      return this._request('GET', `/repos/${this.__fullname}/pulls/${number}`, null, cb);\n   }\n\n   /**\n    * List the files of a specific pull request\n    * @see https://developer.github.com/v3/pulls/#list-pull-requests-files\n    * @param {number|string} number - the PR you wish to fetch\n    * @param {Requestable.callback} [cb] - will receive the list of files from the API\n    * @return {Promise} - the promise for the http request\n    */\n   listPullRequestFiles(number, cb) {\n      return this._request('GET', `/repos/${this.__fullname}/pulls/${number}/files`, null, cb);\n   }\n\n   /**\n    * Compare two branches/commits/repositories\n    * @see https://developer.github.com/v3/repos/commits/#compare-two-commits\n    * @param {string} base - the base commit\n    * @param {string} head - the head commit\n    * @param {Requestable.callback} cb - will receive the comparison\n    * @return {Promise} - the promise for the http request\n    */\n   compareBranches(base, head, cb) {\n      return this._request('GET', `/repos/${this.__fullname}/compare/${base}...${head}`, null, cb);\n   }\n\n   /**\n    * List all the branches for the repository\n    * @see https://developer.github.com/v3/repos/#list-branches\n    * @param {Requestable.callback} cb - will receive the list of branches\n    * @return {Promise} - the promise for the http request\n    */\n   listBranches(cb) {\n      return this._request('GET', `/repos/${this.__fullname}/branches`, null, cb);\n   }\n\n   /**\n    * Get a raw blob from the repository\n    * @see https://developer.github.com/v3/git/blobs/#get-a-blob\n    * @param {string} sha - the sha of the blob to fetch\n    * @param {Requestable.callback} cb - will receive the blob from the API\n    * @return {Promise} - the promise for the http request\n    */\n   getBlob(sha, cb) {\n      return this._request('GET', `/repos/${this.__fullname}/git/blobs/${sha}`, null, cb, 'raw');\n   }\n\n   /**\n    * Get a single branch\n    * @see https://developer.github.com/v3/repos/branches/#get-branch\n    * @param {string} branch - the name of the branch to fetch\n    * @param {Requestable.callback} cb - will receive the branch from the API\n    * @returns {Promise} - the promise for the http request\n    */\n   getBranch(branch, cb) {\n      return this._request('GET', `/repos/${this.__fullname}/branches/${branch}`, null, cb);\n   }\n\n   /**\n    * Get a commit from the repository\n    * @see https://developer.github.com/v3/repos/commits/#get-a-single-commit\n    * @param {string} sha - the sha for the commit to fetch\n    * @param {Requestable.callback} cb - will receive the commit data\n    * @return {Promise} - the promise for the http request\n    */\n   getCommit(sha, cb) {\n      return this._request('GET', `/repos/${this.__fullname}/git/commits/${sha}`, null, cb);\n   }\n\n   /**\n    * List the commits on a repository, optionally filtering by path, author or time range\n    * @see https://developer.github.com/v3/repos/commits/#list-commits-on-a-repository\n    * @param {Object} [options] - the filtering options for commits\n    * @param {string} [options.sha] - the SHA or branch to start from\n    * @param {string} [options.path] - the path to search on\n    * @param {string} [options.author] - the commit author\n    * @param {(Date|string)} [options.since] - only commits after this date will be returned\n    * @param {(Date|string)} [options.until] - only commits before this date will be returned\n    * @param {Requestable.callback} cb - will receive the list of commits found matching the criteria\n    * @return {Promise} - the promise for the http request\n    */\n   listCommits(options, cb) {\n      options = options || {};\n\n      options.since = this._dateToISO(options.since);\n      options.until = this._dateToISO(options.until);\n\n      return this._request('GET', `/repos/${this.__fullname}/commits`, options, cb);\n   }\n\n    /**\n     * Gets a single commit information for a repository\n     * @see https://developer.github.com/v3/repos/commits/#get-a-single-commit\n     * @param {string} ref - the reference for the commit-ish\n     * @param {Requestable.callback} cb - will receive the commit information\n     * @return {Promise} - the promise for the http request\n     */\n   getSingleCommit(ref, cb) {\n      ref = ref || '';\n      return this._request('GET', `/repos/${this.__fullname}/commits/${ref}`, null, cb);\n   }\n\n   /**\n    * Get tha sha for a particular object in the repository. This is a convenience function\n    * @see https://developer.github.com/v3/repos/contents/#get-contents\n    * @param {string} [branch] - the branch to look in, or the repository's default branch if omitted\n    * @param {string} path - the path of the file or directory\n    * @param {Requestable.callback} cb - will receive a description of the requested object, including a `SHA` property\n    * @return {Promise} - the promise for the http request\n    */\n   getSha(branch, path, cb) {\n      branch = branch ? `?ref=${branch}` : '';\n      return this._request('GET', `/repos/${this.__fullname}/contents/${path}${branch}`, null, cb);\n   }\n\n   /**\n    * List the commit statuses for a particular sha, branch, or tag\n    * @see https://developer.github.com/v3/repos/statuses/#list-statuses-for-a-specific-ref\n    * @param {string} sha - the sha, branch, or tag to get statuses for\n    * @param {Requestable.callback} cb - will receive the list of statuses\n    * @return {Promise} - the promise for the http request\n    */\n   listStatuses(sha, cb) {\n      return this._request('GET', `/repos/${this.__fullname}/commits/${sha}/statuses`, null, cb);\n   }\n\n   /**\n    * Get a description of a git tree\n    * @see https://developer.github.com/v3/git/trees/#get-a-tree\n    * @param {string} treeSHA - the SHA of the tree to fetch\n    * @param {Requestable.callback} cb - will receive the callback data\n    * @return {Promise} - the promise for the http request\n    */\n   getTree(treeSHA, cb) {\n      return this._request('GET', `/repos/${this.__fullname}/git/trees/${treeSHA}`, null, cb);\n   }\n\n   /**\n    * Create a blob\n    * @see https://developer.github.com/v3/git/blobs/#create-a-blob\n    * @param {(string|Buffer|Blob)} content - the content to add to the repository\n    * @param {Requestable.callback} cb - will receive the details of the created blob\n    * @return {Promise} - the promise for the http request\n    */\n   createBlob(content, cb) {\n      let postBody = this._getContentObject(content);\n\n      log('sending content', postBody);\n      return this._request('POST', `/repos/${this.__fullname}/git/blobs`, postBody, cb);\n   }\n\n   /**\n    * Get the object that represents the provided content\n    * @param {string|Buffer|Blob} content - the content to send to the server\n    * @return {Object} the representation of `content` for the GitHub API\n    */\n   _getContentObject(content) {\n      if (typeof content === 'string') {\n         log('contet is a string');\n         return {\n            content: Utf8.encode(content),\n            encoding: 'utf-8',\n         };\n\n      } else if (typeof Buffer !== 'undefined' && content instanceof Buffer) {\n         log('We appear to be in Node');\n         return {\n            content: content.toString('base64'),\n            encoding: 'base64',\n         };\n\n      } else if (typeof Blob !== 'undefined' && content instanceof Blob) {\n         log('We appear to be in the browser');\n         return {\n            content: Base64.encode(content),\n            encoding: 'base64',\n         };\n\n      } else { // eslint-disable-line\n         log(`Not sure what this content is: ${typeof content}, ${JSON.stringify(content)}`);\n         throw new Error('Unknown content passed to postBlob. Must be string or Buffer (node) or Blob (web)');\n      }\n   }\n\n   /**\n    * Update a tree in Git\n    * @see https://developer.github.com/v3/git/trees/#create-a-tree\n    * @param {string} baseTreeSHA - the SHA of the tree to update\n    * @param {string} path - the path for the new file\n    * @param {string} blobSHA - the SHA for the blob to put at `path`\n    * @param {Requestable.callback} cb - will receive the new tree that is created\n    * @return {Promise} - the promise for the http request\n    * @deprecated use {@link Repository#createTree} instead\n    */\n   updateTree(baseTreeSHA, path, blobSHA, cb) {\n      let newTree = {\n         base_tree: baseTreeSHA, // eslint-disable-line\n         tree: [{\n            path: path,\n            sha: blobSHA,\n            mode: '100644',\n            type: 'blob',\n         }],\n      };\n\n      return this._request('POST', `/repos/${this.__fullname}/git/trees`, newTree, cb);\n   }\n\n   /**\n    * Create a new tree in git\n    * @see https://developer.github.com/v3/git/trees/#create-a-tree\n    * @param {Object} tree - the tree to create\n    * @param {string} baseSHA - the root sha of the tree\n    * @param {Requestable.callback} cb - will receive the new tree that is created\n    * @return {Promise} - the promise for the http request\n    */\n   createTree(tree, baseSHA, cb) {\n      return this._request('POST', `/repos/${this.__fullname}/git/trees`, {\n         tree,\n         base_tree: baseSHA, // eslint-disable-line camelcase\n      }, cb);\n   }\n\n   /**\n    * Add a commit to the repository\n    * @see https://developer.github.com/v3/git/commits/#create-a-commit\n    * @param {string} parent - the SHA of the parent commit\n    * @param {string} tree - the SHA of the tree for this commit\n    * @param {string} message - the commit message\n    * @param {Requestable.callback} cb - will receive the commit that is created\n    * @return {Promise} - the promise for the http request\n    */\n   commit(parent, tree, message, cb) {\n      let data = {\n         message,\n         tree,\n         parents: [parent],\n      };\n\n      return this._request('POST', `/repos/${this.__fullname}/git/commits`, data, cb)\n         .then((response) => {\n            this.__currentTree.sha = response.data.sha; // Update latest commit\n            return response;\n         });\n   }\n\n   /**\n    * Update a ref\n    * @see https://developer.github.com/v3/git/refs/#update-a-reference\n    * @param {string} ref - the ref to update\n    * @param {string} commitSHA - the SHA to point the reference to\n    * @param {boolean} force - indicates whether to force or ensure a fast-forward update\n    * @param {Requestable.callback} cb - will receive the updated ref back\n    * @return {Promise} - the promise for the http request\n    */\n   updateHead(ref, commitSHA, force, cb) {\n      return this._request('PATCH', `/repos/${this.__fullname}/git/refs/${ref}`, {\n         sha: commitSHA,\n         force: force,\n      }, cb);\n   }\n\n   /**\n    * Update commit status\n    * @see https://developer.github.com/v3/repos/statuses/\n    * @param {string} commitSHA - the SHA of the commit that should be updated\n    * @param {object} options - Commit status parameters\n    * @param {string} options.state - The state of the status. Can be one of: pending, success, error, or failure.\n    * @param {string} [options.target_url] - The target URL to associate with this status.\n    * @param {string} [options.description] - A short description of the status.\n    * @param {string} [options.context] - A string label to differentiate this status among CI systems.\n    * @param {Requestable.callback} cb - will receive the updated commit back\n    * @return {Promise} - the promise for the http request\n    */\n   updateStatus(commitSHA, options, cb) {\n      return this._request('POST', `/repos/${this.__fullname}/statuses/${commitSHA}`, options, cb);\n   }\n\n   /**\n    * Update repository information\n    * @see https://developer.github.com/v3/repos/#edit\n    * @param {object} options - New parameters that will be set to the repository\n    * @param {string} options.name - Name of the repository\n    * @param {string} [options.description] - A short description of the repository\n    * @param {string} [options.homepage] - A URL with more information about the repository\n    * @param {boolean} [options.private] - Either true to make the repository private, or false to make it public.\n    * @param {boolean} [options.has_issues] - Either true to enable issues for this repository, false to disable them.\n    * @param {boolean} [options.has_wiki] - Either true to enable the wiki for this repository, false to disable it.\n    * @param {boolean} [options.has_downloads] - Either true to enable downloads, false to disable them.\n    * @param {string} [options.default_branch] - Updates the default branch for this repository.\n    * @param {Requestable.callback} cb - will receive the updated repository back\n    * @return {Promise} - the promise for the http request\n    */\n   updateRepository(options, cb) {\n      return this._request('PATCH', `/repos/${this.__fullname}`, options, cb);\n   }\n\n  /**\n    * Get information about the repository\n    * @see https://developer.github.com/v3/repos/#get\n    * @param {Requestable.callback} cb - will receive the information about the repository\n    * @return {Promise} - the promise for the http request\n    */\n   getDetails(cb) {\n      return this._request('GET', `/repos/${this.__fullname}`, null, cb);\n   }\n\n   /**\n    * List the contributors to the repository\n    * @see https://developer.github.com/v3/repos/#list-contributors\n    * @param {Requestable.callback} cb - will receive the list of contributors\n    * @return {Promise} - the promise for the http request\n    */\n   getContributors(cb) {\n      return this._request('GET', `/repos/${this.__fullname}/contributors`, null, cb);\n   }\n\n   /**\n    * List the contributor stats to the repository\n    * @see https://developer.github.com/v3/repos/#list-contributors\n    * @param {Requestable.callback} cb - will receive the list of contributors\n    * @return {Promise} - the promise for the http request\n    */\n   getContributorStats(cb) {\n      return this._request('GET', `/repos/${this.__fullname}/stats/contributors`, null, cb);\n   }\n\n   /**\n    * List the users who are collaborators on the repository. The currently authenticated user must have\n    * push access to use this method\n    * @see https://developer.github.com/v3/repos/collaborators/#list-collaborators\n    * @param {Requestable.callback} cb - will receive the list of collaborators\n    * @return {Promise} - the promise for the http request\n    */\n   getCollaborators(cb) {\n      return this._request('GET', `/repos/${this.__fullname}/collaborators`, null, cb);\n   }\n\n   /**\n    * Check if a user is a collaborator on the repository\n    * @see https://developer.github.com/v3/repos/collaborators/#check-if-a-user-is-a-collaborator\n    * @param {string} username - the user to check\n    * @param {Requestable.callback} cb - will receive true if the user is a collaborator and false if they are not\n    * @return {Promise} - the promise for the http request {Boolean} [description]\n    */\n   isCollaborator(username, cb) {\n      return this._request('GET', `/repos/${this.__fullname}/collaborators/${username}`, null, cb);\n   }\n\n   /**\n    * Get the contents of a repository\n    * @see https://developer.github.com/v3/repos/contents/#get-contents\n    * @param {string} ref - the ref to check\n    * @param {string} path - the path containing the content to fetch\n    * @param {boolean} raw - `true` if the results should be returned raw instead of GitHub's normalized format\n    * @param {Requestable.callback} cb - will receive the fetched data\n    * @return {Promise} - the promise for the http request\n    */\n   getContents(ref, path, raw, cb) {\n      path = path ? `${encodeURI(path)}` : '';\n      return this._request('GET', `/repos/${this.__fullname}/contents/${path}`, {\n         ref,\n      }, cb, raw);\n   }\n\n   /**\n    * Get the README of a repository\n    * @see https://developer.github.com/v3/repos/contents/#get-the-readme\n    * @param {string} ref - the ref to check\n    * @param {boolean} raw - `true` if the results should be returned raw instead of GitHub's normalized format\n    * @param {Requestable.callback} cb - will receive the fetched data\n    * @return {Promise} - the promise for the http request\n    */\n   getReadme(ref, raw, cb) {\n      return this._request('GET', `/repos/${this.__fullname}/readme`, {\n         ref,\n      }, cb, raw);\n   }\n\n   /**\n    * Fork a repository\n    * @see https://developer.github.com/v3/repos/forks/#create-a-fork\n    * @param {Requestable.callback} cb - will receive the information about the newly created fork\n    * @return {Promise} - the promise for the http request\n    */\n   fork(cb) {\n      return this._request('POST', `/repos/${this.__fullname}/forks`, null, cb);\n   }\n\n   /**\n    * List a repository's forks\n    * @see https://developer.github.com/v3/repos/forks/#list-forks\n    * @param {Requestable.callback} cb - will receive the list of repositories forked from this one\n    * @return {Promise} - the promise for the http request\n    */\n   listForks(cb) {\n      return this._request('GET', `/repos/${this.__fullname}/forks`, null, cb);\n   }\n\n   /**\n    * Create a new branch from an existing branch.\n    * @param {string} [oldBranch=master] - the name of the existing branch\n    * @param {string} newBranch - the name of the new branch\n    * @param {Requestable.callback} cb - will receive the commit data for the head of the new branch\n    * @return {Promise} - the promise for the http request\n    */\n   createBranch(oldBranch, newBranch, cb) {\n      if (typeof newBranch === 'function') {\n         cb = newBranch;\n         newBranch = oldBranch;\n         oldBranch = 'master';\n      }\n\n      return this.getRef(`heads/${oldBranch}`)\n         .then((response) => {\n            let sha = response.data.object.sha;\n            return this.createRef({\n               sha,\n               ref: `refs/heads/${newBranch}`,\n            }, cb);\n         });\n   }\n\n   /**\n    * Create a new pull request\n    * @see https://developer.github.com/v3/pulls/#create-a-pull-request\n    * @param {Object} options - the pull request description\n    * @param {Requestable.callback} cb - will receive the new pull request\n    * @return {Promise} - the promise for the http request\n    */\n   createPullRequest(options, cb) {\n      return this._request('POST', `/repos/${this.__fullname}/pulls`, options, cb);\n   }\n\n   /**\n    * Update a pull request\n    * @see https://developer.github.com/v3/pulls/#update-a-pull-request\n    * @param {number|string} number - the number of the pull request to update\n    * @param {Object} options - the pull request description\n    * @param {Requestable.callback} [cb] - will receive the pull request information\n    * @return {Promise} - the promise for the http request\n    */\n   updatePullRequest(number, options, cb) {\n      return this._request('PATCH', `/repos/${this.__fullname}/pulls/${number}`, options, cb);\n   }\n\n   /**\n    * List the hooks for the repository\n    * @see https://developer.github.com/v3/repos/hooks/#list-hooks\n    * @param {Requestable.callback} cb - will receive the list of hooks\n    * @return {Promise} - the promise for the http request\n    */\n   listHooks(cb) {\n      return this._request('GET', `/repos/${this.__fullname}/hooks`, null, cb);\n   }\n\n   /**\n    * Get a hook for the repository\n    * @see https://developer.github.com/v3/repos/hooks/#get-single-hook\n    * @param {number} id - the id of the webook\n    * @param {Requestable.callback} cb - will receive the details of the webook\n    * @return {Promise} - the promise for the http request\n    */\n   getHook(id, cb) {\n      return this._request('GET', `/repos/${this.__fullname}/hooks/${id}`, null, cb);\n   }\n\n   /**\n    * Add a new hook to the repository\n    * @see https://developer.github.com/v3/repos/hooks/#create-a-hook\n    * @param {Object} options - the configuration describing the new hook\n    * @param {Requestable.callback} cb - will receive the new webhook\n    * @return {Promise} - the promise for the http request\n    */\n   createHook(options, cb) {\n      return this._request('POST', `/repos/${this.__fullname}/hooks`, options, cb);\n   }\n\n   /**\n    * Edit an existing webhook\n    * @see https://developer.github.com/v3/repos/hooks/#edit-a-hook\n    * @param {number} id - the id of the webhook\n    * @param {Object} options - the new description of the webhook\n    * @param {Requestable.callback} cb - will receive the updated webhook\n    * @return {Promise} - the promise for the http request\n    */\n   updateHook(id, options, cb) {\n      return this._request('PATCH', `/repos/${this.__fullname}/hooks/${id}`, options, cb);\n   }\n\n   /**\n    * Delete a webhook\n    * @see https://developer.github.com/v3/repos/hooks/#delete-a-hook\n    * @param {number} id - the id of the webhook to be deleted\n    * @param {Requestable.callback} cb - will receive true if the call is successful\n    * @return {Promise} - the promise for the http request\n    */\n   deleteHook(id, cb) {\n      return this._request('DELETE', `/repos/${this.__fullname}/hooks/${id}`, null, cb);\n   }\n\n   /**\n    * List the deploy keys for the repository\n    * @see https://developer.github.com/v3/repos/keys/#list-deploy-keys\n    * @param {Requestable.callback} cb - will receive the list of deploy keys\n    * @return {Promise} - the promise for the http request\n    */\n   listKeys(cb) {\n      return this._request('GET', `/repos/${this.__fullname}/keys`, null, cb);\n   }\n\n   /**\n    * Get a deploy key for the repository\n    * @see https://developer.github.com/v3/repos/keys/#get-a-deploy-key\n    * @param {number} id - the id of the deploy key\n    * @param {Requestable.callback} cb - will receive the details of the deploy key\n    * @return {Promise} - the promise for the http request\n    */\n   getKey(id, cb) {\n      return this._request('GET', `/repos/${this.__fullname}/keys/${id}`, null, cb);\n   }\n\n   /**\n    * Add a new deploy key to the repository\n    * @see https://developer.github.com/v3/repos/keys/#add-a-new-deploy-key\n    * @param {Object} options - the configuration describing the new deploy key\n    * @param {Requestable.callback} cb - will receive the new deploy key\n    * @return {Promise} - the promise for the http request\n    */\n   createKey(options, cb) {\n      return this._request('POST', `/repos/${this.__fullname}/keys`, options, cb);\n   }\n\n   /**\n    * Delete a deploy key\n    * @see https://developer.github.com/v3/repos/keys/#remove-a-deploy-key\n    * @param {number} id - the id of the deploy key to be deleted\n    * @param {Requestable.callback} cb - will receive true if the call is successful\n    * @return {Promise} - the promise for the http request\n    */\n   deleteKey(id, cb) {\n      return this._request('DELETE', `/repos/${this.__fullname}/keys/${id}`, null, cb);\n   }\n\n   /**\n    * Delete a file from a branch\n    * @see https://developer.github.com/v3/repos/contents/#delete-a-file\n    * @param {string} branch - the branch to delete from, or the default branch if not specified\n    * @param {string} path - the path of the file to remove\n    * @param {Requestable.callback} cb - will receive the commit in which the delete occurred\n    * @return {Promise} - the promise for the http request\n    */\n   deleteFile(branch, path, cb) {\n      return this.getSha(branch, path)\n         .then((response) => {\n            const deleteCommit = {\n               message: `Delete the file at '${path}'`,\n               sha: response.data.sha,\n               branch,\n            };\n            return this._request('DELETE', `/repos/${this.__fullname}/contents/${path}`, deleteCommit, cb);\n         });\n   }\n\n   /**\n    * Change all references in a repo from oldPath to new_path\n    * @param {string} branch - the branch to carry out the reference change, or the default branch if not specified\n    * @param {string} oldPath - original path\n    * @param {string} newPath - new reference path\n    * @param {Requestable.callback} cb - will receive the commit in which the move occurred\n    * @return {Promise} - the promise for the http request\n    */\n   move(branch, oldPath, newPath, cb) {\n      let oldSha;\n      return this.getRef(`heads/${branch}`)\n         .then(({data: {object}}) => this.getTree(`${object.sha}?recursive=true`))\n         .then(({data: {tree, sha}}) => {\n            oldSha = sha;\n            let newTree = tree.map((ref) => {\n               if (ref.path === oldPath) {\n                  ref.path = newPath;\n               }\n               if (ref.type === 'tree') {\n                  delete ref.sha;\n               }\n               return ref;\n            });\n            return this.createTree(newTree);\n         })\n         .then(({data: tree}) => this.commit(oldSha, tree.sha, `Renamed '${oldPath}' to '${newPath}'`))\n         .then(({data: commit}) => this.updateHead(`heads/${branch}`, commit.sha, true, cb));\n   }\n\n   /**\n    * Write a file to the repository\n    * @see https://developer.github.com/v3/repos/contents/#update-a-file\n    * @param {string} branch - the name of the branch\n    * @param {string} path - the path for the file\n    * @param {string} content - the contents of the file\n    * @param {string} message - the commit message\n    * @param {Object} [options] - commit options\n    * @param {Object} [options.author] - the author of the commit\n    * @param {Object} [options.commiter] - the committer\n    * @param {boolean} [options.encode] - true if the content should be base64 encoded\n    * @param {Requestable.callback} cb - will receive the new commit\n    * @return {Promise} - the promise for the http request\n    */\n   writeFile(branch, path, content, message, options, cb) {\n      if (typeof options === 'function') {\n         cb = options;\n         options = {};\n      }\n      let filePath = path ? encodeURI(path) : '';\n      let shouldEncode = options.encode !== false;\n      let commit = {\n         branch,\n         message,\n         author: options.author,\n         committer: options.committer,\n         content: shouldEncode ? Base64.encode(content) : content,\n      };\n\n      return this.getSha(branch, filePath)\n         .then((response) => {\n            commit.sha = response.data.sha;\n            return this._request('PUT', `/repos/${this.__fullname}/contents/${filePath}`, commit, cb);\n         }, () => {\n            return this._request('PUT', `/repos/${this.__fullname}/contents/${filePath}`, commit, cb);\n         });\n   }\n\n   /**\n    * Check if a repository is starred by you\n    * @see https://developer.github.com/v3/activity/starring/#check-if-you-are-starring-a-repository\n    * @param {Requestable.callback} cb - will receive true if the repository is starred and false if the repository\n    *                                  is not starred\n    * @return {Promise} - the promise for the http request {Boolean} [description]\n    */\n   isStarred(cb) {\n      return this._request204or404(`/user/starred/${this.__fullname}`, null, cb);\n   }\n\n   /**\n    * Star a repository\n    * @see https://developer.github.com/v3/activity/starring/#star-a-repository\n    * @param {Requestable.callback} cb - will receive true if the repository is starred\n    * @return {Promise} - the promise for the http request\n    */\n   star(cb) {\n      return this._request('PUT', `/user/starred/${this.__fullname}`, null, cb);\n   }\n\n   /**\n    * Unstar a repository\n    * @see https://developer.github.com/v3/activity/starring/#unstar-a-repository\n    * @param {Requestable.callback} cb - will receive true if the repository is unstarred\n    * @return {Promise} - the promise for the http request\n    */\n   unstar(cb) {\n      return this._request('DELETE', `/user/starred/${this.__fullname}`, null, cb);\n   }\n\n   /**\n    * Create a new release\n    * @see https://developer.github.com/v3/repos/releases/#create-a-release\n    * @param {Object} options - the description of the release\n    * @param {Requestable.callback} cb - will receive the newly created release\n    * @return {Promise} - the promise for the http request\n    */\n   createRelease(options, cb) {\n      return this._request('POST', `/repos/${this.__fullname}/releases`, options, cb);\n   }\n\n   /**\n    * Edit a release\n    * @see https://developer.github.com/v3/repos/releases/#edit-a-release\n    * @param {string} id - the id of the release\n    * @param {Object} options - the description of the release\n    * @param {Requestable.callback} cb - will receive the modified release\n    * @return {Promise} - the promise for the http request\n    */\n   updateRelease(id, options, cb) {\n      return this._request('PATCH', `/repos/${this.__fullname}/releases/${id}`, options, cb);\n   }\n\n   /**\n    * Get information about all releases\n    * @see https://developer.github.com/v3/repos/releases/#list-releases-for-a-repository\n    * @param {Requestable.callback} cb - will receive the release information\n    * @return {Promise} - the promise for the http request\n    */\n   listReleases(cb) {\n      return this._request('GET', `/repos/${this.__fullname}/releases`, null, cb);\n   }\n\n   /**\n    * Get information about a release\n    * @see https://developer.github.com/v3/repos/releases/#get-a-single-release\n    * @param {string} id - the id of the release\n    * @param {Requestable.callback} cb - will receive the release information\n    * @return {Promise} - the promise for the http request\n    */\n   getRelease(id, cb) {\n      return this._request('GET', `/repos/${this.__fullname}/releases/${id}`, null, cb);\n   }\n\n   /**\n    * Delete a release\n    * @see https://developer.github.com/v3/repos/releases/#delete-a-release\n    * @param {string} id - the release to be deleted\n    * @param {Requestable.callback} cb - will receive true if the operation is successful\n    * @return {Promise} - the promise for the http request\n    */\n   deleteRelease(id, cb) {\n      return this._request('DELETE', `/repos/${this.__fullname}/releases/${id}`, null, cb);\n   }\n\n   /**\n    * Merge a pull request\n    * @see https://developer.github.com/v3/pulls/#merge-a-pull-request-merge-button\n    * @param {number|string} number - the number of the pull request to merge\n    * @param {Object} options - the merge options for the pull request\n    * @param {Requestable.callback} [cb] - will receive the merge information if the operation is successful\n    * @return {Promise} - the promise for the http request\n    */\n   mergePullRequest(number, options, cb) {\n      return this._request('PUT', `/repos/${this.__fullname}/pulls/${number}/merge`, options, cb);\n   }\n\n   /**\n    * Get information about all projects\n    * @see https://developer.github.com/v3/projects/#list-repository-projects\n    * @param {Requestable.callback} [cb] - will receive the list of projects\n    * @return {Promise} - the promise for the http request\n    */\n   listProjects(cb) {\n      return this._requestAllPages(`/repos/${this.__fullname}/projects`, {AcceptHeader: 'inertia-preview'}, cb);\n   }\n\n   /**\n    * Create a new project\n    * @see https://developer.github.com/v3/projects/#create-a-repository-project\n    * @param {Object} options - the description of the project\n    * @param {Requestable.callback} cb - will receive the newly created project\n    * @return {Promise} - the promise for the http request\n    */\n   createProject(options, cb) {\n      options = options || {};\n      options.AcceptHeader = 'inertia-preview';\n      return this._request('POST', `/repos/${this.__fullname}/projects`, options, cb);\n   }\n\n}\n\nmodule.exports = Repository;\n","/**\n * @file\n * @copyright  2016 Yahoo Inc.\n * @license    Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n *             Github.js is freely distributable.\n */\n\nimport axios from 'axios';\nimport debug from 'debug';\nimport {Base64} from 'js-base64';\n\nconst log = debug('github:request');\n\n/**\n * The error structure returned when a network call fails\n */\nclass ResponseError extends Error {\n   /**\n    * Construct a new ResponseError\n    * @param {string} message - an message to return instead of the the default error message\n    * @param {string} path - the requested path\n    * @param {Object} response - the object returned by Axios\n    */\n   constructor(message, path, response) {\n      super(message);\n      this.path = path;\n      this.request = response.config;\n      this.response = (response || {}).response || response;\n      this.status = response.status;\n   }\n}\n\n/**\n * Requestable wraps the logic for making http requests to the API\n */\nclass Requestable {\n   /**\n    * Either a username and password or an oauth token for Github\n    * @typedef {Object} Requestable.auth\n    * @prop {string} [username] - the Github username\n    * @prop {string} [password] - the user's password\n    * @prop {token} [token] - an OAuth token\n    */\n   /**\n    * Initialize the http internals.\n    * @param {Requestable.auth} [auth] - the credentials to authenticate to Github. If auth is\n    *                                  not provided request will be made unauthenticated\n    * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n    * @param {string} [AcceptHeader=v3] - the accept header for the requests\n    */\n   constructor(auth, apiBase, AcceptHeader) {\n      this.__apiBase = apiBase || 'https://api.github.com';\n      this.__auth = {\n         token: auth.token,\n         username: auth.username,\n         password: auth.password,\n      };\n      this.__AcceptHeader = AcceptHeader || 'v3';\n\n      if (auth.token) {\n         this.__authorizationHeader = 'token ' + auth.token;\n      } else if (auth.username && auth.password) {\n         this.__authorizationHeader = 'Basic ' + Base64.encode(auth.username + ':' + auth.password);\n      }\n   }\n\n   /**\n    * Compute the URL to use to make a request.\n    * @private\n    * @param {string} path - either a URL relative to the API base or an absolute URL\n    * @return {string} - the URL to use\n    */\n   __getURL(path) {\n      let url = path;\n\n      if (path.indexOf('//') === -1) {\n         url = this.__apiBase + path;\n      }\n\n      let newCacheBuster = 'timestamp=' + new Date().getTime();\n      return url.replace(/(timestamp=\\d+)/, newCacheBuster);\n   }\n\n   /**\n    * Compute the headers required for an API request.\n    * @private\n    * @param {boolean} raw - if the request should be treated as JSON or as a raw request\n    * @param {string} AcceptHeader - the accept header for the request\n    * @return {Object} - the headers to use in the request\n    */\n   __getRequestHeaders(raw, AcceptHeader) {\n      let headers = {\n         'Content-Type': 'application/json;charset=UTF-8',\n         'Accept': 'application/vnd.github.' + (AcceptHeader || this.__AcceptHeader),\n      };\n\n      if (raw) {\n         headers.Accept += '.raw';\n      }\n      headers.Accept += '+json';\n\n      if (this.__authorizationHeader) {\n         headers.Authorization = this.__authorizationHeader;\n      }\n\n      return headers;\n   }\n\n   /**\n    * Sets the default options for API requests\n    * @protected\n    * @param {Object} [requestOptions={}] - the current options for the request\n    * @return {Object} - the options to pass to the request\n    */\n   _getOptionsWithDefaults(requestOptions = {}) {\n      if (!(requestOptions.visibility || requestOptions.affiliation)) {\n         requestOptions.type = requestOptions.type || 'all';\n      }\n      requestOptions.sort = requestOptions.sort || 'updated';\n      requestOptions.per_page = requestOptions.per_page || '100'; // eslint-disable-line\n\n      return requestOptions;\n   }\n\n   /**\n    * if a `Date` is passed to this function it will be converted to an ISO string\n    * @param {*} date - the object to attempt to cooerce into an ISO date string\n    * @return {string} - the ISO representation of `date` or whatever was passed in if it was not a date\n    */\n   _dateToISO(date) {\n      if (date && (date instanceof Date)) {\n         date = date.toISOString();\n      }\n\n      return date;\n   }\n\n   /**\n    * A function that receives the result of the API request.\n    * @callback Requestable.callback\n    * @param {Requestable.Error} error - the error returned by the API or `null`\n    * @param {(Object|true)} result - the data returned by the API or `true` if the API returns `204 No Content`\n    * @param {Object} request - the raw {@linkcode https://github.com/mzabriskie/axios#response-schema Response}\n    */\n   /**\n    * Make a request.\n    * @param {string} method - the method for the request (GET, PUT, POST, DELETE)\n    * @param {string} path - the path for the request\n    * @param {*} [data] - the data to send to the server. For HTTP methods that don't have a body the data\n    *                   will be sent as query parameters\n    * @param {Requestable.callback} [cb] - the callback for the request\n    * @param {boolean} [raw=false] - if the request should be sent as raw. If this is a falsy value then the\n    *                              request will be made as JSON\n    * @return {Promise} - the Promise for the http request\n    */\n   _request(method, path, data, cb, raw) {\n      const url = this.__getURL(path);\n\n      const AcceptHeader = (data || {}).AcceptHeader;\n      if (AcceptHeader) {\n         delete data.AcceptHeader;\n      }\n      const headers = this.__getRequestHeaders(raw, AcceptHeader);\n\n      let queryParams = {};\n\n      const shouldUseDataAsParams = data && (typeof data === 'object') && methodHasNoBody(method);\n      if (shouldUseDataAsParams) {\n         queryParams = data;\n         data = undefined;\n      }\n\n      const config = {\n         url: url,\n         method: method,\n         headers: headers,\n         params: queryParams,\n         data: data,\n         responseType: raw ? 'text' : 'json',\n      };\n\n      log(`${config.method} to ${config.url}`);\n      const requestPromise = axios(config).catch(callbackErrorOrThrow(cb, path));\n\n      if (cb) {\n         requestPromise.then((response) => {\n            if (response.data && Object.keys(response.data).length > 0) {\n               // When data has results\n               cb(null, response.data, response);\n            } else if (config.method !== 'GET' && Object.keys(response.data).length < 1) {\n               // True when successful submit a request and receive a empty object\n               cb(null, (response.status < 300), response);\n            } else {\n               cb(null, response.data, response);\n            }\n         });\n      }\n\n      return requestPromise;\n   }\n\n   /**\n    * Make a request to an endpoint the returns 204 when true and 404 when false\n    * @param {string} path - the path to request\n    * @param {Object} data - any query parameters for the request\n    * @param {Requestable.callback} cb - the callback that will receive `true` or `false`\n    * @param {method} [method=GET] - HTTP Method to use\n    * @return {Promise} - the promise for the http request\n    */\n   _request204or404(path, data, cb, method = 'GET') {\n      return this._request(method, path, data)\n         .then(function success(response) {\n            if (cb) {\n               cb(null, true, response);\n            }\n            return true;\n         }, function failure(response) {\n            if (response.response.status === 404) {\n               if (cb) {\n                  cb(null, false, response);\n               }\n               return false;\n            }\n\n            if (cb) {\n               cb(response);\n            }\n            throw response;\n         });\n   }\n\n   /**\n    * Make a request and fetch all the available data. Github will paginate responses so for queries\n    * that might span multiple pages this method is preferred to {@link Requestable#request}\n    * @param {string} path - the path to request\n    * @param {Object} options - the query parameters to include\n    * @param {Requestable.callback} [cb] - the function to receive the data. The returned data will always be an array.\n    * @param {Object[]} results - the partial results. This argument is intended for interal use only.\n    * @return {Promise} - a promise which will resolve when all pages have been fetched\n    * @deprecated This will be folded into {@link Requestable#_request} in the 2.0 release.\n    */\n   _requestAllPages(path, options, cb, results) {\n      results = results || [];\n\n      return this._request('GET', path, options)\n         .then((response) => {\n            let thisGroup;\n            if (response.data instanceof Array) {\n               thisGroup = response.data;\n            } else if (response.data.items instanceof Array) {\n               thisGroup = response.data.items;\n            } else {\n               let message = `cannot figure out how to append ${response.data} to the result set`;\n               throw new ResponseError(message, path, response);\n            }\n            results.push(...thisGroup);\n\n            const nextUrl = getNextPage(response.headers.link);\n            if (nextUrl && typeof options.page !== 'number') {\n               log(`getting next page: ${nextUrl}`);\n               return this._requestAllPages(nextUrl, options, cb, results);\n            }\n\n            if (cb) {\n               cb(null, results, response);\n            }\n\n            response.data = results;\n            return response;\n         }).catch(callbackErrorOrThrow(cb, path));\n   }\n}\n\nmodule.exports = Requestable;\n\n// ////////////////////////// //\n//  Private helper functions  //\n// ////////////////////////// //\nconst METHODS_WITH_NO_BODY = ['GET', 'HEAD', 'DELETE'];\nfunction methodHasNoBody(method) {\n   return METHODS_WITH_NO_BODY.indexOf(method) !== -1;\n}\n\nfunction getNextPage(linksHeader = '') {\n   const links = linksHeader.split(/\\s*,\\s*/); // splits and strips the urls\n   return links.reduce(function(nextUrl, link) {\n      if (link.search(/rel=\"next\"/) !== -1) {\n         return (link.match(/<(.*)>/) || [])[1];\n      }\n\n      return nextUrl;\n   }, undefined);\n}\n\nfunction callbackErrorOrThrow(cb, path) {\n   return function handler(object) {\n      let error;\n      if (object.hasOwnProperty('config')) {\n         const {response: {status, statusText}, config: {method, url}} = object;\n         let message = (`${status} error making request ${method} ${url}: \"${statusText}\"`);\n         error = new ResponseError(message, path, object);\n         log(`${message} ${JSON.stringify(object.data)}`);\n      } else {\n         error = object;\n      }\n      if (cb) {\n         log('going to error callback');\n         cb(error);\n      } else {\n         log('throwing error');\n         throw error;\n      }\n   };\n}\n","/**\n * @file\n * @copyright  2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license    Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n *             Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\nimport debug from 'debug';\nconst log = debug('github:search');\n\n/**\n * Wrap the Search API\n */\nclass Search extends Requestable {\n   /**\n    * Create a Search\n    * @param {Object} defaults - defaults for the search\n    * @param {Requestable.auth} [auth] - information required to authenticate to Github\n    * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n    */\n   constructor(defaults, auth, apiBase) {\n      super(auth, apiBase);\n      this.__defaults = this._getOptionsWithDefaults(defaults);\n   }\n\n   /**\n    * Available search options\n    * @see https://developer.github.com/v3/search/#parameters\n    * @typedef {Object} Search.Params\n    * @param {string} q - the query to make\n    * @param {string} sort - the sort field, one of `stars`, `forks`, or `updated`.\n    *                      Default is [best match](https://developer.github.com/v3/search/#ranking-search-results)\n    * @param {string} order - the ordering, either `asc` or `desc`\n    */\n   /**\n    * Perform a search on the GitHub API\n    * @private\n    * @param {string} path - the scope of the search\n    * @param {Search.Params} [withOptions] - additional parameters for the search\n    * @param {Requestable.callback} [cb] - will receive the results of the search\n    * @return {Promise} - the promise for the http request\n    */\n   _search(path, withOptions = {}, cb = undefined) {\n      let requestOptions = {};\n      Object.keys(this.__defaults).forEach((prop) => {\n         requestOptions[prop] = this.__defaults[prop];\n      });\n      Object.keys(withOptions).forEach((prop) => {\n         requestOptions[prop] = withOptions[prop];\n      });\n\n      log(`searching ${path} with options:`, requestOptions);\n      return this._requestAllPages(`/search/${path}`, requestOptions, cb);\n   }\n\n   /**\n    * Search for repositories\n    * @see https://developer.github.com/v3/search/#search-repositories\n    * @param {Search.Params} [options] - additional parameters for the search\n    * @param {Requestable.callback} [cb] - will receive the results of the search\n    * @return {Promise} - the promise for the http request\n    */\n   forRepositories(options, cb) {\n      return this._search('repositories', options, cb);\n   }\n\n   /**\n    * Search for code\n    * @see https://developer.github.com/v3/search/#search-code\n    * @param {Search.Params} [options] - additional parameters for the search\n    * @param {Requestable.callback} [cb] - will receive the results of the search\n    * @return {Promise} - the promise for the http request\n    */\n   forCode(options, cb) {\n      return this._search('code', options, cb);\n   }\n\n   /**\n    * Search for issues\n    * @see https://developer.github.com/v3/search/#search-issues\n    * @param {Search.Params} [options] - additional parameters for the search\n    * @param {Requestable.callback} [cb] - will receive the results of the search\n    * @return {Promise} - the promise for the http request\n    */\n   forIssues(options, cb) {\n      return this._search('issues', options, cb);\n   }\n\n   /**\n    * Search for users\n    * @see https://developer.github.com/v3/search/#search-users\n    * @param {Search.Params} [options] - additional parameters for the search\n    * @param {Requestable.callback} [cb] - will receive the results of the search\n    * @return {Promise} - the promise for the http request\n    */\n   forUsers(options, cb) {\n      return this._search('users', options, cb);\n   }\n}\n\nmodule.exports = Search;\n","/**\n * @file\n * @copyright  2016 Matt Smith (Development Seed)\n * @license    Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n *             Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\nimport debug from 'debug';\nconst log = debug('github:team');\n\n/**\n * A Team allows scoping of API requests to a particular Github Organization Team.\n */\nclass Team extends Requestable {\n   /**\n    * Create a Team.\n    * @param {string} [teamId] - the id for the team\n    * @param {Requestable.auth} [auth] - information required to authenticate to Github\n    * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n    */\n   constructor(teamId, auth, apiBase) {\n      super(auth, apiBase);\n      this.__teamId = teamId;\n   }\n\n   /**\n    * Get Team information\n    * @see https://developer.github.com/v3/orgs/teams/#get-team\n    * @param {Requestable.callback} [cb] - will receive the team\n    * @return {Promise} - the promise for the http request\n    */\n   getTeam(cb) {\n      log(`Fetching Team ${this.__teamId}`);\n      return this._request('Get', `/teams/${this.__teamId}`, undefined, cb);\n   }\n\n   /**\n    * List the Team's repositories\n    * @see https://developer.github.com/v3/orgs/teams/#list-team-repos\n    * @param {Requestable.callback} [cb] - will receive the list of repositories\n    * @return {Promise} - the promise for the http request\n    */\n   listRepos(cb) {\n      log(`Fetching repositories for Team ${this.__teamId}`);\n      return this._requestAllPages(`/teams/${this.__teamId}/repos`, undefined, cb);\n   }\n\n   /**\n    * Edit Team information\n    * @see https://developer.github.com/v3/orgs/teams/#edit-team\n    * @param {object} options - Parameters for team edit\n    * @param {string} options.name - The name of the team\n    * @param {string} [options.description] - Team description\n    * @param {string} [options.repo_names] - Repos to add the team to\n    * @param {string} [options.privacy=secret] - The level of privacy the team should have. Can be either one\n    * of: `secret`, or `closed`\n    * @param {Requestable.callback} [cb] - will receive the updated team\n    * @return {Promise} - the promise for the http request\n    */\n   editTeam(options, cb) {\n      log(`Editing Team ${this.__teamId}`);\n      return this._request('PATCH', `/teams/${this.__teamId}`, options, cb);\n   }\n\n   /**\n    * List the users who are members of the Team\n    * @see https://developer.github.com/v3/orgs/teams/#list-team-members\n    * @param {object} options - Parameters for listing team users\n    * @param {string} [options.role=all] - can be one of: `all`, `maintainer`, or `member`\n    * @param {Requestable.callback} [cb] - will receive the list of users\n    * @return {Promise} - the promise for the http request\n    */\n   listMembers(options, cb) {\n      log(`Getting members of Team ${this.__teamId}`);\n      return this._requestAllPages(`/teams/${this.__teamId}/members`, options, cb);\n   }\n\n   /**\n    * Get Team membership status for a user\n    * @see https://developer.github.com/v3/orgs/teams/#get-team-membership\n    * @param {string} username - can be one of: `all`, `maintainer`, or `member`\n    * @param {Requestable.callback} [cb] - will receive the membership status of a user\n    * @return {Promise} - the promise for the http request\n    */\n   getMembership(username, cb) {\n      log(`Getting membership of user ${username} in Team ${this.__teamId}`);\n      return this._request('GET', `/teams/${this.__teamId}/memberships/${username}`, undefined, cb);\n   }\n\n   /**\n    * Add a member to the Team\n    * @see https://developer.github.com/v3/orgs/teams/#add-team-membership\n    * @param {string} username - can be one of: `all`, `maintainer`, or `member`\n    * @param {object} options - Parameters for adding a team member\n    * @param {string} [options.role=member] - The role that this user should have in the team. Can be one\n    * of: `member`, or `maintainer`\n    * @param {Requestable.callback} [cb] - will receive the membership status of added user\n    * @return {Promise} - the promise for the http request\n    */\n   addMembership(username, options, cb) {\n      log(`Adding user ${username} to Team ${this.__teamId}`);\n      return this._request('PUT', `/teams/${this.__teamId}/memberships/${username}`, options, cb);\n   }\n\n   /**\n    * Get repo management status for team\n    * @see https://developer.github.com/v3/orgs/teams/#remove-team-membership\n    * @param {string} owner - Organization name\n    * @param {string} repo - Repo name\n    * @param {Requestable.callback} [cb] - will receive the membership status of added user\n    * @return {Promise} - the promise for the http request\n    */\n   isManagedRepo(owner, repo, cb) {\n      log(`Getting repo management by Team ${this.__teamId} for repo ${owner}/${repo}`);\n      return this._request204or404(`/teams/${this.__teamId}/repos/${owner}/${repo}`, undefined, cb);\n   }\n\n   /**\n    * Add or Update repo management status for team\n    * @see https://developer.github.com/v3/orgs/teams/#add-or-update-team-repository\n    * @param {string} owner - Organization name\n    * @param {string} repo - Repo name\n    * @param {object} options - Parameters for adding or updating repo management for the team\n    * @param {string} [options.permission] - The permission to grant the team on this repository. Can be one\n    * of: `pull`, `push`, or `admin`\n    * @param {Requestable.callback} [cb] - will receive the membership status of added user\n    * @return {Promise} - the promise for the http request\n    */\n   manageRepo(owner, repo, options, cb) {\n      log(`Adding or Updating repo management by Team ${this.__teamId} for repo ${owner}/${repo}`);\n      return this._request204or404(`/teams/${this.__teamId}/repos/${owner}/${repo}`, options, cb, 'PUT');\n   }\n\n   /**\n    * Remove repo management status for team\n    * @see https://developer.github.com/v3/orgs/teams/#remove-team-repository\n    * @param {string} owner - Organization name\n    * @param {string} repo - Repo name\n    * @param {Requestable.callback} [cb] - will receive the membership status of added user\n    * @return {Promise} - the promise for the http request\n    */\n   unmanageRepo(owner, repo, cb) {\n      log(`Remove repo management by Team ${this.__teamId} for repo ${owner}/${repo}`);\n      return this._request204or404(`/teams/${this.__teamId}/repos/${owner}/${repo}`, undefined, cb, 'DELETE');\n   }\n\n   /**\n    * Delete Team\n    * @see https://developer.github.com/v3/orgs/teams/#delete-team\n    * @param {Requestable.callback} [cb] - will receive the list of repositories\n    * @return {Promise} - the promise for the http request\n    */\n   deleteTeam(cb) {\n      log(`Deleting Team ${this.__teamId}`);\n      return this._request204or404(`/teams/${this.__teamId}`, undefined, cb, 'DELETE');\n   }\n}\n\nmodule.exports = Team;\n","/**\n * @file\n * @copyright  2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license    Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n *             Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\nimport debug from 'debug';\nconst log = debug('github:user');\n\n/**\n * A User allows scoping of API requests to a particular Github user.\n */\nclass User extends Requestable {\n   /**\n    * Create a User.\n    * @param {string} [username] - the user to use for user-scoped queries\n    * @param {Requestable.auth} [auth] - information required to authenticate to Github\n    * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n    */\n   constructor(username, auth, apiBase) {\n      super(auth, apiBase);\n      this.__user = username;\n   }\n\n   /**\n    * Get the url for the request. (dependent on if we're requesting for the authenticated user or not)\n    * @private\n    * @param {string} endpoint - the endpoint being requested\n    * @return {string} - the resolved endpoint\n    */\n   __getScopedUrl(endpoint) {\n      if (this.__user) {\n         return endpoint ?\n            `/users/${this.__user}/${endpoint}` :\n            `/users/${this.__user}`\n            ;\n\n      } else { // eslint-disable-line\n         switch (endpoint) {\n            case '':\n               return '/user';\n\n            case 'notifications':\n            case 'gists':\n               return `/${endpoint}`;\n\n            default:\n               return `/user/${endpoint}`;\n         }\n      }\n   }\n\n   /**\n    * List the user's repositories\n    * @see https://developer.github.com/v3/repos/#list-user-repositories\n    * @param {Object} [options={}] - any options to refine the search\n    * @param {Requestable.callback} [cb] - will receive the list of repositories\n    * @return {Promise} - the promise for the http request\n    */\n   listRepos(options, cb) {\n      if (typeof options === 'function') {\n         cb = options;\n         options = {};\n      }\n\n      options = this._getOptionsWithDefaults(options);\n\n      log(`Fetching repositories with options: ${JSON.stringify(options)}`);\n      return this._requestAllPages(this.__getScopedUrl('repos'), options, cb);\n   }\n\n   /**\n    * List the orgs that the user belongs to\n    * @see https://developer.github.com/v3/orgs/#list-user-organizations\n    * @param {Requestable.callback} [cb] - will receive the list of organizations\n    * @return {Promise} - the promise for the http request\n    */\n   listOrgs(cb) {\n      return this._request('GET', this.__getScopedUrl('orgs'), null, cb);\n   }\n\n   /**\n    * List the user's gists\n    * @see https://developer.github.com/v3/gists/#list-a-users-gists\n    * @param {Requestable.callback} [cb] - will receive the list of gists\n    * @return {Promise} - the promise for the http request\n    */\n   listGists(cb) {\n      return this._request('GET', this.__getScopedUrl('gists'), null, cb);\n   }\n\n   /**\n    * List the user's starred gists\n    * @see https://developer.github.com/v3/gists/#list-starred-gists\n    * @param {Requestable.callback} [cb] - will receive the list of gists\n    * @return {Promise} - the promise for the http request\n    */\n   listStarredGists(cb) {\n      return this._request('GET', this.__getScopedUrl('gists/starred'), null, cb);\n   }\n\n   /**\n    * List the user's gists\n    * @see https://developer.github.com/v3/gists/#list-a-users-gists\n    * @param {Requestable.callback} [cb] - will receive the list of gists\n    * @return {Promise} - the promise for the http request\n    */\n   listStarredGists(cb) {\n      return this._request('GET', this.__getScopedUrl('gists'), null, cb);\n   }\n\n   /**\n    * List the user's notifications\n    * @see https://developer.github.com/v3/activity/notifications/#list-your-notifications\n    * @param {Object} [options={}] - any options to refine the search\n    * @param {Requestable.callback} [cb] - will receive the list of repositories\n    * @return {Promise} - the promise for the http request\n    */\n   listNotifications(options, cb) {\n      options = options || {};\n      if (typeof options === 'function') {\n         cb = options;\n         options = {};\n      }\n\n      options.since = this._dateToISO(options.since);\n      options.before = this._dateToISO(options.before);\n\n      return this._request('GET', this.__getScopedUrl('notifications'), options, cb);\n   }\n\n   /**\n    * Show the user's profile\n    * @see https://developer.github.com/v3/users/#get-a-single-user\n    * @param {Requestable.callback} [cb] - will receive the user's information\n    * @return {Promise} - the promise for the http request\n    */\n   getProfile(cb) {\n      return this._request('GET', this.__getScopedUrl(''), null, cb);\n   }\n\n   /**\n    * Gets the list of starred repositories for the user\n    * @see https://developer.github.com/v3/activity/starring/#list-repositories-being-starred\n    * @param {Requestable.callback} [cb] - will receive the list of starred repositories\n    * @return {Promise} - the promise for the http request\n    */\n   listStarredRepos(cb) {\n      let requestOptions = this._getOptionsWithDefaults();\n      return this._requestAllPages(this.__getScopedUrl('starred'), requestOptions, cb);\n   }\n\n   /**\n    * List email addresses for a user\n    * @see https://developer.github.com/v3/users/emails/#list-email-addresses-for-a-user\n    * @param {Requestable.callback} [cb] - will receive the list of emails\n    * @return {Promise} - the promise for the http request\n    */\n   getEmails(cb) {\n      return this._request('GET', '/user/emails', null, cb);\n   }\n\n   /**\n    * Have the authenticated user follow this user\n    * @see https://developer.github.com/v3/users/followers/#follow-a-user\n    * @param {string} username - the user to follow\n    * @param {Requestable.callback} [cb] - will receive true if the request succeeds\n    * @return {Promise} - the promise for the http request\n    */\n   follow(username, cb) {\n      return this._request('PUT', `/user/following/${this.__user}`, null, cb);\n   }\n\n   /**\n    * Have the currently authenticated user unfollow this user\n    * @see https://developer.github.com/v3/users/followers/#follow-a-user\n    * @param {string} username - the user to unfollow\n    * @param {Requestable.callback} [cb] - receives true if the request succeeds\n    * @return {Promise} - the promise for the http request\n    */\n   unfollow(username, cb) {\n      return this._request('DELETE', `/user/following/${this.__user}`, null, cb);\n   }\n\n   /**\n    * Create a new repository for the currently authenticated user\n    * @see https://developer.github.com/v3/repos/#create\n    * @param {object} options - the repository definition\n    * @param {Requestable.callback} [cb] - will receive the API response\n    * @return {Promise} - the promise for the http request\n    */\n   createRepo(options, cb) {\n      return this._request('POST', '/user/repos', options, cb);\n   }\n}\n\nmodule.exports = User;\n","module.exports = require('./lib/axios');","'use strict';\n\nvar utils = require('./../utils');\nvar settle = require('./../core/settle');\nvar buildURL = require('./../helpers/buildURL');\nvar parseHeaders = require('./../helpers/parseHeaders');\nvar isURLSameOrigin = require('./../helpers/isURLSameOrigin');\nvar createError = require('../core/createError');\nvar btoa = (typeof window !== 'undefined' && window.btoa && window.btoa.bind(window)) || require('./../helpers/btoa');\n\nmodule.exports = function xhrAdapter(config) {\n  return new Promise(function dispatchXhrRequest(resolve, reject) {\n    var requestData = config.data;\n    var requestHeaders = config.headers;\n\n    if (utils.isFormData(requestData)) {\n      delete requestHeaders['Content-Type']; // Let the browser set it\n    }\n\n    var request = new XMLHttpRequest();\n    var loadEvent = 'onreadystatechange';\n    var xDomain = false;\n\n    // For IE 8/9 CORS support\n    // Only supports POST and GET calls and doesn't returns the response headers.\n    // DON'T do this for testing b/c XMLHttpRequest is mocked, not XDomainRequest.\n    if (process.env.NODE_ENV !== 'test' &&\n        typeof window !== 'undefined' &&\n        window.XDomainRequest && !('withCredentials' in request) &&\n        !isURLSameOrigin(config.url)) {\n      request = new window.XDomainRequest();\n      loadEvent = 'onload';\n      xDomain = true;\n      request.onprogress = function handleProgress() {};\n      request.ontimeout = function handleTimeout() {};\n    }\n\n    // HTTP basic authentication\n    if (config.auth) {\n      var username = config.auth.username || '';\n      var password = config.auth.password || '';\n      requestHeaders.Authorization = 'Basic ' + btoa(username + ':' + password);\n    }\n\n    request.open(config.method.toUpperCase(), buildURL(config.url, config.params, config.paramsSerializer), true);\n\n    // Set the request timeout in MS\n    request.timeout = config.timeout;\n\n    // Listen for ready state\n    request[loadEvent] = function handleLoad() {\n      if (!request || (request.readyState !== 4 && !xDomain)) {\n        return;\n      }\n\n      // The request errored out and we didn't get a response, this will be\n      // handled by onerror instead\n      // With one exception: request that using file: protocol, most browsers\n      // will return status as 0 even though it's a successful request\n      if (request.status === 0 && !(request.responseURL && request.responseURL.indexOf('file:') === 0)) {\n        return;\n      }\n\n      // Prepare the response\n      var responseHeaders = 'getAllResponseHeaders' in request ? parseHeaders(request.getAllResponseHeaders()) : null;\n      var responseData = !config.responseType || config.responseType === 'text' ? request.responseText : request.response;\n      var response = {\n        data: responseData,\n        // IE sends 1223 instead of 204 (https://github.com/mzabriskie/axios/issues/201)\n        status: request.status === 1223 ? 204 : request.status,\n        statusText: request.status === 1223 ? 'No Content' : request.statusText,\n        headers: responseHeaders,\n        config: config,\n        request: request\n      };\n\n      settle(resolve, reject, response);\n\n      // Clean up request\n      request = null;\n    };\n\n    // Handle low level network errors\n    request.onerror = function handleError() {\n      // Real errors are hidden from us by the browser\n      // onerror should only fire if it's a network error\n      reject(createError('Network Error', config));\n\n      // Clean up request\n      request = null;\n    };\n\n    // Handle timeout\n    request.ontimeout = function handleTimeout() {\n      reject(createError('timeout of ' + config.timeout + 'ms exceeded', config, 'ECONNABORTED'));\n\n      // Clean up request\n      request = null;\n    };\n\n    // Add xsrf header\n    // This is only done if running in a standard browser environment.\n    // Specifically not if we're in a web worker, or react-native.\n    if (utils.isStandardBrowserEnv()) {\n      var cookies = require('./../helpers/cookies');\n\n      // Add xsrf header\n      var xsrfValue = (config.withCredentials || isURLSameOrigin(config.url)) && config.xsrfCookieName ?\n          cookies.read(config.xsrfCookieName) :\n          undefined;\n\n      if (xsrfValue) {\n        requestHeaders[config.xsrfHeaderName] = xsrfValue;\n      }\n    }\n\n    // Add headers to the request\n    if ('setRequestHeader' in request) {\n      utils.forEach(requestHeaders, function setRequestHeader(val, key) {\n        if (typeof requestData === 'undefined' && key.toLowerCase() === 'content-type') {\n          // Remove Content-Type if data is undefined\n          delete requestHeaders[key];\n        } else {\n          // Otherwise add header to the request\n          request.setRequestHeader(key, val);\n        }\n      });\n    }\n\n    // Add withCredentials to request if needed\n    if (config.withCredentials) {\n      request.withCredentials = true;\n    }\n\n    // Add responseType to request if needed\n    if (config.responseType) {\n      try {\n        request.responseType = config.responseType;\n      } catch (e) {\n        if (request.responseType !== 'json') {\n          throw e;\n        }\n      }\n    }\n\n    // Handle progress if needed\n    if (typeof config.onDownloadProgress === 'function') {\n      request.addEventListener('progress', config.onDownloadProgress);\n    }\n\n    // Not all browsers support upload events\n    if (typeof config.onUploadProgress === 'function' && request.upload) {\n      request.upload.addEventListener('progress', config.onUploadProgress);\n    }\n\n    if (config.cancelToken) {\n      // Handle cancellation\n      config.cancelToken.promise.then(function onCanceled(cancel) {\n        if (!request) {\n          return;\n        }\n\n        request.abort();\n        reject(cancel);\n        // Clean up request\n        request = null;\n      });\n    }\n\n    if (requestData === undefined) {\n      requestData = null;\n    }\n\n    // Send the request\n    request.send(requestData);\n  });\n};\n","'use strict';\n\nvar utils = require('./utils');\nvar bind = require('./helpers/bind');\nvar Axios = require('./core/Axios');\nvar defaults = require('./defaults');\n\n/**\n * Create an instance of Axios\n *\n * @param {Object} defaultConfig The default config for the instance\n * @return {Axios} A new instance of Axios\n */\nfunction createInstance(defaultConfig) {\n  var context = new Axios(defaultConfig);\n  var instance = bind(Axios.prototype.request, context);\n\n  // Copy axios.prototype to instance\n  utils.extend(instance, Axios.prototype, context);\n\n  // Copy context to instance\n  utils.extend(instance, context);\n\n  return instance;\n}\n\n// Create the default instance to be exported\nvar axios = createInstance(defaults);\n\n// Expose Axios class to allow class inheritance\naxios.Axios = Axios;\n\n// Factory for creating new instances\naxios.create = function create(instanceConfig) {\n  return createInstance(utils.merge(defaults, instanceConfig));\n};\n\n// Expose Cancel & CancelToken\naxios.Cancel = require('./cancel/Cancel');\naxios.CancelToken = require('./cancel/CancelToken');\naxios.isCancel = require('./cancel/isCancel');\n\n// Expose all/spread\naxios.all = function all(promises) {\n  return Promise.all(promises);\n};\naxios.spread = require('./helpers/spread');\n\nmodule.exports = axios;\n\n// Allow use of default import syntax in TypeScript\nmodule.exports.default = axios;\n","'use strict';\n\n/**\n * A `Cancel` is an object that is thrown when an operation is canceled.\n *\n * @class\n * @param {string=} message The message.\n */\nfunction Cancel(message) {\n  this.message = message;\n}\n\nCancel.prototype.toString = function toString() {\n  return 'Cancel' + (this.message ? ': ' + this.message : '');\n};\n\nCancel.prototype.__CANCEL__ = true;\n\nmodule.exports = Cancel;\n","'use strict';\n\nvar Cancel = require('./Cancel');\n\n/**\n * A `CancelToken` is an object that can be used to request cancellation of an operation.\n *\n * @class\n * @param {Function} executor The executor function.\n */\nfunction CancelToken(executor) {\n  if (typeof executor !== 'function') {\n    throw new TypeError('executor must be a function.');\n  }\n\n  var resolvePromise;\n  this.promise = new Promise(function promiseExecutor(resolve) {\n    resolvePromise = resolve;\n  });\n\n  var token = this;\n  executor(function cancel(message) {\n    if (token.reason) {\n      // Cancellation has already been requested\n      return;\n    }\n\n    token.reason = new Cancel(message);\n    resolvePromise(token.reason);\n  });\n}\n\n/**\n * Throws a `Cancel` if cancellation has been requested.\n */\nCancelToken.prototype.throwIfRequested = function throwIfRequested() {\n  if (this.reason) {\n    throw this.reason;\n  }\n};\n\n/**\n * Returns an object that contains a new `CancelToken` and a function that, when called,\n * cancels the `CancelToken`.\n */\nCancelToken.source = function source() {\n  var cancel;\n  var token = new CancelToken(function executor(c) {\n    cancel = c;\n  });\n  return {\n    token: token,\n    cancel: cancel\n  };\n};\n\nmodule.exports = CancelToken;\n","'use strict';\n\nmodule.exports = function isCancel(value) {\n  return !!(value && value.__CANCEL__);\n};\n","'use strict';\n\nvar defaults = require('./../defaults');\nvar utils = require('./../utils');\nvar InterceptorManager = require('./InterceptorManager');\nvar dispatchRequest = require('./dispatchRequest');\nvar isAbsoluteURL = require('./../helpers/isAbsoluteURL');\nvar combineURLs = require('./../helpers/combineURLs');\n\n/**\n * Create a new instance of Axios\n *\n * @param {Object} instanceConfig The default config for the instance\n */\nfunction Axios(instanceConfig) {\n  this.defaults = instanceConfig;\n  this.interceptors = {\n    request: new InterceptorManager(),\n    response: new InterceptorManager()\n  };\n}\n\n/**\n * Dispatch a request\n *\n * @param {Object} config The config specific for this request (merged with this.defaults)\n */\nAxios.prototype.request = function request(config) {\n  /*eslint no-param-reassign:0*/\n  // Allow for axios('example/url'[, config]) a la fetch API\n  if (typeof config === 'string') {\n    config = utils.merge({\n      url: arguments[0]\n    }, arguments[1]);\n  }\n\n  config = utils.merge(defaults, this.defaults, { method: 'get' }, config);\n\n  // Support baseURL config\n  if (config.baseURL && !isAbsoluteURL(config.url)) {\n    config.url = combineURLs(config.baseURL, config.url);\n  }\n\n  // Hook up interceptors middleware\n  var chain = [dispatchRequest, undefined];\n  var promise = Promise.resolve(config);\n\n  this.interceptors.request.forEach(function unshiftRequestInterceptors(interceptor) {\n    chain.unshift(interceptor.fulfilled, interceptor.rejected);\n  });\n\n  this.interceptors.response.forEach(function pushResponseInterceptors(interceptor) {\n    chain.push(interceptor.fulfilled, interceptor.rejected);\n  });\n\n  while (chain.length) {\n    promise = promise.then(chain.shift(), chain.shift());\n  }\n\n  return promise;\n};\n\n// Provide aliases for supported request methods\nutils.forEach(['delete', 'get', 'head'], function forEachMethodNoData(method) {\n  /*eslint func-names:0*/\n  Axios.prototype[method] = function(url, config) {\n    return this.request(utils.merge(config || {}, {\n      method: method,\n      url: url\n    }));\n  };\n});\n\nutils.forEach(['post', 'put', 'patch'], function forEachMethodWithData(method) {\n  /*eslint func-names:0*/\n  Axios.prototype[method] = function(url, data, config) {\n    return this.request(utils.merge(config || {}, {\n      method: method,\n      url: url,\n      data: data\n    }));\n  };\n});\n\nmodule.exports = Axios;\n","'use strict';\n\nvar utils = require('./../utils');\n\nfunction InterceptorManager() {\n  this.handlers = [];\n}\n\n/**\n * Add a new interceptor to the stack\n *\n * @param {Function} fulfilled The function to handle `then` for a `Promise`\n * @param {Function} rejected The function to handle `reject` for a `Promise`\n *\n * @return {Number} An ID used to remove interceptor later\n */\nInterceptorManager.prototype.use = function use(fulfilled, rejected) {\n  this.handlers.push({\n    fulfilled: fulfilled,\n    rejected: rejected\n  });\n  return this.handlers.length - 1;\n};\n\n/**\n * Remove an interceptor from the stack\n *\n * @param {Number} id The ID that was returned by `use`\n */\nInterceptorManager.prototype.eject = function eject(id) {\n  if (this.handlers[id]) {\n    this.handlers[id] = null;\n  }\n};\n\n/**\n * Iterate over all the registered interceptors\n *\n * This method is particularly useful for skipping over any\n * interceptors that may have become `null` calling `eject`.\n *\n * @param {Function} fn The function to call for each interceptor\n */\nInterceptorManager.prototype.forEach = function forEach(fn) {\n  utils.forEach(this.handlers, function forEachHandler(h) {\n    if (h !== null) {\n      fn(h);\n    }\n  });\n};\n\nmodule.exports = InterceptorManager;\n","'use strict';\n\nvar enhanceError = require('./enhanceError');\n\n/**\n * Create an Error with the specified message, config, error code, and response.\n *\n * @param {string} message The error message.\n * @param {Object} config The config.\n * @param {string} [code] The error code (for example, 'ECONNABORTED').\n @ @param {Object} [response] The response.\n * @returns {Error} The created error.\n */\nmodule.exports = function createError(message, config, code, response) {\n  var error = new Error(message);\n  return enhanceError(error, config, code, response);\n};\n","'use strict';\n\nvar utils = require('./../utils');\nvar transformData = require('./transformData');\nvar isCancel = require('../cancel/isCancel');\nvar defaults = require('../defaults');\n\n/**\n * Throws a `Cancel` if cancellation has been requested.\n */\nfunction throwIfCancellationRequested(config) {\n  if (config.cancelToken) {\n    config.cancelToken.throwIfRequested();\n  }\n}\n\n/**\n * Dispatch a request to the server using the configured adapter.\n *\n * @param {object} config The config that is to be used for the request\n * @returns {Promise} The Promise to be fulfilled\n */\nmodule.exports = function dispatchRequest(config) {\n  throwIfCancellationRequested(config);\n\n  // Ensure headers exist\n  config.headers = config.headers || {};\n\n  // Transform request data\n  config.data = transformData(\n    config.data,\n    config.headers,\n    config.transformRequest\n  );\n\n  // Flatten headers\n  config.headers = utils.merge(\n    config.headers.common || {},\n    config.headers[config.method] || {},\n    config.headers || {}\n  );\n\n  utils.forEach(\n    ['delete', 'get', 'head', 'post', 'put', 'patch', 'common'],\n    function cleanHeaderConfig(method) {\n      delete config.headers[method];\n    }\n  );\n\n  var adapter = config.adapter || defaults.adapter;\n\n  return adapter(config).then(function onAdapterResolution(response) {\n    throwIfCancellationRequested(config);\n\n    // Transform response data\n    response.data = transformData(\n      response.data,\n      response.headers,\n      config.transformResponse\n    );\n\n    return response;\n  }, function onAdapterRejection(reason) {\n    if (!isCancel(reason)) {\n      throwIfCancellationRequested(config);\n\n      // Transform response data\n      if (reason && reason.response) {\n        reason.response.data = transformData(\n          reason.response.data,\n          reason.response.headers,\n          config.transformResponse\n        );\n      }\n    }\n\n    return Promise.reject(reason);\n  });\n};\n","'use strict';\n\n/**\n * Update an Error with the specified config, error code, and response.\n *\n * @param {Error} error The error to update.\n * @param {Object} config The config.\n * @param {string} [code] The error code (for example, 'ECONNABORTED').\n @ @param {Object} [response] The response.\n * @returns {Error} The error.\n */\nmodule.exports = function enhanceError(error, config, code, response) {\n  error.config = config;\n  if (code) {\n    error.code = code;\n  }\n  error.response = response;\n  return error;\n};\n","'use strict';\n\nvar createError = require('./createError');\n\n/**\n * Resolve or reject a Promise based on response status.\n *\n * @param {Function} resolve A function that resolves the promise.\n * @param {Function} reject A function that rejects the promise.\n * @param {object} response The response.\n */\nmodule.exports = function settle(resolve, reject, response) {\n  var validateStatus = response.config.validateStatus;\n  // Note: status is not exposed by XDomainRequest\n  if (!response.status || !validateStatus || validateStatus(response.status)) {\n    resolve(response);\n  } else {\n    reject(createError(\n      'Request failed with status code ' + response.status,\n      response.config,\n      null,\n      response\n    ));\n  }\n};\n","'use strict';\n\nvar utils = require('./../utils');\n\n/**\n * Transform the data for a request or a response\n *\n * @param {Object|String} data The data to be transformed\n * @param {Array} headers The headers for the request or response\n * @param {Array|Function} fns A single function or Array of functions\n * @returns {*} The resulting transformed data\n */\nmodule.exports = function transformData(data, headers, fns) {\n  /*eslint no-param-reassign:0*/\n  utils.forEach(fns, function transform(fn) {\n    data = fn(data, headers);\n  });\n\n  return data;\n};\n","'use strict';\n\nvar utils = require('./utils');\nvar normalizeHeaderName = require('./helpers/normalizeHeaderName');\n\nvar PROTECTION_PREFIX = /^\\)\\]\\}',?\\n/;\nvar DEFAULT_CONTENT_TYPE = {\n  'Content-Type': 'application/x-www-form-urlencoded'\n};\n\nfunction setContentTypeIfUnset(headers, value) {\n  if (!utils.isUndefined(headers) && utils.isUndefined(headers['Content-Type'])) {\n    headers['Content-Type'] = value;\n  }\n}\n\nfunction getDefaultAdapter() {\n  var adapter;\n  if (typeof XMLHttpRequest !== 'undefined') {\n    // For browsers use XHR adapter\n    adapter = require('./adapters/xhr');\n  } else if (typeof process !== 'undefined') {\n    // For node use HTTP adapter\n    adapter = require('./adapters/http');\n  }\n  return adapter;\n}\n\nvar defaults = {\n  adapter: getDefaultAdapter(),\n\n  transformRequest: [function transformRequest(data, headers) {\n    normalizeHeaderName(headers, 'Content-Type');\n    if (utils.isFormData(data) ||\n      utils.isArrayBuffer(data) ||\n      utils.isStream(data) ||\n      utils.isFile(data) ||\n      utils.isBlob(data)\n    ) {\n      return data;\n    }\n    if (utils.isArrayBufferView(data)) {\n      return data.buffer;\n    }\n    if (utils.isURLSearchParams(data)) {\n      setContentTypeIfUnset(headers, 'application/x-www-form-urlencoded;charset=utf-8');\n      return data.toString();\n    }\n    if (utils.isObject(data)) {\n      setContentTypeIfUnset(headers, 'application/json;charset=utf-8');\n      return JSON.stringify(data);\n    }\n    return data;\n  }],\n\n  transformResponse: [function transformResponse(data) {\n    /*eslint no-param-reassign:0*/\n    if (typeof data === 'string') {\n      data = data.replace(PROTECTION_PREFIX, '');\n      try {\n        data = JSON.parse(data);\n      } catch (e) { /* Ignore */ }\n    }\n    return data;\n  }],\n\n  timeout: 0,\n\n  xsrfCookieName: 'XSRF-TOKEN',\n  xsrfHeaderName: 'X-XSRF-TOKEN',\n\n  maxContentLength: -1,\n\n  validateStatus: function validateStatus(status) {\n    return status >= 200 && status < 300;\n  }\n};\n\ndefaults.headers = {\n  common: {\n    'Accept': 'application/json, text/plain, */*'\n  }\n};\n\nutils.forEach(['delete', 'get', 'head'], function forEachMehtodNoData(method) {\n  defaults.headers[method] = {};\n});\n\nutils.forEach(['post', 'put', 'patch'], function forEachMethodWithData(method) {\n  defaults.headers[method] = utils.merge(DEFAULT_CONTENT_TYPE);\n});\n\nmodule.exports = defaults;\n","'use strict';\n\nmodule.exports = function bind(fn, thisArg) {\n  return function wrap() {\n    var args = new Array(arguments.length);\n    for (var i = 0; i < args.length; i++) {\n      args[i] = arguments[i];\n    }\n    return fn.apply(thisArg, args);\n  };\n};\n","'use strict';\n\n// btoa polyfill for IE<10 courtesy https://github.com/davidchambers/Base64.js\n\nvar chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=';\n\nfunction E() {\n  this.message = 'String contains an invalid character';\n}\nE.prototype = new Error;\nE.prototype.code = 5;\nE.prototype.name = 'InvalidCharacterError';\n\nfunction btoa(input) {\n  var str = String(input);\n  var output = '';\n  for (\n    // initialize result and counter\n    var block, charCode, idx = 0, map = chars;\n    // if the next str index does not exist:\n    //   change the mapping table to \"=\"\n    //   check if d has no fractional digits\n    str.charAt(idx | 0) || (map = '=', idx % 1);\n    // \"8 - idx % 1 * 8\" generates the sequence 2, 4, 6, 8\n    output += map.charAt(63 & block >> 8 - idx % 1 * 8)\n  ) {\n    charCode = str.charCodeAt(idx += 3 / 4);\n    if (charCode > 0xFF) {\n      throw new E();\n    }\n    block = block << 8 | charCode;\n  }\n  return output;\n}\n\nmodule.exports = btoa;\n","'use strict';\n\nvar utils = require('./../utils');\n\nfunction encode(val) {\n  return encodeURIComponent(val).\n    replace(/%40/gi, '@').\n    replace(/%3A/gi, ':').\n    replace(/%24/g, '$').\n    replace(/%2C/gi, ',').\n    replace(/%20/g, '+').\n    replace(/%5B/gi, '[').\n    replace(/%5D/gi, ']');\n}\n\n/**\n * Build a URL by appending params to the end\n *\n * @param {string} url The base of the url (e.g., http://www.google.com)\n * @param {object} [params] The params to be appended\n * @returns {string} The formatted url\n */\nmodule.exports = function buildURL(url, params, paramsSerializer) {\n  /*eslint no-param-reassign:0*/\n  if (!params) {\n    return url;\n  }\n\n  var serializedParams;\n  if (paramsSerializer) {\n    serializedParams = paramsSerializer(params);\n  } else if (utils.isURLSearchParams(params)) {\n    serializedParams = params.toString();\n  } else {\n    var parts = [];\n\n    utils.forEach(params, function serialize(val, key) {\n      if (val === null || typeof val === 'undefined') {\n        return;\n      }\n\n      if (utils.isArray(val)) {\n        key = key + '[]';\n      }\n\n      if (!utils.isArray(val)) {\n        val = [val];\n      }\n\n      utils.forEach(val, function parseValue(v) {\n        if (utils.isDate(v)) {\n          v = v.toISOString();\n        } else if (utils.isObject(v)) {\n          v = JSON.stringify(v);\n        }\n        parts.push(encode(key) + '=' + encode(v));\n      });\n    });\n\n    serializedParams = parts.join('&');\n  }\n\n  if (serializedParams) {\n    url += (url.indexOf('?') === -1 ? '?' : '&') + serializedParams;\n  }\n\n  return url;\n};\n","'use strict';\n\n/**\n * Creates a new URL by combining the specified URLs\n *\n * @param {string} baseURL The base URL\n * @param {string} relativeURL The relative URL\n * @returns {string} The combined URL\n */\nmodule.exports = function combineURLs(baseURL, relativeURL) {\n  return baseURL.replace(/\\/+$/, '') + '/' + relativeURL.replace(/^\\/+/, '');\n};\n","'use strict';\n\nvar utils = require('./../utils');\n\nmodule.exports = (\n  utils.isStandardBrowserEnv() ?\n\n  // Standard browser envs support document.cookie\n  (function standardBrowserEnv() {\n    return {\n      write: function write(name, value, expires, path, domain, secure) {\n        var cookie = [];\n        cookie.push(name + '=' + encodeURIComponent(value));\n\n        if (utils.isNumber(expires)) {\n          cookie.push('expires=' + new Date(expires).toGMTString());\n        }\n\n        if (utils.isString(path)) {\n          cookie.push('path=' + path);\n        }\n\n        if (utils.isString(domain)) {\n          cookie.push('domain=' + domain);\n        }\n\n        if (secure === true) {\n          cookie.push('secure');\n        }\n\n        document.cookie = cookie.join('; ');\n      },\n\n      read: function read(name) {\n        var match = document.cookie.match(new RegExp('(^|;\\\\s*)(' + name + ')=([^;]*)'));\n        return (match ? decodeURIComponent(match[3]) : null);\n      },\n\n      remove: function remove(name) {\n        this.write(name, '', Date.now() - 86400000);\n      }\n    };\n  })() :\n\n  // Non standard browser env (web workers, react-native) lack needed support.\n  (function nonStandardBrowserEnv() {\n    return {\n      write: function write() {},\n      read: function read() { return null; },\n      remove: function remove() {}\n    };\n  })()\n);\n","'use strict';\n\n/**\n * Determines whether the specified URL is absolute\n *\n * @param {string} url The URL to test\n * @returns {boolean} True if the specified URL is absolute, otherwise false\n */\nmodule.exports = function isAbsoluteURL(url) {\n  // A URL is considered absolute if it begins with \"<scheme>://\" or \"//\" (protocol-relative URL).\n  // RFC 3986 defines scheme name as a sequence of characters beginning with a letter and followed\n  // by any combination of letters, digits, plus, period, or hyphen.\n  return /^([a-z][a-z\\d\\+\\-\\.]*:)?\\/\\//i.test(url);\n};\n","'use strict';\n\nvar utils = require('./../utils');\n\nmodule.exports = (\n  utils.isStandardBrowserEnv() ?\n\n  // Standard browser envs have full support of the APIs needed to test\n  // whether the request URL is of the same origin as current location.\n  (function standardBrowserEnv() {\n    var msie = /(msie|trident)/i.test(navigator.userAgent);\n    var urlParsingNode = document.createElement('a');\n    var originURL;\n\n    /**\n    * Parse a URL to discover it's components\n    *\n    * @param {String} url The URL to be parsed\n    * @returns {Object}\n    */\n    function resolveURL(url) {\n      var href = url;\n\n      if (msie) {\n        // IE needs attribute set twice to normalize properties\n        urlParsingNode.setAttribute('href', href);\n        href = urlParsingNode.href;\n      }\n\n      urlParsingNode.setAttribute('href', href);\n\n      // urlParsingNode provides the UrlUtils interface - http://url.spec.whatwg.org/#urlutils\n      return {\n        href: urlParsingNode.href,\n        protocol: urlParsingNode.protocol ? urlParsingNode.protocol.replace(/:$/, '') : '',\n        host: urlParsingNode.host,\n        search: urlParsingNode.search ? urlParsingNode.search.replace(/^\\?/, '') : '',\n        hash: urlParsingNode.hash ? urlParsingNode.hash.replace(/^#/, '') : '',\n        hostname: urlParsingNode.hostname,\n        port: urlParsingNode.port,\n        pathname: (urlParsingNode.pathname.charAt(0) === '/') ?\n                  urlParsingNode.pathname :\n                  '/' + urlParsingNode.pathname\n      };\n    }\n\n    originURL = resolveURL(window.location.href);\n\n    /**\n    * Determine if a URL shares the same origin as the current location\n    *\n    * @param {String} requestURL The URL to test\n    * @returns {boolean} True if URL shares the same origin, otherwise false\n    */\n    return function isURLSameOrigin(requestURL) {\n      var parsed = (utils.isString(requestURL)) ? resolveURL(requestURL) : requestURL;\n      return (parsed.protocol === originURL.protocol &&\n            parsed.host === originURL.host);\n    };\n  })() :\n\n  // Non standard browser envs (web workers, react-native) lack needed support.\n  (function nonStandardBrowserEnv() {\n    return function isURLSameOrigin() {\n      return true;\n    };\n  })()\n);\n","'use strict';\n\nvar utils = require('../utils');\n\nmodule.exports = function normalizeHeaderName(headers, normalizedName) {\n  utils.forEach(headers, function processHeader(value, name) {\n    if (name !== normalizedName && name.toUpperCase() === normalizedName.toUpperCase()) {\n      headers[normalizedName] = value;\n      delete headers[name];\n    }\n  });\n};\n","'use strict';\n\nvar utils = require('./../utils');\n\n/**\n * Parse headers into an object\n *\n * ```\n * Date: Wed, 27 Aug 2014 08:58:49 GMT\n * Content-Type: application/json\n * Connection: keep-alive\n * Transfer-Encoding: chunked\n * ```\n *\n * @param {String} headers Headers needing to be parsed\n * @returns {Object} Headers parsed into an object\n */\nmodule.exports = function parseHeaders(headers) {\n  var parsed = {};\n  var key;\n  var val;\n  var i;\n\n  if (!headers) { return parsed; }\n\n  utils.forEach(headers.split('\\n'), function parser(line) {\n    i = line.indexOf(':');\n    key = utils.trim(line.substr(0, i)).toLowerCase();\n    val = utils.trim(line.substr(i + 1));\n\n    if (key) {\n      parsed[key] = parsed[key] ? parsed[key] + ', ' + val : val;\n    }\n  });\n\n  return parsed;\n};\n","'use strict';\n\n/**\n * Syntactic sugar for invoking a function and expanding an array for arguments.\n *\n * Common use case would be to use `Function.prototype.apply`.\n *\n *  ```js\n *  function f(x, y, z) {}\n *  var args = [1, 2, 3];\n *  f.apply(null, args);\n *  ```\n *\n * With `spread` this example can be re-written.\n *\n *  ```js\n *  spread(function(x, y, z) {})([1, 2, 3]);\n *  ```\n *\n * @param {Function} callback\n * @returns {Function}\n */\nmodule.exports = function spread(callback) {\n  return function wrap(arr) {\n    return callback.apply(null, arr);\n  };\n};\n","'use strict';\n\nvar bind = require('./helpers/bind');\n\n/*global toString:true*/\n\n// utils is a library of generic helper functions non-specific to axios\n\nvar toString = Object.prototype.toString;\n\n/**\n * Determine if a value is an Array\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if value is an Array, otherwise false\n */\nfunction isArray(val) {\n  return toString.call(val) === '[object Array]';\n}\n\n/**\n * Determine if a value is an ArrayBuffer\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if value is an ArrayBuffer, otherwise false\n */\nfunction isArrayBuffer(val) {\n  return toString.call(val) === '[object ArrayBuffer]';\n}\n\n/**\n * Determine if a value is a FormData\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if value is an FormData, otherwise false\n */\nfunction isFormData(val) {\n  return (typeof FormData !== 'undefined') && (val instanceof FormData);\n}\n\n/**\n * Determine if a value is a view on an ArrayBuffer\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if value is a view on an ArrayBuffer, otherwise false\n */\nfunction isArrayBufferView(val) {\n  var result;\n  if ((typeof ArrayBuffer !== 'undefined') && (ArrayBuffer.isView)) {\n    result = ArrayBuffer.isView(val);\n  } else {\n    result = (val) && (val.buffer) && (val.buffer instanceof ArrayBuffer);\n  }\n  return result;\n}\n\n/**\n * Determine if a value is a String\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if value is a String, otherwise false\n */\nfunction isString(val) {\n  return typeof val === 'string';\n}\n\n/**\n * Determine if a value is a Number\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if value is a Number, otherwise false\n */\nfunction isNumber(val) {\n  return typeof val === 'number';\n}\n\n/**\n * Determine if a value is undefined\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if the value is undefined, otherwise false\n */\nfunction isUndefined(val) {\n  return typeof val === 'undefined';\n}\n\n/**\n * Determine if a value is an Object\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if value is an Object, otherwise false\n */\nfunction isObject(val) {\n  return val !== null && typeof val === 'object';\n}\n\n/**\n * Determine if a value is a Date\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if value is a Date, otherwise false\n */\nfunction isDate(val) {\n  return toString.call(val) === '[object Date]';\n}\n\n/**\n * Determine if a value is a File\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if value is a File, otherwise false\n */\nfunction isFile(val) {\n  return toString.call(val) === '[object File]';\n}\n\n/**\n * Determine if a value is a Blob\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if value is a Blob, otherwise false\n */\nfunction isBlob(val) {\n  return toString.call(val) === '[object Blob]';\n}\n\n/**\n * Determine if a value is a Function\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if value is a Function, otherwise false\n */\nfunction isFunction(val) {\n  return toString.call(val) === '[object Function]';\n}\n\n/**\n * Determine if a value is a Stream\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if value is a Stream, otherwise false\n */\nfunction isStream(val) {\n  return isObject(val) && isFunction(val.pipe);\n}\n\n/**\n * Determine if a value is a URLSearchParams object\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if value is a URLSearchParams object, otherwise false\n */\nfunction isURLSearchParams(val) {\n  return typeof URLSearchParams !== 'undefined' && val instanceof URLSearchParams;\n}\n\n/**\n * Trim excess whitespace off the beginning and end of a string\n *\n * @param {String} str The String to trim\n * @returns {String} The String freed of excess whitespace\n */\nfunction trim(str) {\n  return str.replace(/^\\s*/, '').replace(/\\s*$/, '');\n}\n\n/**\n * Determine if we're running in a standard browser environment\n *\n * This allows axios to run in a web worker, and react-native.\n * Both environments support XMLHttpRequest, but not fully standard globals.\n *\n * web workers:\n *  typeof window -> undefined\n *  typeof document -> undefined\n *\n * react-native:\n *  typeof document.createElement -> undefined\n */\nfunction isStandardBrowserEnv() {\n  return (\n    typeof window !== 'undefined' &&\n    typeof document !== 'undefined' &&\n    typeof document.createElement === 'function'\n  );\n}\n\n/**\n * Iterate over an Array or an Object invoking a function for each item.\n *\n * If `obj` is an Array callback will be called passing\n * the value, index, and complete array for each item.\n *\n * If 'obj' is an Object callback will be called passing\n * the value, key, and complete object for each property.\n *\n * @param {Object|Array} obj The object to iterate\n * @param {Function} fn The callback to invoke for each item\n */\nfunction forEach(obj, fn) {\n  // Don't bother if no value provided\n  if (obj === null || typeof obj === 'undefined') {\n    return;\n  }\n\n  // Force an array if not already something iterable\n  if (typeof obj !== 'object' && !isArray(obj)) {\n    /*eslint no-param-reassign:0*/\n    obj = [obj];\n  }\n\n  if (isArray(obj)) {\n    // Iterate over array values\n    for (var i = 0, l = obj.length; i < l; i++) {\n      fn.call(null, obj[i], i, obj);\n    }\n  } else {\n    // Iterate over object keys\n    for (var key in obj) {\n      if (Object.prototype.hasOwnProperty.call(obj, key)) {\n        fn.call(null, obj[key], key, obj);\n      }\n    }\n  }\n}\n\n/**\n * Accepts varargs expecting each argument to be an object, then\n * immutably merges the properties of each object and returns result.\n *\n * When multiple objects contain the same key the later object in\n * the arguments list will take precedence.\n *\n * Example:\n *\n * ```js\n * var result = merge({foo: 123}, {foo: 456});\n * console.log(result.foo); // outputs 456\n * ```\n *\n * @param {Object} obj1 Object to merge\n * @returns {Object} Result of all merge properties\n */\nfunction merge(/* obj1, obj2, obj3, ... */) {\n  var result = {};\n  function assignValue(val, key) {\n    if (typeof result[key] === 'object' && typeof val === 'object') {\n      result[key] = merge(result[key], val);\n    } else {\n      result[key] = val;\n    }\n  }\n\n  for (var i = 0, l = arguments.length; i < l; i++) {\n    forEach(arguments[i], assignValue);\n  }\n  return result;\n}\n\n/**\n * Extends object a by mutably adding to it the properties of object b.\n *\n * @param {Object} a The object to be extended\n * @param {Object} b The object to copy properties from\n * @param {Object} thisArg The object to bind function to\n * @return {Object} The resulting value of object a\n */\nfunction extend(a, b, thisArg) {\n  forEach(b, function assignValue(val, key) {\n    if (thisArg && typeof val === 'function') {\n      a[key] = bind(val, thisArg);\n    } else {\n      a[key] = val;\n    }\n  });\n  return a;\n}\n\nmodule.exports = {\n  isArray: isArray,\n  isArrayBuffer: isArrayBuffer,\n  isFormData: isFormData,\n  isArrayBufferView: isArrayBufferView,\n  isString: isString,\n  isNumber: isNumber,\n  isObject: isObject,\n  isUndefined: isUndefined,\n  isDate: isDate,\n  isFile: isFile,\n  isBlob: isBlob,\n  isFunction: isFunction,\n  isStream: isStream,\n  isURLSearchParams: isURLSearchParams,\n  isStandardBrowserEnv: isStandardBrowserEnv,\n  forEach: forEach,\n  merge: merge,\n  extend: extend,\n  trim: trim\n};\n","'use strict'\n\nexports.byteLength = byteLength\nexports.toByteArray = toByteArray\nexports.fromByteArray = fromByteArray\n\nvar lookup = []\nvar revLookup = []\nvar Arr = typeof Uint8Array !== 'undefined' ? Uint8Array : Array\n\nvar code = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'\nfor (var i = 0, len = code.length; i < len; ++i) {\n  lookup[i] = code[i]\n  revLookup[code.charCodeAt(i)] = i\n}\n\nrevLookup['-'.charCodeAt(0)] = 62\nrevLookup['_'.charCodeAt(0)] = 63\n\nfunction placeHoldersCount (b64) {\n  var len = b64.length\n  if (len % 4 > 0) {\n    throw new Error('Invalid string. Length must be a multiple of 4')\n  }\n\n  // the number of equal signs (place holders)\n  // if there are two placeholders, than the two characters before it\n  // represent one byte\n  // if there is only one, then the three characters before it represent 2 bytes\n  // this is just a cheap hack to not do indexOf twice\n  return b64[len - 2] === '=' ? 2 : b64[len - 1] === '=' ? 1 : 0\n}\n\nfunction byteLength (b64) {\n  // base64 is 4/3 + up to two characters of the original data\n  return b64.length * 3 / 4 - placeHoldersCount(b64)\n}\n\nfunction toByteArray (b64) {\n  var i, j, l, tmp, placeHolders, arr\n  var len = b64.length\n  placeHolders = placeHoldersCount(b64)\n\n  arr = new Arr(len * 3 / 4 - placeHolders)\n\n  // if there are placeholders, only get up to the last complete 4 chars\n  l = placeHolders > 0 ? len - 4 : len\n\n  var L = 0\n\n  for (i = 0, j = 0; i < l; i += 4, j += 3) {\n    tmp = (revLookup[b64.charCodeAt(i)] << 18) | (revLookup[b64.charCodeAt(i + 1)] << 12) | (revLookup[b64.charCodeAt(i + 2)] << 6) | revLookup[b64.charCodeAt(i + 3)]\n    arr[L++] = (tmp >> 16) & 0xFF\n    arr[L++] = (tmp >> 8) & 0xFF\n    arr[L++] = tmp & 0xFF\n  }\n\n  if (placeHolders === 2) {\n    tmp = (revLookup[b64.charCodeAt(i)] << 2) | (revLookup[b64.charCodeAt(i + 1)] >> 4)\n    arr[L++] = tmp & 0xFF\n  } else if (placeHolders === 1) {\n    tmp = (revLookup[b64.charCodeAt(i)] << 10) | (revLookup[b64.charCodeAt(i + 1)] << 4) | (revLookup[b64.charCodeAt(i + 2)] >> 2)\n    arr[L++] = (tmp >> 8) & 0xFF\n    arr[L++] = tmp & 0xFF\n  }\n\n  return arr\n}\n\nfunction tripletToBase64 (num) {\n  return lookup[num >> 18 & 0x3F] + lookup[num >> 12 & 0x3F] + lookup[num >> 6 & 0x3F] + lookup[num & 0x3F]\n}\n\nfunction encodeChunk (uint8, start, end) {\n  var tmp\n  var output = []\n  for (var i = start; i < end; i += 3) {\n    tmp = (uint8[i] << 16) + (uint8[i + 1] << 8) + (uint8[i + 2])\n    output.push(tripletToBase64(tmp))\n  }\n  return output.join('')\n}\n\nfunction fromByteArray (uint8) {\n  var tmp\n  var len = uint8.length\n  var extraBytes = len % 3 // if we have 1 byte left, pad 2 bytes\n  var output = ''\n  var parts = []\n  var maxChunkLength = 16383 // must be multiple of 3\n\n  // go through the array every three bytes, we'll deal with trailing stuff later\n  for (var i = 0, len2 = len - extraBytes; i < len2; i += maxChunkLength) {\n    parts.push(encodeChunk(uint8, i, (i + maxChunkLength) > len2 ? len2 : (i + maxChunkLength)))\n  }\n\n  // pad the end with zeros, but make sure to not forget the extra bytes\n  if (extraBytes === 1) {\n    tmp = uint8[len - 1]\n    output += lookup[tmp >> 2]\n    output += lookup[(tmp << 4) & 0x3F]\n    output += '=='\n  } else if (extraBytes === 2) {\n    tmp = (uint8[len - 2] << 8) + (uint8[len - 1])\n    output += lookup[tmp >> 10]\n    output += lookup[(tmp >> 4) & 0x3F]\n    output += lookup[(tmp << 2) & 0x3F]\n    output += '='\n  }\n\n  parts.push(output)\n\n  return parts.join('')\n}\n","/*!\n * The buffer module from node.js, for the browser.\n *\n * @author   Feross Aboukhadijeh <feross@feross.org> <http://feross.org>\n * @license  MIT\n */\n/* eslint-disable no-proto */\n\n'use strict'\n\nvar base64 = require('base64-js')\nvar ieee754 = require('ieee754')\nvar isArray = require('isarray')\n\nexports.Buffer = Buffer\nexports.SlowBuffer = SlowBuffer\nexports.INSPECT_MAX_BYTES = 50\n\n/**\n * If `Buffer.TYPED_ARRAY_SUPPORT`:\n *   === true    Use Uint8Array implementation (fastest)\n *   === false   Use Object implementation (most compatible, even IE6)\n *\n * Browsers that support typed arrays are IE 10+, Firefox 4+, Chrome 7+, Safari 5.1+,\n * Opera 11.6+, iOS 4.2+.\n *\n * Due to various browser bugs, sometimes the Object implementation will be used even\n * when the browser supports typed arrays.\n *\n * Note:\n *\n *   - Firefox 4-29 lacks support for adding new properties to `Uint8Array` instances,\n *     See: https://bugzilla.mozilla.org/show_bug.cgi?id=695438.\n *\n *   - Chrome 9-10 is missing the `TypedArray.prototype.subarray` function.\n *\n *   - IE10 has a broken `TypedArray.prototype.subarray` function which returns arrays of\n *     incorrect length in some situations.\n\n * We detect these buggy browsers and set `Buffer.TYPED_ARRAY_SUPPORT` to `false` so they\n * get the Object implementation, which is slower but behaves correctly.\n */\nBuffer.TYPED_ARRAY_SUPPORT = global.TYPED_ARRAY_SUPPORT !== undefined\n  ? global.TYPED_ARRAY_SUPPORT\n  : typedArraySupport()\n\n/*\n * Export kMaxLength after typed array support is determined.\n */\nexports.kMaxLength = kMaxLength()\n\nfunction typedArraySupport () {\n  try {\n    var arr = new Uint8Array(1)\n    arr.__proto__ = {__proto__: Uint8Array.prototype, foo: function () { return 42 }}\n    return arr.foo() === 42 && // typed array instances can be augmented\n        typeof arr.subarray === 'function' && // chrome 9-10 lack `subarray`\n        arr.subarray(1, 1).byteLength === 0 // ie10 has broken `subarray`\n  } catch (e) {\n    return false\n  }\n}\n\nfunction kMaxLength () {\n  return Buffer.TYPED_ARRAY_SUPPORT\n    ? 0x7fffffff\n    : 0x3fffffff\n}\n\nfunction createBuffer (that, length) {\n  if (kMaxLength() < length) {\n    throw new RangeError('Invalid typed array length')\n  }\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    // Return an augmented `Uint8Array` instance, for best performance\n    that = new Uint8Array(length)\n    that.__proto__ = Buffer.prototype\n  } else {\n    // Fallback: Return an object instance of the Buffer class\n    if (that === null) {\n      that = new Buffer(length)\n    }\n    that.length = length\n  }\n\n  return that\n}\n\n/**\n * The Buffer constructor returns instances of `Uint8Array` that have their\n * prototype changed to `Buffer.prototype`. Furthermore, `Buffer` is a subclass of\n * `Uint8Array`, so the returned instances will have all the node `Buffer` methods\n * and the `Uint8Array` methods. Square bracket notation works as expected -- it\n * returns a single octet.\n *\n * The `Uint8Array` prototype remains unmodified.\n */\n\nfunction Buffer (arg, encodingOrOffset, length) {\n  if (!Buffer.TYPED_ARRAY_SUPPORT && !(this instanceof Buffer)) {\n    return new Buffer(arg, encodingOrOffset, length)\n  }\n\n  // Common case.\n  if (typeof arg === 'number') {\n    if (typeof encodingOrOffset === 'string') {\n      throw new Error(\n        'If encoding is specified then the first argument must be a string'\n      )\n    }\n    return allocUnsafe(this, arg)\n  }\n  return from(this, arg, encodingOrOffset, length)\n}\n\nBuffer.poolSize = 8192 // not used by this implementation\n\n// TODO: Legacy, not needed anymore. Remove in next major version.\nBuffer._augment = function (arr) {\n  arr.__proto__ = Buffer.prototype\n  return arr\n}\n\nfunction from (that, value, encodingOrOffset, length) {\n  if (typeof value === 'number') {\n    throw new TypeError('\"value\" argument must not be a number')\n  }\n\n  if (typeof ArrayBuffer !== 'undefined' && value instanceof ArrayBuffer) {\n    return fromArrayBuffer(that, value, encodingOrOffset, length)\n  }\n\n  if (typeof value === 'string') {\n    return fromString(that, value, encodingOrOffset)\n  }\n\n  return fromObject(that, value)\n}\n\n/**\n * Functionally equivalent to Buffer(arg, encoding) but throws a TypeError\n * if value is a number.\n * Buffer.from(str[, encoding])\n * Buffer.from(array)\n * Buffer.from(buffer)\n * Buffer.from(arrayBuffer[, byteOffset[, length]])\n **/\nBuffer.from = function (value, encodingOrOffset, length) {\n  return from(null, value, encodingOrOffset, length)\n}\n\nif (Buffer.TYPED_ARRAY_SUPPORT) {\n  Buffer.prototype.__proto__ = Uint8Array.prototype\n  Buffer.__proto__ = Uint8Array\n  if (typeof Symbol !== 'undefined' && Symbol.species &&\n      Buffer[Symbol.species] === Buffer) {\n    // Fix subarray() in ES2016. See: https://github.com/feross/buffer/pull/97\n    Object.defineProperty(Buffer, Symbol.species, {\n      value: null,\n      configurable: true\n    })\n  }\n}\n\nfunction assertSize (size) {\n  if (typeof size !== 'number') {\n    throw new TypeError('\"size\" argument must be a number')\n  } else if (size < 0) {\n    throw new RangeError('\"size\" argument must not be negative')\n  }\n}\n\nfunction alloc (that, size, fill, encoding) {\n  assertSize(size)\n  if (size <= 0) {\n    return createBuffer(that, size)\n  }\n  if (fill !== undefined) {\n    // Only pay attention to encoding if it's a string. This\n    // prevents accidentally sending in a number that would\n    // be interpretted as a start offset.\n    return typeof encoding === 'string'\n      ? createBuffer(that, size).fill(fill, encoding)\n      : createBuffer(that, size).fill(fill)\n  }\n  return createBuffer(that, size)\n}\n\n/**\n * Creates a new filled Buffer instance.\n * alloc(size[, fill[, encoding]])\n **/\nBuffer.alloc = function (size, fill, encoding) {\n  return alloc(null, size, fill, encoding)\n}\n\nfunction allocUnsafe (that, size) {\n  assertSize(size)\n  that = createBuffer(that, size < 0 ? 0 : checked(size) | 0)\n  if (!Buffer.TYPED_ARRAY_SUPPORT) {\n    for (var i = 0; i < size; ++i) {\n      that[i] = 0\n    }\n  }\n  return that\n}\n\n/**\n * Equivalent to Buffer(num), by default creates a non-zero-filled Buffer instance.\n * */\nBuffer.allocUnsafe = function (size) {\n  return allocUnsafe(null, size)\n}\n/**\n * Equivalent to SlowBuffer(num), by default creates a non-zero-filled Buffer instance.\n */\nBuffer.allocUnsafeSlow = function (size) {\n  return allocUnsafe(null, size)\n}\n\nfunction fromString (that, string, encoding) {\n  if (typeof encoding !== 'string' || encoding === '') {\n    encoding = 'utf8'\n  }\n\n  if (!Buffer.isEncoding(encoding)) {\n    throw new TypeError('\"encoding\" must be a valid string encoding')\n  }\n\n  var length = byteLength(string, encoding) | 0\n  that = createBuffer(that, length)\n\n  var actual = that.write(string, encoding)\n\n  if (actual !== length) {\n    // Writing a hex string, for example, that contains invalid characters will\n    // cause everything after the first invalid character to be ignored. (e.g.\n    // 'abxxcd' will be treated as 'ab')\n    that = that.slice(0, actual)\n  }\n\n  return that\n}\n\nfunction fromArrayLike (that, array) {\n  var length = array.length < 0 ? 0 : checked(array.length) | 0\n  that = createBuffer(that, length)\n  for (var i = 0; i < length; i += 1) {\n    that[i] = array[i] & 255\n  }\n  return that\n}\n\nfunction fromArrayBuffer (that, array, byteOffset, length) {\n  array.byteLength // this throws if `array` is not a valid ArrayBuffer\n\n  if (byteOffset < 0 || array.byteLength < byteOffset) {\n    throw new RangeError('\\'offset\\' is out of bounds')\n  }\n\n  if (array.byteLength < byteOffset + (length || 0)) {\n    throw new RangeError('\\'length\\' is out of bounds')\n  }\n\n  if (byteOffset === undefined && length === undefined) {\n    array = new Uint8Array(array)\n  } else if (length === undefined) {\n    array = new Uint8Array(array, byteOffset)\n  } else {\n    array = new Uint8Array(array, byteOffset, length)\n  }\n\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    // Return an augmented `Uint8Array` instance, for best performance\n    that = array\n    that.__proto__ = Buffer.prototype\n  } else {\n    // Fallback: Return an object instance of the Buffer class\n    that = fromArrayLike(that, array)\n  }\n  return that\n}\n\nfunction fromObject (that, obj) {\n  if (Buffer.isBuffer(obj)) {\n    var len = checked(obj.length) | 0\n    that = createBuffer(that, len)\n\n    if (that.length === 0) {\n      return that\n    }\n\n    obj.copy(that, 0, 0, len)\n    return that\n  }\n\n  if (obj) {\n    if ((typeof ArrayBuffer !== 'undefined' &&\n        obj.buffer instanceof ArrayBuffer) || 'length' in obj) {\n      if (typeof obj.length !== 'number' || isnan(obj.length)) {\n        return createBuffer(that, 0)\n      }\n      return fromArrayLike(that, obj)\n    }\n\n    if (obj.type === 'Buffer' && isArray(obj.data)) {\n      return fromArrayLike(that, obj.data)\n    }\n  }\n\n  throw new TypeError('First argument must be a string, Buffer, ArrayBuffer, Array, or array-like object.')\n}\n\nfunction checked (length) {\n  // Note: cannot use `length < kMaxLength()` here because that fails when\n  // length is NaN (which is otherwise coerced to zero.)\n  if (length >= kMaxLength()) {\n    throw new RangeError('Attempt to allocate Buffer larger than maximum ' +\n                         'size: 0x' + kMaxLength().toString(16) + ' bytes')\n  }\n  return length | 0\n}\n\nfunction SlowBuffer (length) {\n  if (+length != length) { // eslint-disable-line eqeqeq\n    length = 0\n  }\n  return Buffer.alloc(+length)\n}\n\nBuffer.isBuffer = function isBuffer (b) {\n  return !!(b != null && b._isBuffer)\n}\n\nBuffer.compare = function compare (a, b) {\n  if (!Buffer.isBuffer(a) || !Buffer.isBuffer(b)) {\n    throw new TypeError('Arguments must be Buffers')\n  }\n\n  if (a === b) return 0\n\n  var x = a.length\n  var y = b.length\n\n  for (var i = 0, len = Math.min(x, y); i < len; ++i) {\n    if (a[i] !== b[i]) {\n      x = a[i]\n      y = b[i]\n      break\n    }\n  }\n\n  if (x < y) return -1\n  if (y < x) return 1\n  return 0\n}\n\nBuffer.isEncoding = function isEncoding (encoding) {\n  switch (String(encoding).toLowerCase()) {\n    case 'hex':\n    case 'utf8':\n    case 'utf-8':\n    case 'ascii':\n    case 'latin1':\n    case 'binary':\n    case 'base64':\n    case 'ucs2':\n    case 'ucs-2':\n    case 'utf16le':\n    case 'utf-16le':\n      return true\n    default:\n      return false\n  }\n}\n\nBuffer.concat = function concat (list, length) {\n  if (!isArray(list)) {\n    throw new TypeError('\"list\" argument must be an Array of Buffers')\n  }\n\n  if (list.length === 0) {\n    return Buffer.alloc(0)\n  }\n\n  var i\n  if (length === undefined) {\n    length = 0\n    for (i = 0; i < list.length; ++i) {\n      length += list[i].length\n    }\n  }\n\n  var buffer = Buffer.allocUnsafe(length)\n  var pos = 0\n  for (i = 0; i < list.length; ++i) {\n    var buf = list[i]\n    if (!Buffer.isBuffer(buf)) {\n      throw new TypeError('\"list\" argument must be an Array of Buffers')\n    }\n    buf.copy(buffer, pos)\n    pos += buf.length\n  }\n  return buffer\n}\n\nfunction byteLength (string, encoding) {\n  if (Buffer.isBuffer(string)) {\n    return string.length\n  }\n  if (typeof ArrayBuffer !== 'undefined' && typeof ArrayBuffer.isView === 'function' &&\n      (ArrayBuffer.isView(string) || string instanceof ArrayBuffer)) {\n    return string.byteLength\n  }\n  if (typeof string !== 'string') {\n    string = '' + string\n  }\n\n  var len = string.length\n  if (len === 0) return 0\n\n  // Use a for loop to avoid recursion\n  var loweredCase = false\n  for (;;) {\n    switch (encoding) {\n      case 'ascii':\n      case 'latin1':\n      case 'binary':\n        return len\n      case 'utf8':\n      case 'utf-8':\n      case undefined:\n        return utf8ToBytes(string).length\n      case 'ucs2':\n      case 'ucs-2':\n      case 'utf16le':\n      case 'utf-16le':\n        return len * 2\n      case 'hex':\n        return len >>> 1\n      case 'base64':\n        return base64ToBytes(string).length\n      default:\n        if (loweredCase) return utf8ToBytes(string).length // assume utf8\n        encoding = ('' + encoding).toLowerCase()\n        loweredCase = true\n    }\n  }\n}\nBuffer.byteLength = byteLength\n\nfunction slowToString (encoding, start, end) {\n  var loweredCase = false\n\n  // No need to verify that \"this.length <= MAX_UINT32\" since it's a read-only\n  // property of a typed array.\n\n  // This behaves neither like String nor Uint8Array in that we set start/end\n  // to their upper/lower bounds if the value passed is out of range.\n  // undefined is handled specially as per ECMA-262 6th Edition,\n  // Section 13.3.3.7 Runtime Semantics: KeyedBindingInitialization.\n  if (start === undefined || start < 0) {\n    start = 0\n  }\n  // Return early if start > this.length. Done here to prevent potential uint32\n  // coercion fail below.\n  if (start > this.length) {\n    return ''\n  }\n\n  if (end === undefined || end > this.length) {\n    end = this.length\n  }\n\n  if (end <= 0) {\n    return ''\n  }\n\n  // Force coersion to uint32. This will also coerce falsey/NaN values to 0.\n  end >>>= 0\n  start >>>= 0\n\n  if (end <= start) {\n    return ''\n  }\n\n  if (!encoding) encoding = 'utf8'\n\n  while (true) {\n    switch (encoding) {\n      case 'hex':\n        return hexSlice(this, start, end)\n\n      case 'utf8':\n      case 'utf-8':\n        return utf8Slice(this, start, end)\n\n      case 'ascii':\n        return asciiSlice(this, start, end)\n\n      case 'latin1':\n      case 'binary':\n        return latin1Slice(this, start, end)\n\n      case 'base64':\n        return base64Slice(this, start, end)\n\n      case 'ucs2':\n      case 'ucs-2':\n      case 'utf16le':\n      case 'utf-16le':\n        return utf16leSlice(this, start, end)\n\n      default:\n        if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)\n        encoding = (encoding + '').toLowerCase()\n        loweredCase = true\n    }\n  }\n}\n\n// The property is used by `Buffer.isBuffer` and `is-buffer` (in Safari 5-7) to detect\n// Buffer instances.\nBuffer.prototype._isBuffer = true\n\nfunction swap (b, n, m) {\n  var i = b[n]\n  b[n] = b[m]\n  b[m] = i\n}\n\nBuffer.prototype.swap16 = function swap16 () {\n  var len = this.length\n  if (len % 2 !== 0) {\n    throw new RangeError('Buffer size must be a multiple of 16-bits')\n  }\n  for (var i = 0; i < len; i += 2) {\n    swap(this, i, i + 1)\n  }\n  return this\n}\n\nBuffer.prototype.swap32 = function swap32 () {\n  var len = this.length\n  if (len % 4 !== 0) {\n    throw new RangeError('Buffer size must be a multiple of 32-bits')\n  }\n  for (var i = 0; i < len; i += 4) {\n    swap(this, i, i + 3)\n    swap(this, i + 1, i + 2)\n  }\n  return this\n}\n\nBuffer.prototype.swap64 = function swap64 () {\n  var len = this.length\n  if (len % 8 !== 0) {\n    throw new RangeError('Buffer size must be a multiple of 64-bits')\n  }\n  for (var i = 0; i < len; i += 8) {\n    swap(this, i, i + 7)\n    swap(this, i + 1, i + 6)\n    swap(this, i + 2, i + 5)\n    swap(this, i + 3, i + 4)\n  }\n  return this\n}\n\nBuffer.prototype.toString = function toString () {\n  var length = this.length | 0\n  if (length === 0) return ''\n  if (arguments.length === 0) return utf8Slice(this, 0, length)\n  return slowToString.apply(this, arguments)\n}\n\nBuffer.prototype.equals = function equals (b) {\n  if (!Buffer.isBuffer(b)) throw new TypeError('Argument must be a Buffer')\n  if (this === b) return true\n  return Buffer.compare(this, b) === 0\n}\n\nBuffer.prototype.inspect = function inspect () {\n  var str = ''\n  var max = exports.INSPECT_MAX_BYTES\n  if (this.length > 0) {\n    str = this.toString('hex', 0, max).match(/.{2}/g).join(' ')\n    if (this.length > max) str += ' ... '\n  }\n  return '<Buffer ' + str + '>'\n}\n\nBuffer.prototype.compare = function compare (target, start, end, thisStart, thisEnd) {\n  if (!Buffer.isBuffer(target)) {\n    throw new TypeError('Argument must be a Buffer')\n  }\n\n  if (start === undefined) {\n    start = 0\n  }\n  if (end === undefined) {\n    end = target ? target.length : 0\n  }\n  if (thisStart === undefined) {\n    thisStart = 0\n  }\n  if (thisEnd === undefined) {\n    thisEnd = this.length\n  }\n\n  if (start < 0 || end > target.length || thisStart < 0 || thisEnd > this.length) {\n    throw new RangeError('out of range index')\n  }\n\n  if (thisStart >= thisEnd && start >= end) {\n    return 0\n  }\n  if (thisStart >= thisEnd) {\n    return -1\n  }\n  if (start >= end) {\n    return 1\n  }\n\n  start >>>= 0\n  end >>>= 0\n  thisStart >>>= 0\n  thisEnd >>>= 0\n\n  if (this === target) return 0\n\n  var x = thisEnd - thisStart\n  var y = end - start\n  var len = Math.min(x, y)\n\n  var thisCopy = this.slice(thisStart, thisEnd)\n  var targetCopy = target.slice(start, end)\n\n  for (var i = 0; i < len; ++i) {\n    if (thisCopy[i] !== targetCopy[i]) {\n      x = thisCopy[i]\n      y = targetCopy[i]\n      break\n    }\n  }\n\n  if (x < y) return -1\n  if (y < x) return 1\n  return 0\n}\n\n// Finds either the first index of `val` in `buffer` at offset >= `byteOffset`,\n// OR the last index of `val` in `buffer` at offset <= `byteOffset`.\n//\n// Arguments:\n// - buffer - a Buffer to search\n// - val - a string, Buffer, or number\n// - byteOffset - an index into `buffer`; will be clamped to an int32\n// - encoding - an optional encoding, relevant is val is a string\n// - dir - true for indexOf, false for lastIndexOf\nfunction bidirectionalIndexOf (buffer, val, byteOffset, encoding, dir) {\n  // Empty buffer means no match\n  if (buffer.length === 0) return -1\n\n  // Normalize byteOffset\n  if (typeof byteOffset === 'string') {\n    encoding = byteOffset\n    byteOffset = 0\n  } else if (byteOffset > 0x7fffffff) {\n    byteOffset = 0x7fffffff\n  } else if (byteOffset < -0x80000000) {\n    byteOffset = -0x80000000\n  }\n  byteOffset = +byteOffset  // Coerce to Number.\n  if (isNaN(byteOffset)) {\n    // byteOffset: it it's undefined, null, NaN, \"foo\", etc, search whole buffer\n    byteOffset = dir ? 0 : (buffer.length - 1)\n  }\n\n  // Normalize byteOffset: negative offsets start from the end of the buffer\n  if (byteOffset < 0) byteOffset = buffer.length + byteOffset\n  if (byteOffset >= buffer.length) {\n    if (dir) return -1\n    else byteOffset = buffer.length - 1\n  } else if (byteOffset < 0) {\n    if (dir) byteOffset = 0\n    else return -1\n  }\n\n  // Normalize val\n  if (typeof val === 'string') {\n    val = Buffer.from(val, encoding)\n  }\n\n  // Finally, search either indexOf (if dir is true) or lastIndexOf\n  if (Buffer.isBuffer(val)) {\n    // Special case: looking for empty string/buffer always fails\n    if (val.length === 0) {\n      return -1\n    }\n    return arrayIndexOf(buffer, val, byteOffset, encoding, dir)\n  } else if (typeof val === 'number') {\n    val = val & 0xFF // Search for a byte value [0-255]\n    if (Buffer.TYPED_ARRAY_SUPPORT &&\n        typeof Uint8Array.prototype.indexOf === 'function') {\n      if (dir) {\n        return Uint8Array.prototype.indexOf.call(buffer, val, byteOffset)\n      } else {\n        return Uint8Array.prototype.lastIndexOf.call(buffer, val, byteOffset)\n      }\n    }\n    return arrayIndexOf(buffer, [ val ], byteOffset, encoding, dir)\n  }\n\n  throw new TypeError('val must be string, number or Buffer')\n}\n\nfunction arrayIndexOf (arr, val, byteOffset, encoding, dir) {\n  var indexSize = 1\n  var arrLength = arr.length\n  var valLength = val.length\n\n  if (encoding !== undefined) {\n    encoding = String(encoding).toLowerCase()\n    if (encoding === 'ucs2' || encoding === 'ucs-2' ||\n        encoding === 'utf16le' || encoding === 'utf-16le') {\n      if (arr.length < 2 || val.length < 2) {\n        return -1\n      }\n      indexSize = 2\n      arrLength /= 2\n      valLength /= 2\n      byteOffset /= 2\n    }\n  }\n\n  function read (buf, i) {\n    if (indexSize === 1) {\n      return buf[i]\n    } else {\n      return buf.readUInt16BE(i * indexSize)\n    }\n  }\n\n  var i\n  if (dir) {\n    var foundIndex = -1\n    for (i = byteOffset; i < arrLength; i++) {\n      if (read(arr, i) === read(val, foundIndex === -1 ? 0 : i - foundIndex)) {\n        if (foundIndex === -1) foundIndex = i\n        if (i - foundIndex + 1 === valLength) return foundIndex * indexSize\n      } else {\n        if (foundIndex !== -1) i -= i - foundIndex\n        foundIndex = -1\n      }\n    }\n  } else {\n    if (byteOffset + valLength > arrLength) byteOffset = arrLength - valLength\n    for (i = byteOffset; i >= 0; i--) {\n      var found = true\n      for (var j = 0; j < valLength; j++) {\n        if (read(arr, i + j) !== read(val, j)) {\n          found = false\n          break\n        }\n      }\n      if (found) return i\n    }\n  }\n\n  return -1\n}\n\nBuffer.prototype.includes = function includes (val, byteOffset, encoding) {\n  return this.indexOf(val, byteOffset, encoding) !== -1\n}\n\nBuffer.prototype.indexOf = function indexOf (val, byteOffset, encoding) {\n  return bidirectionalIndexOf(this, val, byteOffset, encoding, true)\n}\n\nBuffer.prototype.lastIndexOf = function lastIndexOf (val, byteOffset, encoding) {\n  return bidirectionalIndexOf(this, val, byteOffset, encoding, false)\n}\n\nfunction hexWrite (buf, string, offset, length) {\n  offset = Number(offset) || 0\n  var remaining = buf.length - offset\n  if (!length) {\n    length = remaining\n  } else {\n    length = Number(length)\n    if (length > remaining) {\n      length = remaining\n    }\n  }\n\n  // must be an even number of digits\n  var strLen = string.length\n  if (strLen % 2 !== 0) throw new TypeError('Invalid hex string')\n\n  if (length > strLen / 2) {\n    length = strLen / 2\n  }\n  for (var i = 0; i < length; ++i) {\n    var parsed = parseInt(string.substr(i * 2, 2), 16)\n    if (isNaN(parsed)) return i\n    buf[offset + i] = parsed\n  }\n  return i\n}\n\nfunction utf8Write (buf, string, offset, length) {\n  return blitBuffer(utf8ToBytes(string, buf.length - offset), buf, offset, length)\n}\n\nfunction asciiWrite (buf, string, offset, length) {\n  return blitBuffer(asciiToBytes(string), buf, offset, length)\n}\n\nfunction latin1Write (buf, string, offset, length) {\n  return asciiWrite(buf, string, offset, length)\n}\n\nfunction base64Write (buf, string, offset, length) {\n  return blitBuffer(base64ToBytes(string), buf, offset, length)\n}\n\nfunction ucs2Write (buf, string, offset, length) {\n  return blitBuffer(utf16leToBytes(string, buf.length - offset), buf, offset, length)\n}\n\nBuffer.prototype.write = function write (string, offset, length, encoding) {\n  // Buffer#write(string)\n  if (offset === undefined) {\n    encoding = 'utf8'\n    length = this.length\n    offset = 0\n  // Buffer#write(string, encoding)\n  } else if (length === undefined && typeof offset === 'string') {\n    encoding = offset\n    length = this.length\n    offset = 0\n  // Buffer#write(string, offset[, length][, encoding])\n  } else if (isFinite(offset)) {\n    offset = offset | 0\n    if (isFinite(length)) {\n      length = length | 0\n      if (encoding === undefined) encoding = 'utf8'\n    } else {\n      encoding = length\n      length = undefined\n    }\n  // legacy write(string, encoding, offset, length) - remove in v0.13\n  } else {\n    throw new Error(\n      'Buffer.write(string, encoding, offset[, length]) is no longer supported'\n    )\n  }\n\n  var remaining = this.length - offset\n  if (length === undefined || length > remaining) length = remaining\n\n  if ((string.length > 0 && (length < 0 || offset < 0)) || offset > this.length) {\n    throw new RangeError('Attempt to write outside buffer bounds')\n  }\n\n  if (!encoding) encoding = 'utf8'\n\n  var loweredCase = false\n  for (;;) {\n    switch (encoding) {\n      case 'hex':\n        return hexWrite(this, string, offset, length)\n\n      case 'utf8':\n      case 'utf-8':\n        return utf8Write(this, string, offset, length)\n\n      case 'ascii':\n        return asciiWrite(this, string, offset, length)\n\n      case 'latin1':\n      case 'binary':\n        return latin1Write(this, string, offset, length)\n\n      case 'base64':\n        // Warning: maxLength not taken into account in base64Write\n        return base64Write(this, string, offset, length)\n\n      case 'ucs2':\n      case 'ucs-2':\n      case 'utf16le':\n      case 'utf-16le':\n        return ucs2Write(this, string, offset, length)\n\n      default:\n        if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)\n        encoding = ('' + encoding).toLowerCase()\n        loweredCase = true\n    }\n  }\n}\n\nBuffer.prototype.toJSON = function toJSON () {\n  return {\n    type: 'Buffer',\n    data: Array.prototype.slice.call(this._arr || this, 0)\n  }\n}\n\nfunction base64Slice (buf, start, end) {\n  if (start === 0 && end === buf.length) {\n    return base64.fromByteArray(buf)\n  } else {\n    return base64.fromByteArray(buf.slice(start, end))\n  }\n}\n\nfunction utf8Slice (buf, start, end) {\n  end = Math.min(buf.length, end)\n  var res = []\n\n  var i = start\n  while (i < end) {\n    var firstByte = buf[i]\n    var codePoint = null\n    var bytesPerSequence = (firstByte > 0xEF) ? 4\n      : (firstByte > 0xDF) ? 3\n      : (firstByte > 0xBF) ? 2\n      : 1\n\n    if (i + bytesPerSequence <= end) {\n      var secondByte, thirdByte, fourthByte, tempCodePoint\n\n      switch (bytesPerSequence) {\n        case 1:\n          if (firstByte < 0x80) {\n            codePoint = firstByte\n          }\n          break\n        case 2:\n          secondByte = buf[i + 1]\n          if ((secondByte & 0xC0) === 0x80) {\n            tempCodePoint = (firstByte & 0x1F) << 0x6 | (secondByte & 0x3F)\n            if (tempCodePoint > 0x7F) {\n              codePoint = tempCodePoint\n            }\n          }\n          break\n        case 3:\n          secondByte = buf[i + 1]\n          thirdByte = buf[i + 2]\n          if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80) {\n            tempCodePoint = (firstByte & 0xF) << 0xC | (secondByte & 0x3F) << 0x6 | (thirdByte & 0x3F)\n            if (tempCodePoint > 0x7FF && (tempCodePoint < 0xD800 || tempCodePoint > 0xDFFF)) {\n              codePoint = tempCodePoint\n            }\n          }\n          break\n        case 4:\n          secondByte = buf[i + 1]\n          thirdByte = buf[i + 2]\n          fourthByte = buf[i + 3]\n          if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80 && (fourthByte & 0xC0) === 0x80) {\n            tempCodePoint = (firstByte & 0xF) << 0x12 | (secondByte & 0x3F) << 0xC | (thirdByte & 0x3F) << 0x6 | (fourthByte & 0x3F)\n            if (tempCodePoint > 0xFFFF && tempCodePoint < 0x110000) {\n              codePoint = tempCodePoint\n            }\n          }\n      }\n    }\n\n    if (codePoint === null) {\n      // we did not generate a valid codePoint so insert a\n      // replacement char (U+FFFD) and advance only 1 byte\n      codePoint = 0xFFFD\n      bytesPerSequence = 1\n    } else if (codePoint > 0xFFFF) {\n      // encode to utf16 (surrogate pair dance)\n      codePoint -= 0x10000\n      res.push(codePoint >>> 10 & 0x3FF | 0xD800)\n      codePoint = 0xDC00 | codePoint & 0x3FF\n    }\n\n    res.push(codePoint)\n    i += bytesPerSequence\n  }\n\n  return decodeCodePointsArray(res)\n}\n\n// Based on http://stackoverflow.com/a/22747272/680742, the browser with\n// the lowest limit is Chrome, with 0x10000 args.\n// We go 1 magnitude less, for safety\nvar MAX_ARGUMENTS_LENGTH = 0x1000\n\nfunction decodeCodePointsArray (codePoints) {\n  var len = codePoints.length\n  if (len <= MAX_ARGUMENTS_LENGTH) {\n    return String.fromCharCode.apply(String, codePoints) // avoid extra slice()\n  }\n\n  // Decode in chunks to avoid \"call stack size exceeded\".\n  var res = ''\n  var i = 0\n  while (i < len) {\n    res += String.fromCharCode.apply(\n      String,\n      codePoints.slice(i, i += MAX_ARGUMENTS_LENGTH)\n    )\n  }\n  return res\n}\n\nfunction asciiSlice (buf, start, end) {\n  var ret = ''\n  end = Math.min(buf.length, end)\n\n  for (var i = start; i < end; ++i) {\n    ret += String.fromCharCode(buf[i] & 0x7F)\n  }\n  return ret\n}\n\nfunction latin1Slice (buf, start, end) {\n  var ret = ''\n  end = Math.min(buf.length, end)\n\n  for (var i = start; i < end; ++i) {\n    ret += String.fromCharCode(buf[i])\n  }\n  return ret\n}\n\nfunction hexSlice (buf, start, end) {\n  var len = buf.length\n\n  if (!start || start < 0) start = 0\n  if (!end || end < 0 || end > len) end = len\n\n  var out = ''\n  for (var i = start; i < end; ++i) {\n    out += toHex(buf[i])\n  }\n  return out\n}\n\nfunction utf16leSlice (buf, start, end) {\n  var bytes = buf.slice(start, end)\n  var res = ''\n  for (var i = 0; i < bytes.length; i += 2) {\n    res += String.fromCharCode(bytes[i] + bytes[i + 1] * 256)\n  }\n  return res\n}\n\nBuffer.prototype.slice = function slice (start, end) {\n  var len = this.length\n  start = ~~start\n  end = end === undefined ? len : ~~end\n\n  if (start < 0) {\n    start += len\n    if (start < 0) start = 0\n  } else if (start > len) {\n    start = len\n  }\n\n  if (end < 0) {\n    end += len\n    if (end < 0) end = 0\n  } else if (end > len) {\n    end = len\n  }\n\n  if (end < start) end = start\n\n  var newBuf\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    newBuf = this.subarray(start, end)\n    newBuf.__proto__ = Buffer.prototype\n  } else {\n    var sliceLen = end - start\n    newBuf = new Buffer(sliceLen, undefined)\n    for (var i = 0; i < sliceLen; ++i) {\n      newBuf[i] = this[i + start]\n    }\n  }\n\n  return newBuf\n}\n\n/*\n * Need to make sure that buffer isn't trying to write out of bounds.\n */\nfunction checkOffset (offset, ext, length) {\n  if ((offset % 1) !== 0 || offset < 0) throw new RangeError('offset is not uint')\n  if (offset + ext > length) throw new RangeError('Trying to access beyond buffer length')\n}\n\nBuffer.prototype.readUIntLE = function readUIntLE (offset, byteLength, noAssert) {\n  offset = offset | 0\n  byteLength = byteLength | 0\n  if (!noAssert) checkOffset(offset, byteLength, this.length)\n\n  var val = this[offset]\n  var mul = 1\n  var i = 0\n  while (++i < byteLength && (mul *= 0x100)) {\n    val += this[offset + i] * mul\n  }\n\n  return val\n}\n\nBuffer.prototype.readUIntBE = function readUIntBE (offset, byteLength, noAssert) {\n  offset = offset | 0\n  byteLength = byteLength | 0\n  if (!noAssert) {\n    checkOffset(offset, byteLength, this.length)\n  }\n\n  var val = this[offset + --byteLength]\n  var mul = 1\n  while (byteLength > 0 && (mul *= 0x100)) {\n    val += this[offset + --byteLength] * mul\n  }\n\n  return val\n}\n\nBuffer.prototype.readUInt8 = function readUInt8 (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 1, this.length)\n  return this[offset]\n}\n\nBuffer.prototype.readUInt16LE = function readUInt16LE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 2, this.length)\n  return this[offset] | (this[offset + 1] << 8)\n}\n\nBuffer.prototype.readUInt16BE = function readUInt16BE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 2, this.length)\n  return (this[offset] << 8) | this[offset + 1]\n}\n\nBuffer.prototype.readUInt32LE = function readUInt32LE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length)\n\n  return ((this[offset]) |\n      (this[offset + 1] << 8) |\n      (this[offset + 2] << 16)) +\n      (this[offset + 3] * 0x1000000)\n}\n\nBuffer.prototype.readUInt32BE = function readUInt32BE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length)\n\n  return (this[offset] * 0x1000000) +\n    ((this[offset + 1] << 16) |\n    (this[offset + 2] << 8) |\n    this[offset + 3])\n}\n\nBuffer.prototype.readIntLE = function readIntLE (offset, byteLength, noAssert) {\n  offset = offset | 0\n  byteLength = byteLength | 0\n  if (!noAssert) checkOffset(offset, byteLength, this.length)\n\n  var val = this[offset]\n  var mul = 1\n  var i = 0\n  while (++i < byteLength && (mul *= 0x100)) {\n    val += this[offset + i] * mul\n  }\n  mul *= 0x80\n\n  if (val >= mul) val -= Math.pow(2, 8 * byteLength)\n\n  return val\n}\n\nBuffer.prototype.readIntBE = function readIntBE (offset, byteLength, noAssert) {\n  offset = offset | 0\n  byteLength = byteLength | 0\n  if (!noAssert) checkOffset(offset, byteLength, this.length)\n\n  var i = byteLength\n  var mul = 1\n  var val = this[offset + --i]\n  while (i > 0 && (mul *= 0x100)) {\n    val += this[offset + --i] * mul\n  }\n  mul *= 0x80\n\n  if (val >= mul) val -= Math.pow(2, 8 * byteLength)\n\n  return val\n}\n\nBuffer.prototype.readInt8 = function readInt8 (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 1, this.length)\n  if (!(this[offset] & 0x80)) return (this[offset])\n  return ((0xff - this[offset] + 1) * -1)\n}\n\nBuffer.prototype.readInt16LE = function readInt16LE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 2, this.length)\n  var val = this[offset] | (this[offset + 1] << 8)\n  return (val & 0x8000) ? val | 0xFFFF0000 : val\n}\n\nBuffer.prototype.readInt16BE = function readInt16BE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 2, this.length)\n  var val = this[offset + 1] | (this[offset] << 8)\n  return (val & 0x8000) ? val | 0xFFFF0000 : val\n}\n\nBuffer.prototype.readInt32LE = function readInt32LE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length)\n\n  return (this[offset]) |\n    (this[offset + 1] << 8) |\n    (this[offset + 2] << 16) |\n    (this[offset + 3] << 24)\n}\n\nBuffer.prototype.readInt32BE = function readInt32BE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length)\n\n  return (this[offset] << 24) |\n    (this[offset + 1] << 16) |\n    (this[offset + 2] << 8) |\n    (this[offset + 3])\n}\n\nBuffer.prototype.readFloatLE = function readFloatLE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length)\n  return ieee754.read(this, offset, true, 23, 4)\n}\n\nBuffer.prototype.readFloatBE = function readFloatBE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length)\n  return ieee754.read(this, offset, false, 23, 4)\n}\n\nBuffer.prototype.readDoubleLE = function readDoubleLE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 8, this.length)\n  return ieee754.read(this, offset, true, 52, 8)\n}\n\nBuffer.prototype.readDoubleBE = function readDoubleBE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 8, this.length)\n  return ieee754.read(this, offset, false, 52, 8)\n}\n\nfunction checkInt (buf, value, offset, ext, max, min) {\n  if (!Buffer.isBuffer(buf)) throw new TypeError('\"buffer\" argument must be a Buffer instance')\n  if (value > max || value < min) throw new RangeError('\"value\" argument is out of bounds')\n  if (offset + ext > buf.length) throw new RangeError('Index out of range')\n}\n\nBuffer.prototype.writeUIntLE = function writeUIntLE (value, offset, byteLength, noAssert) {\n  value = +value\n  offset = offset | 0\n  byteLength = byteLength | 0\n  if (!noAssert) {\n    var maxBytes = Math.pow(2, 8 * byteLength) - 1\n    checkInt(this, value, offset, byteLength, maxBytes, 0)\n  }\n\n  var mul = 1\n  var i = 0\n  this[offset] = value & 0xFF\n  while (++i < byteLength && (mul *= 0x100)) {\n    this[offset + i] = (value / mul) & 0xFF\n  }\n\n  return offset + byteLength\n}\n\nBuffer.prototype.writeUIntBE = function writeUIntBE (value, offset, byteLength, noAssert) {\n  value = +value\n  offset = offset | 0\n  byteLength = byteLength | 0\n  if (!noAssert) {\n    var maxBytes = Math.pow(2, 8 * byteLength) - 1\n    checkInt(this, value, offset, byteLength, maxBytes, 0)\n  }\n\n  var i = byteLength - 1\n  var mul = 1\n  this[offset + i] = value & 0xFF\n  while (--i >= 0 && (mul *= 0x100)) {\n    this[offset + i] = (value / mul) & 0xFF\n  }\n\n  return offset + byteLength\n}\n\nBuffer.prototype.writeUInt8 = function writeUInt8 (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 1, 0xff, 0)\n  if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value)\n  this[offset] = (value & 0xff)\n  return offset + 1\n}\n\nfunction objectWriteUInt16 (buf, value, offset, littleEndian) {\n  if (value < 0) value = 0xffff + value + 1\n  for (var i = 0, j = Math.min(buf.length - offset, 2); i < j; ++i) {\n    buf[offset + i] = (value & (0xff << (8 * (littleEndian ? i : 1 - i)))) >>>\n      (littleEndian ? i : 1 - i) * 8\n  }\n}\n\nBuffer.prototype.writeUInt16LE = function writeUInt16LE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value & 0xff)\n    this[offset + 1] = (value >>> 8)\n  } else {\n    objectWriteUInt16(this, value, offset, true)\n  }\n  return offset + 2\n}\n\nBuffer.prototype.writeUInt16BE = function writeUInt16BE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value >>> 8)\n    this[offset + 1] = (value & 0xff)\n  } else {\n    objectWriteUInt16(this, value, offset, false)\n  }\n  return offset + 2\n}\n\nfunction objectWriteUInt32 (buf, value, offset, littleEndian) {\n  if (value < 0) value = 0xffffffff + value + 1\n  for (var i = 0, j = Math.min(buf.length - offset, 4); i < j; ++i) {\n    buf[offset + i] = (value >>> (littleEndian ? i : 3 - i) * 8) & 0xff\n  }\n}\n\nBuffer.prototype.writeUInt32LE = function writeUInt32LE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset + 3] = (value >>> 24)\n    this[offset + 2] = (value >>> 16)\n    this[offset + 1] = (value >>> 8)\n    this[offset] = (value & 0xff)\n  } else {\n    objectWriteUInt32(this, value, offset, true)\n  }\n  return offset + 4\n}\n\nBuffer.prototype.writeUInt32BE = function writeUInt32BE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value >>> 24)\n    this[offset + 1] = (value >>> 16)\n    this[offset + 2] = (value >>> 8)\n    this[offset + 3] = (value & 0xff)\n  } else {\n    objectWriteUInt32(this, value, offset, false)\n  }\n  return offset + 4\n}\n\nBuffer.prototype.writeIntLE = function writeIntLE (value, offset, byteLength, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) {\n    var limit = Math.pow(2, 8 * byteLength - 1)\n\n    checkInt(this, value, offset, byteLength, limit - 1, -limit)\n  }\n\n  var i = 0\n  var mul = 1\n  var sub = 0\n  this[offset] = value & 0xFF\n  while (++i < byteLength && (mul *= 0x100)) {\n    if (value < 0 && sub === 0 && this[offset + i - 1] !== 0) {\n      sub = 1\n    }\n    this[offset + i] = ((value / mul) >> 0) - sub & 0xFF\n  }\n\n  return offset + byteLength\n}\n\nBuffer.prototype.writeIntBE = function writeIntBE (value, offset, byteLength, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) {\n    var limit = Math.pow(2, 8 * byteLength - 1)\n\n    checkInt(this, value, offset, byteLength, limit - 1, -limit)\n  }\n\n  var i = byteLength - 1\n  var mul = 1\n  var sub = 0\n  this[offset + i] = value & 0xFF\n  while (--i >= 0 && (mul *= 0x100)) {\n    if (value < 0 && sub === 0 && this[offset + i + 1] !== 0) {\n      sub = 1\n    }\n    this[offset + i] = ((value / mul) >> 0) - sub & 0xFF\n  }\n\n  return offset + byteLength\n}\n\nBuffer.prototype.writeInt8 = function writeInt8 (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 1, 0x7f, -0x80)\n  if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value)\n  if (value < 0) value = 0xff + value + 1\n  this[offset] = (value & 0xff)\n  return offset + 1\n}\n\nBuffer.prototype.writeInt16LE = function writeInt16LE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value & 0xff)\n    this[offset + 1] = (value >>> 8)\n  } else {\n    objectWriteUInt16(this, value, offset, true)\n  }\n  return offset + 2\n}\n\nBuffer.prototype.writeInt16BE = function writeInt16BE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value >>> 8)\n    this[offset + 1] = (value & 0xff)\n  } else {\n    objectWriteUInt16(this, value, offset, false)\n  }\n  return offset + 2\n}\n\nBuffer.prototype.writeInt32LE = function writeInt32LE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value & 0xff)\n    this[offset + 1] = (value >>> 8)\n    this[offset + 2] = (value >>> 16)\n    this[offset + 3] = (value >>> 24)\n  } else {\n    objectWriteUInt32(this, value, offset, true)\n  }\n  return offset + 4\n}\n\nBuffer.prototype.writeInt32BE = function writeInt32BE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)\n  if (value < 0) value = 0xffffffff + value + 1\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value >>> 24)\n    this[offset + 1] = (value >>> 16)\n    this[offset + 2] = (value >>> 8)\n    this[offset + 3] = (value & 0xff)\n  } else {\n    objectWriteUInt32(this, value, offset, false)\n  }\n  return offset + 4\n}\n\nfunction checkIEEE754 (buf, value, offset, ext, max, min) {\n  if (offset + ext > buf.length) throw new RangeError('Index out of range')\n  if (offset < 0) throw new RangeError('Index out of range')\n}\n\nfunction writeFloat (buf, value, offset, littleEndian, noAssert) {\n  if (!noAssert) {\n    checkIEEE754(buf, value, offset, 4, 3.4028234663852886e+38, -3.4028234663852886e+38)\n  }\n  ieee754.write(buf, value, offset, littleEndian, 23, 4)\n  return offset + 4\n}\n\nBuffer.prototype.writeFloatLE = function writeFloatLE (value, offset, noAssert) {\n  return writeFloat(this, value, offset, true, noAssert)\n}\n\nBuffer.prototype.writeFloatBE = function writeFloatBE (value, offset, noAssert) {\n  return writeFloat(this, value, offset, false, noAssert)\n}\n\nfunction writeDouble (buf, value, offset, littleEndian, noAssert) {\n  if (!noAssert) {\n    checkIEEE754(buf, value, offset, 8, 1.7976931348623157E+308, -1.7976931348623157E+308)\n  }\n  ieee754.write(buf, value, offset, littleEndian, 52, 8)\n  return offset + 8\n}\n\nBuffer.prototype.writeDoubleLE = function writeDoubleLE (value, offset, noAssert) {\n  return writeDouble(this, value, offset, true, noAssert)\n}\n\nBuffer.prototype.writeDoubleBE = function writeDoubleBE (value, offset, noAssert) {\n  return writeDouble(this, value, offset, false, noAssert)\n}\n\n// copy(targetBuffer, targetStart=0, sourceStart=0, sourceEnd=buffer.length)\nBuffer.prototype.copy = function copy (target, targetStart, start, end) {\n  if (!start) start = 0\n  if (!end && end !== 0) end = this.length\n  if (targetStart >= target.length) targetStart = target.length\n  if (!targetStart) targetStart = 0\n  if (end > 0 && end < start) end = start\n\n  // Copy 0 bytes; we're done\n  if (end === start) return 0\n  if (target.length === 0 || this.length === 0) return 0\n\n  // Fatal error conditions\n  if (targetStart < 0) {\n    throw new RangeError('targetStart out of bounds')\n  }\n  if (start < 0 || start >= this.length) throw new RangeError('sourceStart out of bounds')\n  if (end < 0) throw new RangeError('sourceEnd out of bounds')\n\n  // Are we oob?\n  if (end > this.length) end = this.length\n  if (target.length - targetStart < end - start) {\n    end = target.length - targetStart + start\n  }\n\n  var len = end - start\n  var i\n\n  if (this === target && start < targetStart && targetStart < end) {\n    // descending copy from end\n    for (i = len - 1; i >= 0; --i) {\n      target[i + targetStart] = this[i + start]\n    }\n  } else if (len < 1000 || !Buffer.TYPED_ARRAY_SUPPORT) {\n    // ascending copy from start\n    for (i = 0; i < len; ++i) {\n      target[i + targetStart] = this[i + start]\n    }\n  } else {\n    Uint8Array.prototype.set.call(\n      target,\n      this.subarray(start, start + len),\n      targetStart\n    )\n  }\n\n  return len\n}\n\n// Usage:\n//    buffer.fill(number[, offset[, end]])\n//    buffer.fill(buffer[, offset[, end]])\n//    buffer.fill(string[, offset[, end]][, encoding])\nBuffer.prototype.fill = function fill (val, start, end, encoding) {\n  // Handle string cases:\n  if (typeof val === 'string') {\n    if (typeof start === 'string') {\n      encoding = start\n      start = 0\n      end = this.length\n    } else if (typeof end === 'string') {\n      encoding = end\n      end = this.length\n    }\n    if (val.length === 1) {\n      var code = val.charCodeAt(0)\n      if (code < 256) {\n        val = code\n      }\n    }\n    if (encoding !== undefined && typeof encoding !== 'string') {\n      throw new TypeError('encoding must be a string')\n    }\n    if (typeof encoding === 'string' && !Buffer.isEncoding(encoding)) {\n      throw new TypeError('Unknown encoding: ' + encoding)\n    }\n  } else if (typeof val === 'number') {\n    val = val & 255\n  }\n\n  // Invalid ranges are not set to a default, so can range check early.\n  if (start < 0 || this.length < start || this.length < end) {\n    throw new RangeError('Out of range index')\n  }\n\n  if (end <= start) {\n    return this\n  }\n\n  start = start >>> 0\n  end = end === undefined ? this.length : end >>> 0\n\n  if (!val) val = 0\n\n  var i\n  if (typeof val === 'number') {\n    for (i = start; i < end; ++i) {\n      this[i] = val\n    }\n  } else {\n    var bytes = Buffer.isBuffer(val)\n      ? val\n      : utf8ToBytes(new Buffer(val, encoding).toString())\n    var len = bytes.length\n    for (i = 0; i < end - start; ++i) {\n      this[i + start] = bytes[i % len]\n    }\n  }\n\n  return this\n}\n\n// HELPER FUNCTIONS\n// ================\n\nvar INVALID_BASE64_RE = /[^+\\/0-9A-Za-z-_]/g\n\nfunction base64clean (str) {\n  // Node strips out invalid characters like \\n and \\t from the string, base64-js does not\n  str = stringtrim(str).replace(INVALID_BASE64_RE, '')\n  // Node converts strings with length < 2 to ''\n  if (str.length < 2) return ''\n  // Node allows for non-padded base64 strings (missing trailing ===), base64-js does not\n  while (str.length % 4 !== 0) {\n    str = str + '='\n  }\n  return str\n}\n\nfunction stringtrim (str) {\n  if (str.trim) return str.trim()\n  return str.replace(/^\\s+|\\s+$/g, '')\n}\n\nfunction toHex (n) {\n  if (n < 16) return '0' + n.toString(16)\n  return n.toString(16)\n}\n\nfunction utf8ToBytes (string, units) {\n  units = units || Infinity\n  var codePoint\n  var length = string.length\n  var leadSurrogate = null\n  var bytes = []\n\n  for (var i = 0; i < length; ++i) {\n    codePoint = string.charCodeAt(i)\n\n    // is surrogate component\n    if (codePoint > 0xD7FF && codePoint < 0xE000) {\n      // last char was a lead\n      if (!leadSurrogate) {\n        // no lead yet\n        if (codePoint > 0xDBFF) {\n          // unexpected trail\n          if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n          continue\n        } else if (i + 1 === length) {\n          // unpaired lead\n          if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n          continue\n        }\n\n        // valid lead\n        leadSurrogate = codePoint\n\n        continue\n      }\n\n      // 2 leads in a row\n      if (codePoint < 0xDC00) {\n        if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n        leadSurrogate = codePoint\n        continue\n      }\n\n      // valid surrogate pair\n      codePoint = (leadSurrogate - 0xD800 << 10 | codePoint - 0xDC00) + 0x10000\n    } else if (leadSurrogate) {\n      // valid bmp char, but last char was a lead\n      if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n    }\n\n    leadSurrogate = null\n\n    // encode utf8\n    if (codePoint < 0x80) {\n      if ((units -= 1) < 0) break\n      bytes.push(codePoint)\n    } else if (codePoint < 0x800) {\n      if ((units -= 2) < 0) break\n      bytes.push(\n        codePoint >> 0x6 | 0xC0,\n        codePoint & 0x3F | 0x80\n      )\n    } else if (codePoint < 0x10000) {\n      if ((units -= 3) < 0) break\n      bytes.push(\n        codePoint >> 0xC | 0xE0,\n        codePoint >> 0x6 & 0x3F | 0x80,\n        codePoint & 0x3F | 0x80\n      )\n    } else if (codePoint < 0x110000) {\n      if ((units -= 4) < 0) break\n      bytes.push(\n        codePoint >> 0x12 | 0xF0,\n        codePoint >> 0xC & 0x3F | 0x80,\n        codePoint >> 0x6 & 0x3F | 0x80,\n        codePoint & 0x3F | 0x80\n      )\n    } else {\n      throw new Error('Invalid code point')\n    }\n  }\n\n  return bytes\n}\n\nfunction asciiToBytes (str) {\n  var byteArray = []\n  for (var i = 0; i < str.length; ++i) {\n    // Node's code seems to be doing this and not & 0x7F..\n    byteArray.push(str.charCodeAt(i) & 0xFF)\n  }\n  return byteArray\n}\n\nfunction utf16leToBytes (str, units) {\n  var c, hi, lo\n  var byteArray = []\n  for (var i = 0; i < str.length; ++i) {\n    if ((units -= 2) < 0) break\n\n    c = str.charCodeAt(i)\n    hi = c >> 8\n    lo = c % 256\n    byteArray.push(lo)\n    byteArray.push(hi)\n  }\n\n  return byteArray\n}\n\nfunction base64ToBytes (str) {\n  return base64.toByteArray(base64clean(str))\n}\n\nfunction blitBuffer (src, dst, offset, length) {\n  for (var i = 0; i < length; ++i) {\n    if ((i + offset >= dst.length) || (i >= src.length)) break\n    dst[i + offset] = src[i]\n  }\n  return i\n}\n\nfunction isnan (val) {\n  return val !== val // eslint-disable-line no-self-compare\n}\n","/**\n * This is the web browser implementation of `debug()`.\n *\n * Expose `debug()` as the module.\n */\n\nexports = module.exports = require('./debug');\nexports.log = log;\nexports.formatArgs = formatArgs;\nexports.save = save;\nexports.load = load;\nexports.useColors = useColors;\nexports.storage = 'undefined' != typeof chrome\n               && 'undefined' != typeof chrome.storage\n                  ? chrome.storage.local\n                  : localstorage();\n\n/**\n * Colors.\n */\n\nexports.colors = [\n  'lightseagreen',\n  'forestgreen',\n  'goldenrod',\n  'dodgerblue',\n  'darkorchid',\n  'crimson'\n];\n\n/**\n * Currently only WebKit-based Web Inspectors, Firefox >= v31,\n * and the Firebug extension (any Firefox version) are known\n * to support \"%c\" CSS customizations.\n *\n * TODO: add a `localStorage` variable to explicitly enable/disable colors\n */\n\nfunction useColors() {\n  // NB: In an Electron preload script, document will be defined but not fully\n  // initialized. Since we know we're in Chrome, we'll just detect this case\n  // explicitly\n  if (typeof window !== 'undefined' && window && typeof window.process !== 'undefined' && window.process.type === 'renderer') {\n    return true;\n  }\n\n  // is webkit? http://stackoverflow.com/a/16459606/376773\n  // document is undefined in react-native: https://github.com/facebook/react-native/pull/1632\n  return (typeof document !== 'undefined' && document && 'WebkitAppearance' in document.documentElement.style) ||\n    // is firebug? http://stackoverflow.com/a/398120/376773\n    (typeof window !== 'undefined' && window && window.console && (console.firebug || (console.exception && console.table))) ||\n    // is firefox >= v31?\n    // https://developer.mozilla.org/en-US/docs/Tools/Web_Console#Styling_messages\n    (typeof navigator !== 'undefined' && navigator && navigator.userAgent && navigator.userAgent.toLowerCase().match(/firefox\\/(\\d+)/) && parseInt(RegExp.$1, 10) >= 31) ||\n    // double check webkit in userAgent just in case we are in a worker\n    (typeof navigator !== 'undefined' && navigator && navigator.userAgent && navigator.userAgent.toLowerCase().match(/applewebkit\\/(\\d+)/));\n}\n\n/**\n * Map %j to `JSON.stringify()`, since no Web Inspectors do that by default.\n */\n\nexports.formatters.j = function(v) {\n  try {\n    return JSON.stringify(v);\n  } catch (err) {\n    return '[UnexpectedJSONParseError]: ' + err.message;\n  }\n};\n\n\n/**\n * Colorize log arguments if enabled.\n *\n * @api public\n */\n\nfunction formatArgs(args) {\n  var useColors = this.useColors;\n\n  args[0] = (useColors ? '%c' : '')\n    + this.namespace\n    + (useColors ? ' %c' : ' ')\n    + args[0]\n    + (useColors ? '%c ' : ' ')\n    + '+' + exports.humanize(this.diff);\n\n  if (!useColors) return;\n\n  var c = 'color: ' + this.color;\n  args.splice(1, 0, c, 'color: inherit')\n\n  // the final \"%c\" is somewhat tricky, because there could be other\n  // arguments passed either before or after the %c, so we need to\n  // figure out the correct index to insert the CSS into\n  var index = 0;\n  var lastC = 0;\n  args[0].replace(/%[a-zA-Z%]/g, function(match) {\n    if ('%%' === match) return;\n    index++;\n    if ('%c' === match) {\n      // we only are interested in the *last* %c\n      // (the user may have provided their own)\n      lastC = index;\n    }\n  });\n\n  args.splice(lastC, 0, c);\n}\n\n/**\n * Invokes `console.log()` when available.\n * No-op when `console.log` is not a \"function\".\n *\n * @api public\n */\n\nfunction log() {\n  // this hackery is required for IE8/9, where\n  // the `console.log` function doesn't have 'apply'\n  return 'object' === typeof console\n    && console.log\n    && Function.prototype.apply.call(console.log, console, arguments);\n}\n\n/**\n * Save `namespaces`.\n *\n * @param {String} namespaces\n * @api private\n */\n\nfunction save(namespaces) {\n  try {\n    if (null == namespaces) {\n      exports.storage.removeItem('debug');\n    } else {\n      exports.storage.debug = namespaces;\n    }\n  } catch(e) {}\n}\n\n/**\n * Load `namespaces`.\n *\n * @return {String} returns the previously persisted debug modes\n * @api private\n */\n\nfunction load() {\n  try {\n    return exports.storage.debug;\n  } catch(e) {}\n\n  // If debug isn't set in LS, and we're in Electron, try to load $DEBUG\n  if (typeof process !== 'undefined' && 'env' in process) {\n    return process.env.DEBUG;\n  }\n}\n\n/**\n * Enable namespaces listed in `localStorage.debug` initially.\n */\n\nexports.enable(load());\n\n/**\n * Localstorage attempts to return the localstorage.\n *\n * This is necessary because safari throws\n * when a user disables cookies/localstorage\n * and you attempt to access it.\n *\n * @return {LocalStorage}\n * @api private\n */\n\nfunction localstorage() {\n  try {\n    return window.localStorage;\n  } catch (e) {}\n}\n","\n/**\n * This is the common logic for both the Node.js and web browser\n * implementations of `debug()`.\n *\n * Expose `debug()` as the module.\n */\n\nexports = module.exports = createDebug.debug = createDebug.default = createDebug;\nexports.coerce = coerce;\nexports.disable = disable;\nexports.enable = enable;\nexports.enabled = enabled;\nexports.humanize = require('ms');\n\n/**\n * The currently active debug mode names, and names to skip.\n */\n\nexports.names = [];\nexports.skips = [];\n\n/**\n * Map of special \"%n\" handling functions, for the debug \"format\" argument.\n *\n * Valid key names are a single, lower or upper-case letter, i.e. \"n\" and \"N\".\n */\n\nexports.formatters = {};\n\n/**\n * Previous log timestamp.\n */\n\nvar prevTime;\n\n/**\n * Select a color.\n * @param {String} namespace\n * @return {Number}\n * @api private\n */\n\nfunction selectColor(namespace) {\n  var hash = 0, i;\n\n  for (i in namespace) {\n    hash  = ((hash << 5) - hash) + namespace.charCodeAt(i);\n    hash |= 0; // Convert to 32bit integer\n  }\n\n  return exports.colors[Math.abs(hash) % exports.colors.length];\n}\n\n/**\n * Create a debugger with the given `namespace`.\n *\n * @param {String} namespace\n * @return {Function}\n * @api public\n */\n\nfunction createDebug(namespace) {\n\n  function debug() {\n    // disabled?\n    if (!debug.enabled) return;\n\n    var self = debug;\n\n    // set `diff` timestamp\n    var curr = +new Date();\n    var ms = curr - (prevTime || curr);\n    self.diff = ms;\n    self.prev = prevTime;\n    self.curr = curr;\n    prevTime = curr;\n\n    // turn the `arguments` into a proper Array\n    var args = new Array(arguments.length);\n    for (var i = 0; i < args.length; i++) {\n      args[i] = arguments[i];\n    }\n\n    args[0] = exports.coerce(args[0]);\n\n    if ('string' !== typeof args[0]) {\n      // anything else let's inspect with %O\n      args.unshift('%O');\n    }\n\n    // apply any `formatters` transformations\n    var index = 0;\n    args[0] = args[0].replace(/%([a-zA-Z%])/g, function(match, format) {\n      // if we encounter an escaped % then don't increase the array index\n      if (match === '%%') return match;\n      index++;\n      var formatter = exports.formatters[format];\n      if ('function' === typeof formatter) {\n        var val = args[index];\n        match = formatter.call(self, val);\n\n        // now we need to remove `args[index]` since it's inlined in the `format`\n        args.splice(index, 1);\n        index--;\n      }\n      return match;\n    });\n\n    // apply env-specific formatting (colors, etc.)\n    exports.formatArgs.call(self, args);\n\n    var logFn = debug.log || exports.log || console.log.bind(console);\n    logFn.apply(self, args);\n  }\n\n  debug.namespace = namespace;\n  debug.enabled = exports.enabled(namespace);\n  debug.useColors = exports.useColors();\n  debug.color = selectColor(namespace);\n\n  // env-specific initialization logic for debug instances\n  if ('function' === typeof exports.init) {\n    exports.init(debug);\n  }\n\n  return debug;\n}\n\n/**\n * Enables a debug mode by namespaces. This can include modes\n * separated by a colon and wildcards.\n *\n * @param {String} namespaces\n * @api public\n */\n\nfunction enable(namespaces) {\n  exports.save(namespaces);\n\n  var split = (namespaces || '').split(/[\\s,]+/);\n  var len = split.length;\n\n  for (var i = 0; i < len; i++) {\n    if (!split[i]) continue; // ignore empty strings\n    namespaces = split[i].replace(/\\*/g, '.*?');\n    if (namespaces[0] === '-') {\n      exports.skips.push(new RegExp('^' + namespaces.substr(1) + '$'));\n    } else {\n      exports.names.push(new RegExp('^' + namespaces + '$'));\n    }\n  }\n}\n\n/**\n * Disable debug output.\n *\n * @api public\n */\n\nfunction disable() {\n  exports.enable('');\n}\n\n/**\n * Returns true if the given mode name is enabled, false otherwise.\n *\n * @param {String} name\n * @return {Boolean}\n * @api public\n */\n\nfunction enabled(name) {\n  var i, len;\n  for (i = 0, len = exports.skips.length; i < len; i++) {\n    if (exports.skips[i].test(name)) {\n      return false;\n    }\n  }\n  for (i = 0, len = exports.names.length; i < len; i++) {\n    if (exports.names[i].test(name)) {\n      return true;\n    }\n  }\n  return false;\n}\n\n/**\n * Coerce `val`.\n *\n * @param {Mixed} val\n * @return {Mixed}\n * @api private\n */\n\nfunction coerce(val) {\n  if (val instanceof Error) return val.stack || val.message;\n  return val;\n}\n","exports.read = function (buffer, offset, isLE, mLen, nBytes) {\n  var e, m\n  var eLen = nBytes * 8 - mLen - 1\n  var eMax = (1 << eLen) - 1\n  var eBias = eMax >> 1\n  var nBits = -7\n  var i = isLE ? (nBytes - 1) : 0\n  var d = isLE ? -1 : 1\n  var s = buffer[offset + i]\n\n  i += d\n\n  e = s & ((1 << (-nBits)) - 1)\n  s >>= (-nBits)\n  nBits += eLen\n  for (; nBits > 0; e = e * 256 + buffer[offset + i], i += d, nBits -= 8) {}\n\n  m = e & ((1 << (-nBits)) - 1)\n  e >>= (-nBits)\n  nBits += mLen\n  for (; nBits > 0; m = m * 256 + buffer[offset + i], i += d, nBits -= 8) {}\n\n  if (e === 0) {\n    e = 1 - eBias\n  } else if (e === eMax) {\n    return m ? NaN : ((s ? -1 : 1) * Infinity)\n  } else {\n    m = m + Math.pow(2, mLen)\n    e = e - eBias\n  }\n  return (s ? -1 : 1) * m * Math.pow(2, e - mLen)\n}\n\nexports.write = function (buffer, value, offset, isLE, mLen, nBytes) {\n  var e, m, c\n  var eLen = nBytes * 8 - mLen - 1\n  var eMax = (1 << eLen) - 1\n  var eBias = eMax >> 1\n  var rt = (mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0)\n  var i = isLE ? 0 : (nBytes - 1)\n  var d = isLE ? 1 : -1\n  var s = value < 0 || (value === 0 && 1 / value < 0) ? 1 : 0\n\n  value = Math.abs(value)\n\n  if (isNaN(value) || value === Infinity) {\n    m = isNaN(value) ? 1 : 0\n    e = eMax\n  } else {\n    e = Math.floor(Math.log(value) / Math.LN2)\n    if (value * (c = Math.pow(2, -e)) < 1) {\n      e--\n      c *= 2\n    }\n    if (e + eBias >= 1) {\n      value += rt / c\n    } else {\n      value += rt * Math.pow(2, 1 - eBias)\n    }\n    if (value * c >= 2) {\n      e++\n      c /= 2\n    }\n\n    if (e + eBias >= eMax) {\n      m = 0\n      e = eMax\n    } else if (e + eBias >= 1) {\n      m = (value * c - 1) * Math.pow(2, mLen)\n      e = e + eBias\n    } else {\n      m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen)\n      e = 0\n    }\n  }\n\n  for (; mLen >= 8; buffer[offset + i] = m & 0xff, i += d, m /= 256, mLen -= 8) {}\n\n  e = (e << mLen) | m\n  eLen += mLen\n  for (; eLen > 0; buffer[offset + i] = e & 0xff, i += d, e /= 256, eLen -= 8) {}\n\n  buffer[offset + i - d] |= s * 128\n}\n","var toString = {}.toString;\n\nmodule.exports = Array.isArray || function (arr) {\n  return toString.call(arr) == '[object Array]';\n};\n","/*\n * $Id: base64.js,v 2.15 2014/04/05 12:58:57 dankogai Exp dankogai $\n *\n *  Licensed under the MIT license.\n *    http://opensource.org/licenses/mit-license\n *\n *  References:\n *    http://en.wikipedia.org/wiki/Base64\n */\n\n(function(global) {\n    'use strict';\n    // existing version for noConflict()\n    var _Base64 = global.Base64;\n    var version = \"2.1.9\";\n    // if node.js, we use Buffer\n    var buffer;\n    if (typeof module !== 'undefined' && module.exports) {\n        try {\n            buffer = require('buffer').Buffer;\n        } catch (err) {}\n    }\n    // constants\n    var b64chars\n        = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';\n    var b64tab = function(bin) {\n        var t = {};\n        for (var i = 0, l = bin.length; i < l; i++) t[bin.charAt(i)] = i;\n        return t;\n    }(b64chars);\n    var fromCharCode = String.fromCharCode;\n    // encoder stuff\n    var cb_utob = function(c) {\n        if (c.length < 2) {\n            var cc = c.charCodeAt(0);\n            return cc < 0x80 ? c\n                : cc < 0x800 ? (fromCharCode(0xc0 | (cc >>> 6))\n                                + fromCharCode(0x80 | (cc & 0x3f)))\n                : (fromCharCode(0xe0 | ((cc >>> 12) & 0x0f))\n                   + fromCharCode(0x80 | ((cc >>>  6) & 0x3f))\n                   + fromCharCode(0x80 | ( cc         & 0x3f)));\n        } else {\n            var cc = 0x10000\n                + (c.charCodeAt(0) - 0xD800) * 0x400\n                + (c.charCodeAt(1) - 0xDC00);\n            return (fromCharCode(0xf0 | ((cc >>> 18) & 0x07))\n                    + fromCharCode(0x80 | ((cc >>> 12) & 0x3f))\n                    + fromCharCode(0x80 | ((cc >>>  6) & 0x3f))\n                    + fromCharCode(0x80 | ( cc         & 0x3f)));\n        }\n    };\n    var re_utob = /[\\uD800-\\uDBFF][\\uDC00-\\uDFFFF]|[^\\x00-\\x7F]/g;\n    var utob = function(u) {\n        return u.replace(re_utob, cb_utob);\n    };\n    var cb_encode = function(ccc) {\n        var padlen = [0, 2, 1][ccc.length % 3],\n        ord = ccc.charCodeAt(0) << 16\n            | ((ccc.length > 1 ? ccc.charCodeAt(1) : 0) << 8)\n            | ((ccc.length > 2 ? ccc.charCodeAt(2) : 0)),\n        chars = [\n            b64chars.charAt( ord >>> 18),\n            b64chars.charAt((ord >>> 12) & 63),\n            padlen >= 2 ? '=' : b64chars.charAt((ord >>> 6) & 63),\n            padlen >= 1 ? '=' : b64chars.charAt(ord & 63)\n        ];\n        return chars.join('');\n    };\n    var btoa = global.btoa ? function(b) {\n        return global.btoa(b);\n    } : function(b) {\n        return b.replace(/[\\s\\S]{1,3}/g, cb_encode);\n    };\n    var _encode = buffer ? function (u) {\n        return (u.constructor === buffer.constructor ? u : new buffer(u))\n        .toString('base64')\n    }\n    : function (u) { return btoa(utob(u)) }\n    ;\n    var encode = function(u, urisafe) {\n        return !urisafe\n            ? _encode(String(u))\n            : _encode(String(u)).replace(/[+\\/]/g, function(m0) {\n                return m0 == '+' ? '-' : '_';\n            }).replace(/=/g, '');\n    };\n    var encodeURI = function(u) { return encode(u, true) };\n    // decoder stuff\n    var re_btou = new RegExp([\n        '[\\xC0-\\xDF][\\x80-\\xBF]',\n        '[\\xE0-\\xEF][\\x80-\\xBF]{2}',\n        '[\\xF0-\\xF7][\\x80-\\xBF]{3}'\n    ].join('|'), 'g');\n    var cb_btou = function(cccc) {\n        switch(cccc.length) {\n        case 4:\n            var cp = ((0x07 & cccc.charCodeAt(0)) << 18)\n                |    ((0x3f & cccc.charCodeAt(1)) << 12)\n                |    ((0x3f & cccc.charCodeAt(2)) <<  6)\n                |     (0x3f & cccc.charCodeAt(3)),\n            offset = cp - 0x10000;\n            return (fromCharCode((offset  >>> 10) + 0xD800)\n                    + fromCharCode((offset & 0x3FF) + 0xDC00));\n        case 3:\n            return fromCharCode(\n                ((0x0f & cccc.charCodeAt(0)) << 12)\n                    | ((0x3f & cccc.charCodeAt(1)) << 6)\n                    |  (0x3f & cccc.charCodeAt(2))\n            );\n        default:\n            return  fromCharCode(\n                ((0x1f & cccc.charCodeAt(0)) << 6)\n                    |  (0x3f & cccc.charCodeAt(1))\n            );\n        }\n    };\n    var btou = function(b) {\n        return b.replace(re_btou, cb_btou);\n    };\n    var cb_decode = function(cccc) {\n        var len = cccc.length,\n        padlen = len % 4,\n        n = (len > 0 ? b64tab[cccc.charAt(0)] << 18 : 0)\n            | (len > 1 ? b64tab[cccc.charAt(1)] << 12 : 0)\n            | (len > 2 ? b64tab[cccc.charAt(2)] <<  6 : 0)\n            | (len > 3 ? b64tab[cccc.charAt(3)]       : 0),\n        chars = [\n            fromCharCode( n >>> 16),\n            fromCharCode((n >>>  8) & 0xff),\n            fromCharCode( n         & 0xff)\n        ];\n        chars.length -= [0, 0, 2, 1][padlen];\n        return chars.join('');\n    };\n    var atob = global.atob ? function(a) {\n        return global.atob(a);\n    } : function(a){\n        return a.replace(/[\\s\\S]{1,4}/g, cb_decode);\n    };\n    var _decode = buffer ? function(a) {\n        return (a.constructor === buffer.constructor\n                ? a : new buffer(a, 'base64')).toString();\n    }\n    : function(a) { return btou(atob(a)) };\n    var decode = function(a){\n        return _decode(\n            String(a).replace(/[-_]/g, function(m0) { return m0 == '-' ? '+' : '/' })\n                .replace(/[^A-Za-z0-9\\+\\/]/g, '')\n        );\n    };\n    var noConflict = function() {\n        var Base64 = global.Base64;\n        global.Base64 = _Base64;\n        return Base64;\n    };\n    // export Base64\n    global.Base64 = {\n        VERSION: version,\n        atob: atob,\n        btoa: btoa,\n        fromBase64: decode,\n        toBase64: encode,\n        utob: utob,\n        encode: encode,\n        encodeURI: encodeURI,\n        btou: btou,\n        decode: decode,\n        noConflict: noConflict\n    };\n    // if ES5 is available, make Base64.extendString() available\n    if (typeof Object.defineProperty === 'function') {\n        var noEnum = function(v){\n            return {value:v,enumerable:false,writable:true,configurable:true};\n        };\n        global.Base64.extendString = function () {\n            Object.defineProperty(\n                String.prototype, 'fromBase64', noEnum(function () {\n                    return decode(this)\n                }));\n            Object.defineProperty(\n                String.prototype, 'toBase64', noEnum(function (urisafe) {\n                    return encode(this, urisafe)\n                }));\n            Object.defineProperty(\n                String.prototype, 'toBase64URI', noEnum(function () {\n                    return encode(this, true)\n                }));\n        };\n    }\n    // that's it!\n    if (global['Meteor']) {\n       Base64 = global.Base64; // for normal export in Meteor.js\n    }\n})(this);\n","/**\n * Helpers.\n */\n\nvar s = 1000\nvar m = s * 60\nvar h = m * 60\nvar d = h * 24\nvar y = d * 365.25\n\n/**\n * Parse or format the given `val`.\n *\n * Options:\n *\n *  - `long` verbose formatting [false]\n *\n * @param {String|Number} val\n * @param {Object} options\n * @throws {Error} throw an error if val is not a non-empty string or a number\n * @return {String|Number}\n * @api public\n */\n\nmodule.exports = function (val, options) {\n  options = options || {}\n  var type = typeof val\n  if (type === 'string' && val.length > 0) {\n    return parse(val)\n  } else if (type === 'number' && isNaN(val) === false) {\n    return options.long ?\n\t\t\tfmtLong(val) :\n\t\t\tfmtShort(val)\n  }\n  throw new Error('val is not a non-empty string or a valid number. val=' + JSON.stringify(val))\n}\n\n/**\n * Parse the given `str` and return milliseconds.\n *\n * @param {String} str\n * @return {Number}\n * @api private\n */\n\nfunction parse(str) {\n  str = String(str)\n  if (str.length > 10000) {\n    return\n  }\n  var match = /^((?:\\d+)?\\.?\\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|years?|yrs?|y)?$/i.exec(str)\n  if (!match) {\n    return\n  }\n  var n = parseFloat(match[1])\n  var type = (match[2] || 'ms').toLowerCase()\n  switch (type) {\n    case 'years':\n    case 'year':\n    case 'yrs':\n    case 'yr':\n    case 'y':\n      return n * y\n    case 'days':\n    case 'day':\n    case 'd':\n      return n * d\n    case 'hours':\n    case 'hour':\n    case 'hrs':\n    case 'hr':\n    case 'h':\n      return n * h\n    case 'minutes':\n    case 'minute':\n    case 'mins':\n    case 'min':\n    case 'm':\n      return n * m\n    case 'seconds':\n    case 'second':\n    case 'secs':\n    case 'sec':\n    case 's':\n      return n * s\n    case 'milliseconds':\n    case 'millisecond':\n    case 'msecs':\n    case 'msec':\n    case 'ms':\n      return n\n    default:\n      return undefined\n  }\n}\n\n/**\n * Short format for `ms`.\n *\n * @param {Number} ms\n * @return {String}\n * @api private\n */\n\nfunction fmtShort(ms) {\n  if (ms >= d) {\n    return Math.round(ms / d) + 'd'\n  }\n  if (ms >= h) {\n    return Math.round(ms / h) + 'h'\n  }\n  if (ms >= m) {\n    return Math.round(ms / m) + 'm'\n  }\n  if (ms >= s) {\n    return Math.round(ms / s) + 's'\n  }\n  return ms + 'ms'\n}\n\n/**\n * Long format for `ms`.\n *\n * @param {Number} ms\n * @return {String}\n * @api private\n */\n\nfunction fmtLong(ms) {\n  return plural(ms, d, 'day') ||\n    plural(ms, h, 'hour') ||\n    plural(ms, m, 'minute') ||\n    plural(ms, s, 'second') ||\n    ms + ' ms'\n}\n\n/**\n * Pluralization helper.\n */\n\nfunction plural(ms, n, name) {\n  if (ms < n) {\n    return\n  }\n  if (ms < n * 1.5) {\n    return Math.floor(ms / n) + ' ' + name\n  }\n  return Math.ceil(ms / n) + ' ' + name + 's'\n}\n","// shim for using process in browser\nvar process = module.exports = {};\n\n// cached from whatever global is present so that test runners that stub it\n// don't break things.  But we need to wrap it in a try catch in case it is\n// wrapped in strict mode code which doesn't define any globals.  It's inside a\n// function because try/catches deoptimize in certain engines.\n\nvar cachedSetTimeout;\nvar cachedClearTimeout;\n\nfunction defaultSetTimout() {\n    throw new Error('setTimeout has not been defined');\n}\nfunction defaultClearTimeout () {\n    throw new Error('clearTimeout has not been defined');\n}\n(function () {\n    try {\n        if (typeof setTimeout === 'function') {\n            cachedSetTimeout = setTimeout;\n        } else {\n            cachedSetTimeout = defaultSetTimout;\n        }\n    } catch (e) {\n        cachedSetTimeout = defaultSetTimout;\n    }\n    try {\n        if (typeof clearTimeout === 'function') {\n            cachedClearTimeout = clearTimeout;\n        } else {\n            cachedClearTimeout = defaultClearTimeout;\n        }\n    } catch (e) {\n        cachedClearTimeout = defaultClearTimeout;\n    }\n} ())\nfunction runTimeout(fun) {\n    if (cachedSetTimeout === setTimeout) {\n        //normal enviroments in sane situations\n        return setTimeout(fun, 0);\n    }\n    // if setTimeout wasn't available but was latter defined\n    if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {\n        cachedSetTimeout = setTimeout;\n        return setTimeout(fun, 0);\n    }\n    try {\n        // when when somebody has screwed with setTimeout but no I.E. maddness\n        return cachedSetTimeout(fun, 0);\n    } catch(e){\n        try {\n            // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally\n            return cachedSetTimeout.call(null, fun, 0);\n        } catch(e){\n            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error\n            return cachedSetTimeout.call(this, fun, 0);\n        }\n    }\n\n\n}\nfunction runClearTimeout(marker) {\n    if (cachedClearTimeout === clearTimeout) {\n        //normal enviroments in sane situations\n        return clearTimeout(marker);\n    }\n    // if clearTimeout wasn't available but was latter defined\n    if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {\n        cachedClearTimeout = clearTimeout;\n        return clearTimeout(marker);\n    }\n    try {\n        // when when somebody has screwed with setTimeout but no I.E. maddness\n        return cachedClearTimeout(marker);\n    } catch (e){\n        try {\n            // When we are in I.E. but the script has been evaled so I.E. doesn't  trust the global object when called normally\n            return cachedClearTimeout.call(null, marker);\n        } catch (e){\n            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error.\n            // Some versions of I.E. have different rules for clearTimeout vs setTimeout\n            return cachedClearTimeout.call(this, marker);\n        }\n    }\n\n\n\n}\nvar queue = [];\nvar draining = false;\nvar currentQueue;\nvar queueIndex = -1;\n\nfunction cleanUpNextTick() {\n    if (!draining || !currentQueue) {\n        return;\n    }\n    draining = false;\n    if (currentQueue.length) {\n        queue = currentQueue.concat(queue);\n    } else {\n        queueIndex = -1;\n    }\n    if (queue.length) {\n        drainQueue();\n    }\n}\n\nfunction drainQueue() {\n    if (draining) {\n        return;\n    }\n    var timeout = runTimeout(cleanUpNextTick);\n    draining = true;\n\n    var len = queue.length;\n    while(len) {\n        currentQueue = queue;\n        queue = [];\n        while (++queueIndex < len) {\n            if (currentQueue) {\n                currentQueue[queueIndex].run();\n            }\n        }\n        queueIndex = -1;\n        len = queue.length;\n    }\n    currentQueue = null;\n    draining = false;\n    runClearTimeout(timeout);\n}\n\nprocess.nextTick = function (fun) {\n    var args = new Array(arguments.length - 1);\n    if (arguments.length > 1) {\n        for (var i = 1; i < arguments.length; i++) {\n            args[i - 1] = arguments[i];\n        }\n    }\n    queue.push(new Item(fun, args));\n    if (queue.length === 1 && !draining) {\n        runTimeout(drainQueue);\n    }\n};\n\n// v8 likes predictible objects\nfunction Item(fun, array) {\n    this.fun = fun;\n    this.array = array;\n}\nItem.prototype.run = function () {\n    this.fun.apply(null, this.array);\n};\nprocess.title = 'browser';\nprocess.browser = true;\nprocess.env = {};\nprocess.argv = [];\nprocess.version = ''; // empty string to avoid regexp issues\nprocess.versions = {};\n\nfunction noop() {}\n\nprocess.on = noop;\nprocess.addListener = noop;\nprocess.once = noop;\nprocess.off = noop;\nprocess.removeListener = noop;\nprocess.removeAllListeners = noop;\nprocess.emit = noop;\n\nprocess.binding = function (name) {\n    throw new Error('process.binding is not supported');\n};\n\nprocess.cwd = function () { return '/' };\nprocess.chdir = function (dir) {\n    throw new Error('process.chdir is not supported');\n};\nprocess.umask = function() { return 0; };\n","/*! https://mths.be/utf8js v2.1.2 by @mathias */\n;(function(root) {\n\n\t// Detect free variables `exports`\n\tvar freeExports = typeof exports == 'object' && exports;\n\n\t// Detect free variable `module`\n\tvar freeModule = typeof module == 'object' && module &&\n\t\tmodule.exports == freeExports && module;\n\n\t// Detect free variable `global`, from Node.js or Browserified code,\n\t// and use it as `root`\n\tvar freeGlobal = typeof global == 'object' && global;\n\tif (freeGlobal.global === freeGlobal || freeGlobal.window === freeGlobal) {\n\t\troot = freeGlobal;\n\t}\n\n\t/*--------------------------------------------------------------------------*/\n\n\tvar stringFromCharCode = String.fromCharCode;\n\n\t// Taken from https://mths.be/punycode\n\tfunction ucs2decode(string) {\n\t\tvar output = [];\n\t\tvar counter = 0;\n\t\tvar length = string.length;\n\t\tvar value;\n\t\tvar extra;\n\t\twhile (counter < length) {\n\t\t\tvalue = string.charCodeAt(counter++);\n\t\t\tif (value >= 0xD800 && value <= 0xDBFF && counter < length) {\n\t\t\t\t// high surrogate, and there is a next character\n\t\t\t\textra = string.charCodeAt(counter++);\n\t\t\t\tif ((extra & 0xFC00) == 0xDC00) { // low surrogate\n\t\t\t\t\toutput.push(((value & 0x3FF) << 10) + (extra & 0x3FF) + 0x10000);\n\t\t\t\t} else {\n\t\t\t\t\t// unmatched surrogate; only append this code unit, in case the next\n\t\t\t\t\t// code unit is the high surrogate of a surrogate pair\n\t\t\t\t\toutput.push(value);\n\t\t\t\t\tcounter--;\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\toutput.push(value);\n\t\t\t}\n\t\t}\n\t\treturn output;\n\t}\n\n\t// Taken from https://mths.be/punycode\n\tfunction ucs2encode(array) {\n\t\tvar length = array.length;\n\t\tvar index = -1;\n\t\tvar value;\n\t\tvar output = '';\n\t\twhile (++index < length) {\n\t\t\tvalue = array[index];\n\t\t\tif (value > 0xFFFF) {\n\t\t\t\tvalue -= 0x10000;\n\t\t\t\toutput += stringFromCharCode(value >>> 10 & 0x3FF | 0xD800);\n\t\t\t\tvalue = 0xDC00 | value & 0x3FF;\n\t\t\t}\n\t\t\toutput += stringFromCharCode(value);\n\t\t}\n\t\treturn output;\n\t}\n\n\tfunction checkScalarValue(codePoint) {\n\t\tif (codePoint >= 0xD800 && codePoint <= 0xDFFF) {\n\t\t\tthrow Error(\n\t\t\t\t'Lone surrogate U+' + codePoint.toString(16).toUpperCase() +\n\t\t\t\t' is not a scalar value'\n\t\t\t);\n\t\t}\n\t}\n\t/*--------------------------------------------------------------------------*/\n\n\tfunction createByte(codePoint, shift) {\n\t\treturn stringFromCharCode(((codePoint >> shift) & 0x3F) | 0x80);\n\t}\n\n\tfunction encodeCodePoint(codePoint) {\n\t\tif ((codePoint & 0xFFFFFF80) == 0) { // 1-byte sequence\n\t\t\treturn stringFromCharCode(codePoint);\n\t\t}\n\t\tvar symbol = '';\n\t\tif ((codePoint & 0xFFFFF800) == 0) { // 2-byte sequence\n\t\t\tsymbol = stringFromCharCode(((codePoint >> 6) & 0x1F) | 0xC0);\n\t\t}\n\t\telse if ((codePoint & 0xFFFF0000) == 0) { // 3-byte sequence\n\t\t\tcheckScalarValue(codePoint);\n\t\t\tsymbol = stringFromCharCode(((codePoint >> 12) & 0x0F) | 0xE0);\n\t\t\tsymbol += createByte(codePoint, 6);\n\t\t}\n\t\telse if ((codePoint & 0xFFE00000) == 0) { // 4-byte sequence\n\t\t\tsymbol = stringFromCharCode(((codePoint >> 18) & 0x07) | 0xF0);\n\t\t\tsymbol += createByte(codePoint, 12);\n\t\t\tsymbol += createByte(codePoint, 6);\n\t\t}\n\t\tsymbol += stringFromCharCode((codePoint & 0x3F) | 0x80);\n\t\treturn symbol;\n\t}\n\n\tfunction utf8encode(string) {\n\t\tvar codePoints = ucs2decode(string);\n\t\tvar length = codePoints.length;\n\t\tvar index = -1;\n\t\tvar codePoint;\n\t\tvar byteString = '';\n\t\twhile (++index < length) {\n\t\t\tcodePoint = codePoints[index];\n\t\t\tbyteString += encodeCodePoint(codePoint);\n\t\t}\n\t\treturn byteString;\n\t}\n\n\t/*--------------------------------------------------------------------------*/\n\n\tfunction readContinuationByte() {\n\t\tif (byteIndex >= byteCount) {\n\t\t\tthrow Error('Invalid byte index');\n\t\t}\n\n\t\tvar continuationByte = byteArray[byteIndex] & 0xFF;\n\t\tbyteIndex++;\n\n\t\tif ((continuationByte & 0xC0) == 0x80) {\n\t\t\treturn continuationByte & 0x3F;\n\t\t}\n\n\t\t// If we end up here, it’s not a continuation byte\n\t\tthrow Error('Invalid continuation byte');\n\t}\n\n\tfunction decodeSymbol() {\n\t\tvar byte1;\n\t\tvar byte2;\n\t\tvar byte3;\n\t\tvar byte4;\n\t\tvar codePoint;\n\n\t\tif (byteIndex > byteCount) {\n\t\t\tthrow Error('Invalid byte index');\n\t\t}\n\n\t\tif (byteIndex == byteCount) {\n\t\t\treturn false;\n\t\t}\n\n\t\t// Read first byte\n\t\tbyte1 = byteArray[byteIndex] & 0xFF;\n\t\tbyteIndex++;\n\n\t\t// 1-byte sequence (no continuation bytes)\n\t\tif ((byte1 & 0x80) == 0) {\n\t\t\treturn byte1;\n\t\t}\n\n\t\t// 2-byte sequence\n\t\tif ((byte1 & 0xE0) == 0xC0) {\n\t\t\tbyte2 = readContinuationByte();\n\t\t\tcodePoint = ((byte1 & 0x1F) << 6) | byte2;\n\t\t\tif (codePoint >= 0x80) {\n\t\t\t\treturn codePoint;\n\t\t\t} else {\n\t\t\t\tthrow Error('Invalid continuation byte');\n\t\t\t}\n\t\t}\n\n\t\t// 3-byte sequence (may include unpaired surrogates)\n\t\tif ((byte1 & 0xF0) == 0xE0) {\n\t\t\tbyte2 = readContinuationByte();\n\t\t\tbyte3 = readContinuationByte();\n\t\t\tcodePoint = ((byte1 & 0x0F) << 12) | (byte2 << 6) | byte3;\n\t\t\tif (codePoint >= 0x0800) {\n\t\t\t\tcheckScalarValue(codePoint);\n\t\t\t\treturn codePoint;\n\t\t\t} else {\n\t\t\t\tthrow Error('Invalid continuation byte');\n\t\t\t}\n\t\t}\n\n\t\t// 4-byte sequence\n\t\tif ((byte1 & 0xF8) == 0xF0) {\n\t\t\tbyte2 = readContinuationByte();\n\t\t\tbyte3 = readContinuationByte();\n\t\t\tbyte4 = readContinuationByte();\n\t\t\tcodePoint = ((byte1 & 0x07) << 0x12) | (byte2 << 0x0C) |\n\t\t\t\t(byte3 << 0x06) | byte4;\n\t\t\tif (codePoint >= 0x010000 && codePoint <= 0x10FFFF) {\n\t\t\t\treturn codePoint;\n\t\t\t}\n\t\t}\n\n\t\tthrow Error('Invalid UTF-8 detected');\n\t}\n\n\tvar byteArray;\n\tvar byteCount;\n\tvar byteIndex;\n\tfunction utf8decode(byteString) {\n\t\tbyteArray = ucs2decode(byteString);\n\t\tbyteCount = byteArray.length;\n\t\tbyteIndex = 0;\n\t\tvar codePoints = [];\n\t\tvar tmp;\n\t\twhile ((tmp = decodeSymbol()) !== false) {\n\t\t\tcodePoints.push(tmp);\n\t\t}\n\t\treturn ucs2encode(codePoints);\n\t}\n\n\t/*--------------------------------------------------------------------------*/\n\n\tvar utf8 = {\n\t\t'version': '2.1.2',\n\t\t'encode': utf8encode,\n\t\t'decode': utf8decode\n\t};\n\n\t// Some AMD build optimizers, like r.js, check for specific condition patterns\n\t// like the following:\n\tif (\n\t\ttypeof define == 'function' &&\n\t\ttypeof define.amd == 'object' &&\n\t\tdefine.amd\n\t) {\n\t\tdefine(function() {\n\t\t\treturn utf8;\n\t\t});\n\t}\telse if (freeExports && !freeExports.nodeType) {\n\t\tif (freeModule) { // in Node.js or RingoJS v0.8.0+\n\t\t\tfreeModule.exports = utf8;\n\t\t} else { // in Narwhal or RingoJS v0.7.0-\n\t\t\tvar object = {};\n\t\t\tvar hasOwnProperty = object.hasOwnProperty;\n\t\t\tfor (var key in utf8) {\n\t\t\t\thasOwnProperty.call(utf8, key) && (freeExports[key] = utf8[key]);\n\t\t\t}\n\t\t}\n\t} else { // in Rhino or a web browser\n\t\troot.utf8 = utf8;\n\t}\n\n}(this));\n"]}"} \ No newline at end of file +{"version":3,"sources":["node_modules/browser-pack/_prelude.js","lib/Gist.js","lib/GitHub.js","lib/Issue.js","lib/Markdown.js","lib/Organization.js","lib/Project.js","lib/RateLimit.js","lib/Repository.js","lib/Requestable.js","lib/Search.js","lib/Team.js","lib/User.js","node_modules/axios/index.js","node_modules/axios/lib/adapters/xhr.js","node_modules/axios/lib/axios.js","node_modules/axios/lib/cancel/Cancel.js","node_modules/axios/lib/cancel/CancelToken.js","node_modules/axios/lib/cancel/isCancel.js","node_modules/axios/lib/core/Axios.js","node_modules/axios/lib/core/InterceptorManager.js","node_modules/axios/lib/core/createError.js","node_modules/axios/lib/core/dispatchRequest.js","node_modules/axios/lib/core/enhanceError.js","node_modules/axios/lib/core/settle.js","node_modules/axios/lib/core/transformData.js","node_modules/axios/lib/defaults.js","node_modules/axios/lib/helpers/bind.js","node_modules/axios/lib/helpers/btoa.js","node_modules/axios/lib/helpers/buildURL.js","node_modules/axios/lib/helpers/combineURLs.js","node_modules/axios/lib/helpers/cookies.js","node_modules/axios/lib/helpers/isAbsoluteURL.js","node_modules/axios/lib/helpers/isURLSameOrigin.js","node_modules/axios/lib/helpers/normalizeHeaderName.js","node_modules/axios/lib/helpers/parseHeaders.js","node_modules/axios/lib/helpers/spread.js","node_modules/axios/lib/utils.js","node_modules/base64-js/index.js","node_modules/buffer/index.js","node_modules/debug/src/browser.js","node_modules/debug/src/debug.js","node_modules/ieee754/index.js","node_modules/isarray/index.js","node_modules/js-base64/base64.js","node_modules/ms/index.js","node_modules/process/browser.js","node_modules/utf8/utf8.js"],"names":[],"mappings":"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ACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;ACjLA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACpDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACnBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACzDA;AACA;AACA;AACA;AACA;AACA;;ACLA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACrFA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACpDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC/EA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACnBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACzBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;ACpBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;AC7FA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACXA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACpCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACpEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACZA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACrDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACdA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACpEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACZA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACr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lHA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;AC7vDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;ACtLA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACvMA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACpFA;AACA;AACA;AACA;AACA;AACA;;ACLA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AClMA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACrJA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;ACpLA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA","file":"GitHub.bundle.js","sourcesContent":["(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require==\"function\"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error(\"Cannot find module '\"+o+\"'\");throw f.code=\"MODULE_NOT_FOUND\",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require==\"function\"&&require;for(var o=0;o {\n this.__id = response.data.id;\n return response;\n });\n }\n\n /**\n * Delete a gist.\n * @see https://developer.github.com/v3/gists/#delete-a-gist\n * @param {Requestable.callback} [cb] - will receive true if the request succeeds\n * @return {Promise} - the Promise for the http request\n */\n delete(cb) {\n return this._request('DELETE', `/gists/${this.__id}`, null, cb);\n }\n\n /**\n * Fork a gist.\n * @see https://developer.github.com/v3/gists/#fork-a-gist\n * @param {Requestable.callback} [cb] - the function that will receive the gist\n * @return {Promise} - the Promise for the http request\n */\n fork(cb) {\n return this._request('POST', `/gists/${this.__id}/forks`, null, cb);\n }\n\n /**\n * Update a gist.\n * @see https://developer.github.com/v3/gists/#edit-a-gist\n * @param {Object} gist - the new data for the gist\n * @param {Requestable.callback} [cb] - the function that receives the API result\n * @return {Promise} - the Promise for the http request\n */\n update(gist, cb) {\n return this._request('PATCH', `/gists/${this.__id}`, gist, cb);\n }\n\n /**\n * Star a gist.\n * @see https://developer.github.com/v3/gists/#star-a-gist\n * @param {Requestable.callback} [cb] - will receive true if the request is successful\n * @return {Promise} - the Promise for the http request\n */\n star(cb) {\n return this._request('PUT', `/gists/${this.__id}/star`, null, cb);\n }\n\n /**\n * Unstar a gist.\n * @see https://developer.github.com/v3/gists/#unstar-a-gist\n * @param {Requestable.callback} [cb] - will receive true if the request is successful\n * @return {Promise} - the Promise for the http request\n */\n unstar(cb) {\n return this._request('DELETE', `/gists/${this.__id}/star`, null, cb);\n }\n\n /**\n * Check if a gist is starred by the user.\n * @see https://developer.github.com/v3/gists/#check-if-a-gist-is-starred\n * @param {Requestable.callback} [cb] - will receive true if the gist is starred and false if the gist is not starred\n * @return {Promise} - the Promise for the http request\n */\n isStarred(cb) {\n return this._request204or404(`/gists/${this.__id}/star`, null, cb);\n }\n\n /**\n * List the gist's commits\n * @see https://developer.github.com/v3/gists/#list-gist-commits\n * @param {Requestable.callback} [cb] - will receive the array of commits\n * @return {Promise} - the Promise for the http request\n */\n listCommits(cb) {\n return this._requestAllPages(`/gists/${this.__id}/commits`, null, cb);\n }\n\n /**\n * Fetch one of the gist's revision.\n * @see https://developer.github.com/v3/gists/#get-a-specific-revision-of-a-gist\n * @param {string} revision - the id of the revision\n * @param {Requestable.callback} [cb] - will receive the revision\n * @return {Promise} - the Promise for the http request\n */\n getRevision(revision, cb) {\n return this._request('GET', `/gists/${this.__id}/${revision}`, null, cb);\n }\n\n /**\n * List the gist's comments\n * @see https://developer.github.com/v3/gists/comments/#list-comments-on-a-gist\n * @param {Requestable.callback} [cb] - will receive the array of comments\n * @return {Promise} - the promise for the http request\n */\n listComments(cb) {\n return this._requestAllPages(`/gists/${this.__id}/comments`, null, cb);\n }\n\n /**\n * Fetch one of the gist's comments\n * @see https://developer.github.com/v3/gists/comments/#get-a-single-comment\n * @param {number} comment - the id of the comment\n * @param {Requestable.callback} [cb] - will receive the comment\n * @return {Promise} - the Promise for the http request\n */\n getComment(comment, cb) {\n return this._request('GET', `/gists/${this.__id}/comments/${comment}`, null, cb);\n }\n\n /**\n * Comment on a gist\n * @see https://developer.github.com/v3/gists/comments/#create-a-comment\n * @param {string} comment - the comment to add\n * @param {Requestable.callback} [cb] - the function that receives the API result\n * @return {Promise} - the Promise for the http request\n */\n createComment(comment, cb) {\n return this._request('POST', `/gists/${this.__id}/comments`, {body: comment}, cb);\n }\n\n /**\n * Edit a comment on the gist\n * @see https://developer.github.com/v3/gists/comments/#edit-a-comment\n * @param {number} comment - the id of the comment\n * @param {string} body - the new comment\n * @param {Requestable.callback} [cb] - will receive the modified comment\n * @return {Promise} - the promise for the http request\n */\n editComment(comment, body, cb) {\n return this._request('PATCH', `/gists/${this.__id}/comments/${comment}`, {body: body}, cb);\n }\n\n /**\n * Delete a comment on the gist.\n * @see https://developer.github.com/v3/gists/comments/#delete-a-comment\n * @param {number} comment - the id of the comment\n * @param {Requestable.callback} [cb] - will receive true if the request succeeds\n * @return {Promise} - the Promise for the http request\n */\n deleteComment(comment, cb) {\n return this._request('DELETE', `/gists/${this.__id}/comments/${comment}`, null, cb);\n }\n}\n\nmodule.exports = Gist;\n","/**\n * @file\n * @copyright 2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n * Github.js is freely distributable.\n */\n/* eslint valid-jsdoc: [\"error\", {\"requireReturnDescription\": false}] */\n\nimport Gist from './Gist';\nimport User from './User';\nimport Issue from './Issue';\nimport Search from './Search';\nimport RateLimit from './RateLimit';\nimport Repository from './Repository';\nimport Organization from './Organization';\nimport Team from './Team';\nimport Markdown from './Markdown';\nimport Project from './Project';\n\n/**\n * GitHub encapsulates the functionality to create various API wrapper objects.\n */\nclass GitHub {\n /**\n * Create a new GitHub.\n * @param {Requestable.auth} [auth] - the credentials to authenticate to Github. If auth is\n * not provided requests will be made unauthenticated\n * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n */\n constructor(auth, apiBase = 'https://api.github.com') {\n this.__apiBase = apiBase;\n this.__auth = auth || {};\n }\n\n /**\n * Create a new Gist wrapper\n * @param {number} [id] - the id for the gist, leave undefined when creating a new gist\n * @return {Gist}\n */\n getGist(id) {\n return new Gist(id, this.__auth, this.__apiBase);\n }\n\n /**\n * Create a new User wrapper\n * @param {string} [user] - the name of the user to get information about\n * leave undefined for the authenticated user\n * @return {User}\n */\n getUser(user) {\n return new User(user, this.__auth, this.__apiBase);\n }\n\n /**\n * Create a new Organization wrapper\n * @param {string} organization - the name of the organization\n * @return {Organization}\n */\n getOrganization(organization) {\n return new Organization(organization, this.__auth, this.__apiBase);\n }\n\n /**\n * create a new Team wrapper\n * @param {string} teamId - the name of the team\n * @return {team}\n */\n getTeam(teamId) {\n return new Team(teamId, this.__auth, this.__apiBase);\n }\n\n /**\n * Create a new Repository wrapper\n * @param {string} user - the user who owns the respository\n * @param {string} repo - the name of the repository\n * @return {Repository}\n */\n getRepo(user, repo) {\n return new Repository(this._getFullName(user, repo), this.__auth, this.__apiBase);\n }\n\n /**\n * Create a new Issue wrapper\n * @param {string} user - the user who owns the respository\n * @param {string} repo - the name of the repository\n * @return {Issue}\n */\n getIssues(user, repo) {\n return new Issue(this._getFullName(user, repo), this.__auth, this.__apiBase);\n }\n\n /**\n * Create a new Search wrapper\n * @param {string} query - the query to search for\n * @return {Search}\n */\n search(query) {\n return new Search(query, this.__auth, this.__apiBase);\n }\n\n /**\n * Create a new RateLimit wrapper\n * @return {RateLimit}\n */\n getRateLimit() {\n return new RateLimit(this.__auth, this.__apiBase);\n }\n\n /**\n * Create a new Markdown wrapper\n * @return {Markdown}\n */\n getMarkdown() {\n return new Markdown(this.__auth, this.__apiBase);\n }\n\n /**\n * Create a new Project wrapper\n * @param {string} id - the id of the project\n * @return {Markdown}\n */\n getProject(id) {\n return new Project(id, this.__auth, this.__apiBase);\n }\n\n /**\n * Computes the full repository name\n * @param {string} user - the username (or the full name)\n * @param {string} repo - the repository name, must not be passed if `user` is the full name\n * @return {string} the repository's full name\n */\n _getFullName(user, repo) {\n let fullname = user;\n\n if (repo) {\n fullname = `${user}/${repo}`;\n }\n\n return fullname;\n }\n}\n\nmodule.exports = GitHub;\n","/**\n * @file\n * @copyright 2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n * Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\n\n/**\n * Issue wraps the functionality to get issues for repositories\n */\nclass Issue extends Requestable {\n /**\n * Create a new Issue\n * @param {string} repository - the full name of the repository (`:user/:repo`) to get issues for\n * @param {Requestable.auth} [auth] - information required to authenticate to Github\n * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n */\n constructor(repository, auth, apiBase) {\n super(auth, apiBase);\n this.__repository = repository;\n }\n\n /**\n * Create a new issue\n * @see https://developer.github.com/v3/issues/#create-an-issue\n * @param {Object} issueData - the issue to create\n * @param {Requestable.callback} [cb] - will receive the created issue\n * @return {Promise} - the promise for the http request\n */\n createIssue(issueData, cb) {\n return this._request('POST', `/repos/${this.__repository}/issues`, issueData, cb);\n }\n\n /**\n * List the issues for the repository\n * @see https://developer.github.com/v3/issues/#list-issues-for-a-repository\n * @param {Object} options - filtering options\n * @param {Requestable.callback} [cb] - will receive the array of issues\n * @return {Promise} - the promise for the http request\n */\n listIssues(options, cb) {\n return this._requestAllPages(`/repos/${this.__repository}/issues`, options, cb);\n }\n\n /**\n * List the events for an issue\n * @see https://developer.github.com/v3/issues/events/#list-events-for-an-issue\n * @param {number} issue - the issue to get events for\n * @param {Requestable.callback} [cb] - will receive the list of events\n * @return {Promise} - the promise for the http request\n */\n listIssueEvents(issue, cb) {\n return this._request('GET', `/repos/${this.__repository}/issues/${issue}/events`, null, cb);\n }\n\n /**\n * List comments on an issue\n * @see https://developer.github.com/v3/issues/comments/#list-comments-on-an-issue\n * @param {number} issue - the id of the issue to get comments from\n * @param {Requestable.callback} [cb] - will receive the comments\n * @return {Promise} - the promise for the http request\n */\n listIssueComments(issue, cb) {\n return this._request('GET', `/repos/${this.__repository}/issues/${issue}/comments`, null, cb);\n }\n\n /**\n * Get a single comment on an issue\n * @see https://developer.github.com/v3/issues/comments/#get-a-single-comment\n * @param {number} id - the comment id to get\n * @param {Requestable.callback} [cb] - will receive the comment\n * @return {Promise} - the promise for the http request\n */\n getIssueComment(id, cb) {\n return this._request('GET', `/repos/${this.__repository}/issues/comments/${id}`, null, cb);\n }\n\n /**\n * Comment on an issue\n * @see https://developer.github.com/v3/issues/comments/#create-a-comment\n * @param {number} issue - the id of the issue to comment on\n * @param {string} comment - the comment to add\n * @param {Requestable.callback} [cb] - will receive the created comment\n * @return {Promise} - the promise for the http request\n */\n createIssueComment(issue, comment, cb) {\n return this._request('POST', `/repos/${this.__repository}/issues/${issue}/comments`, {body: comment}, cb);\n }\n\n /**\n * Edit a comment on an issue\n * @see https://developer.github.com/v3/issues/comments/#edit-a-comment\n * @param {number} id - the comment id to edit\n * @param {string} comment - the comment to edit\n * @param {Requestable.callback} [cb] - will receive the edited comment\n * @return {Promise} - the promise for the http request\n */\n editIssueComment(id, comment, cb) {\n return this._request('PATCH', `/repos/${this.__repository}/issues/comments/${id}`, {body: comment}, cb);\n }\n\n /**\n * Delete a comment on an issue\n * @see https://developer.github.com/v3/issues/comments/#delete-a-comment\n * @param {number} id - the comment id to delete\n * @param {Requestable.callback} [cb] - will receive true if the request is successful\n * @return {Promise} - the promise for the http request\n */\n deleteIssueComment(id, cb) {\n return this._request('DELETE', `/repos/${this.__repository}/issues/comments/${id}`, null, cb);\n }\n\n /**\n * Edit an issue\n * @see https://developer.github.com/v3/issues/#edit-an-issue\n * @param {number} issue - the issue number to edit\n * @param {Object} issueData - the new issue data\n * @param {Requestable.callback} [cb] - will receive the modified issue\n * @return {Promise} - the promise for the http request\n */\n editIssue(issue, issueData, cb) {\n return this._request('PATCH', `/repos/${this.__repository}/issues/${issue}`, issueData, cb);\n }\n\n /**\n * Get a particular issue\n * @see https://developer.github.com/v3/issues/#get-a-single-issue\n * @param {number} issue - the issue number to fetch\n * @param {Requestable.callback} [cb] - will receive the issue\n * @return {Promise} - the promise for the http request\n */\n getIssue(issue, cb) {\n return this._request('GET', `/repos/${this.__repository}/issues/${issue}`, null, cb);\n }\n\n /**\n * List the milestones for the repository\n * @see https://developer.github.com/v3/issues/milestones/#list-milestones-for-a-repository\n * @param {Object} options - filtering options\n * @param {Requestable.callback} [cb] - will receive the array of milestones\n * @return {Promise} - the promise for the http request\n */\n listMilestones(options, cb) {\n return this._request('GET', `/repos/${this.__repository}/milestones`, options, cb);\n }\n\n /**\n * Get a milestone\n * @see https://developer.github.com/v3/issues/milestones/#get-a-single-milestone\n * @param {string} milestone - the id of the milestone to fetch\n * @param {Requestable.callback} [cb] - will receive the milestone\n * @return {Promise} - the promise for the http request\n */\n getMilestone(milestone, cb) {\n return this._request('GET', `/repos/${this.__repository}/milestones/${milestone}`, null, cb);\n }\n\n /**\n * Create a new milestone\n * @see https://developer.github.com/v3/issues/milestones/#create-a-milestone\n * @param {Object} milestoneData - the milestone definition\n * @param {Requestable.callback} [cb] - will receive the milestone\n * @return {Promise} - the promise for the http request\n */\n createMilestone(milestoneData, cb) {\n return this._request('POST', `/repos/${this.__repository}/milestones`, milestoneData, cb);\n }\n\n /**\n * Edit a milestone\n * @see https://developer.github.com/v3/issues/milestones/#update-a-milestone\n * @param {string} milestone - the id of the milestone to edit\n * @param {Object} milestoneData - the updates to make to the milestone\n * @param {Requestable.callback} [cb] - will receive the updated milestone\n * @return {Promise} - the promise for the http request\n */\n editMilestone(milestone, milestoneData, cb) {\n return this._request('PATCH', `/repos/${this.__repository}/milestones/${milestone}`, milestoneData, cb);\n }\n\n /**\n * Delete a milestone (this is distinct from closing a milestone)\n * @see https://developer.github.com/v3/issues/milestones/#delete-a-milestone\n * @param {string} milestone - the id of the milestone to delete\n * @param {Requestable.callback} [cb] - will receive the status\n * @return {Promise} - the promise for the http request\n */\n deleteMilestone(milestone, cb) {\n return this._request('DELETE', `/repos/${this.__repository}/milestones/${milestone}`, null, cb);\n }\n\n /**\n * Create a new label\n * @see https://developer.github.com/v3/issues/labels/#create-a-label\n * @param {Object} labelData - the label definition\n * @param {Requestable.callback} [cb] - will receive the object representing the label\n * @return {Promise} - the promise for the http request\n */\n createLabel(labelData, cb) {\n return this._request('POST', `/repos/${this.__repository}/labels`, labelData, cb);\n }\n\n /**\n * List the labels for the repository\n * @see https://developer.github.com/v3/issues/labels/#list-all-labels-for-this-repository\n * @param {Object} options - filtering options\n * @param {Requestable.callback} [cb] - will receive the array of labels\n * @return {Promise} - the promise for the http request\n */\n listLabels(options, cb) {\n return this._request('GET', `/repos/${this.__repository}/labels`, options, cb);\n }\n\n /**\n * Get a label\n * @see https://developer.github.com/v3/issues/labels/#get-a-single-label\n * @param {string} label - the name of the label to fetch\n * @param {Requestable.callback} [cb] - will receive the label\n * @return {Promise} - the promise for the http request\n */\n getLabel(label, cb) {\n return this._request('GET', `/repos/${this.__repository}/labels/${label}`, null, cb);\n }\n\n /**\n * Edit a label\n * @see https://developer.github.com/v3/issues/labels/#update-a-label\n * @param {string} label - the name of the label to edit\n * @param {Object} labelData - the updates to make to the label\n * @param {Requestable.callback} [cb] - will receive the updated label\n * @return {Promise} - the promise for the http request\n */\n editLabel(label, labelData, cb) {\n return this._request('PATCH', `/repos/${this.__repository}/labels/${label}`, labelData, cb);\n }\n\n /**\n * Delete a label\n * @see https://developer.github.com/v3/issues/labels/#delete-a-label\n * @param {string} label - the name of the label to delete\n * @param {Requestable.callback} [cb] - will receive the status\n * @return {Promise} - the promise for the http request\n */\n deleteLabel(label, cb) {\n return this._request('DELETE', `/repos/${this.__repository}/labels/${label}`, null, cb);\n }\n}\n\nmodule.exports = Issue;\n","/**\n * @file\n * @copyright 2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n * Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\n\n/**\n * Renders html from Markdown text\n */\nclass Markdown extends Requestable {\n /**\n * construct a Markdown\n * @param {Requestable.auth} auth - the credentials to authenticate to GitHub\n * @param {string} [apiBase] - the base Github API URL\n * @return {Promise} - the promise for the http request\n */\n constructor(auth, apiBase) {\n super(auth, apiBase);\n }\n\n /**\n * Render html from Markdown text.\n * @see https://developer.github.com/v3/markdown/#render-an-arbitrary-markdown-document\n * @param {Object} options - conversion options\n * @param {string} [options.text] - the markdown text to convert\n * @param {string} [options.mode=markdown] - can be either `markdown` or `gfm`\n * @param {string} [options.context] - repository name if mode is gfm\n * @param {Requestable.callback} [cb] - will receive the converted html\n * @return {Promise} - the promise for the http request\n */\n render(options, cb) {\n return this._request('POST', '/markdown', options, cb);\n }\n}\n\nmodule.exports = Markdown;\n","/**\n * @file\n * @copyright 2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n * Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\n\n/**\n * Organization encapsulates the functionality to create repositories in organizations\n */\nclass Organization extends Requestable {\n /**\n * Create a new Organization\n * @param {string} organization - the name of the organization\n * @param {Requestable.auth} [auth] - information required to authenticate to Github\n * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n */\n constructor(organization, auth, apiBase) {\n super(auth, apiBase);\n this.__name = organization;\n }\n\n /**\n * Create a repository in an organization\n * @see https://developer.github.com/v3/repos/#create\n * @param {Object} options - the repository definition\n * @param {Requestable.callback} [cb] - will receive the created repository\n * @return {Promise} - the promise for the http request\n */\n createRepo(options, cb) {\n return this._request('POST', `/orgs/${this.__name}/repos`, options, cb);\n }\n\n /**\n * List the repositories in an organization\n * @see https://developer.github.com/v3/repos/#list-organization-repositories\n * @param {Requestable.callback} [cb] - will receive the list of repositories\n * @return {Promise} - the promise for the http request\n */\n getRepos(cb) {\n let requestOptions = this._getOptionsWithDefaults({direction: 'desc'});\n\n return this._requestAllPages(`/orgs/${this.__name}/repos`, requestOptions, cb);\n }\n\n /**\n * Query if the user is a member or not\n * @param {string} username - the user in question\n * @param {Requestable.callback} [cb] - will receive true if the user is a member\n * @return {Promise} - the promise for the http request\n */\n isMember(username, cb) {\n return this._request204or404(`/orgs/${this.__name}/members/${username}`, null, cb);\n }\n\n /**\n * List the users who are members of the company\n * @see https://developer.github.com/v3/orgs/members/#members-list\n * @param {object} options - filtering options\n * @param {string} [options.filter=all] - can be either `2fa_disabled` or `all`\n * @param {string} [options.role=all] - can be one of: `all`, `admin`, or `member`\n * @param {Requestable.callback} [cb] - will receive the list of users\n * @return {Promise} - the promise for the http request\n */\n listMembers(options, cb) {\n return this._request('GET', `/orgs/${this.__name}/members`, options, cb);\n }\n\n /**\n * List the Teams in the Organization\n * @see https://developer.github.com/v3/orgs/teams/#list-teams\n * @param {Requestable.callback} [cb] - will receive the list of teams\n * @return {Promise} - the promise for the http request\n */\n getTeams(cb) {\n return this._requestAllPages(`/orgs/${this.__name}/teams`, undefined, cb);\n }\n\n /**\n * Create a team\n * @see https://developer.github.com/v3/orgs/teams/#create-team\n * @param {object} options - Team creation parameters\n * @param {string} options.name - The name of the team\n * @param {string} [options.description] - Team description\n * @param {string} [options.repo_names] - Repos to add the team to\n * @param {string} [options.privacy=secret] - The level of privacy the team should have. Can be either one\n * of: `secret`, or `closed`\n * @param {Requestable.callback} [cb] - will receive the created team\n * @return {Promise} - the promise for the http request\n */\n createTeam(options, cb) {\n return this._request('POST', `/orgs/${this.__name}/teams`, options, cb);\n }\n\n /**\n * Get information about all projects\n * @see https://developer.github.com/v3/projects/#list-organization-projects\n * @param {Requestable.callback} [cb] - will receive the list of projects\n * @return {Promise} - the promise for the http request\n */\n listProjects(cb) {\n return this._requestAllPages(`/orgs/${this.__name}/projects`, {AcceptHeader: 'inertia-preview'}, cb);\n }\n\n /**\n * Create a new project\n * @see https://developer.github.com/v3/repos/projects/#create-a-project\n * @param {Object} options - the description of the project\n * @param {Requestable.callback} cb - will receive the newly created project\n * @return {Promise} - the promise for the http request\n */\n createProject(options, cb) {\n options = options || {};\n options.AcceptHeader = 'inertia-preview';\n return this._request('POST', `/orgs/${this.__name}/projects`, options, cb);\n }\n}\n\nmodule.exports = Organization;\n","/**\n * @file\n * @copyright 2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n * Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\n\n/**\n * Project encapsulates the functionality to create, query, and modify cards and columns.\n */\nclass Project extends Requestable {\n /**\n * Create a Project.\n * @param {string} id - the id of the project\n * @param {Requestable.auth} [auth] - information required to authenticate to Github\n * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n */\n constructor(id, auth, apiBase) {\n super(auth, apiBase, 'inertia-preview');\n this.__id = id;\n }\n\n /**\n * Get information about a project\n * @see https://developer.github.com/v3/projects/#get-a-project\n * @param {Requestable.callback} cb - will receive the project information\n * @return {Promise} - the promise for the http request\n */\n getProject(cb) {\n return this._request('GET', `/projects/${this.__id}`, null, cb);\n }\n\n /**\n * Edit a project\n * @see https://developer.github.com/v3/projects/#update-a-project\n * @param {Object} options - the description of the project\n * @param {Requestable.callback} cb - will receive the modified project\n * @return {Promise} - the promise for the http request\n */\n updateProject(options, cb) {\n return this._request('PATCH', `/projects/${this.__id}`, options, cb);\n }\n\n /**\n * Delete a project\n * @see https://developer.github.com/v3/projects/#delete-a-project\n * @param {Requestable.callback} cb - will receive true if the operation is successful\n * @return {Promise} - the promise for the http request\n */\n deleteProject(cb) {\n return this._request('DELETE', `/projects/${this.__id}`, null, cb);\n }\n\n /**\n * Get information about all columns of a project\n * @see https://developer.github.com/v3/projects/columns/#list-project-columns\n * @param {Requestable.callback} [cb] - will receive the list of columns\n * @return {Promise} - the promise for the http request\n */\n listProjectColumns(cb) {\n return this._requestAllPages(`/projects/${this.__id}/columns`, null, cb);\n }\n\n /**\n * Get information about a column\n * @see https://developer.github.com/v3/projects/columns/#get-a-project-column\n * @param {string} colId - the id of the column\n * @param {Requestable.callback} cb - will receive the column information\n * @return {Promise} - the promise for the http request\n */\n getProjectColumn(colId, cb) {\n return this._request('GET', `/projects/columns/${colId}`, null, cb);\n }\n\n /**\n * Create a new column\n * @see https://developer.github.com/v3/projects/columns/#create-a-project-column\n * @param {Object} options - the description of the column\n * @param {Requestable.callback} cb - will receive the newly created column\n * @return {Promise} - the promise for the http request\n */\n createProjectColumn(options, cb) {\n return this._request('POST', `/projects/${this.__id}/columns`, options, cb);\n }\n\n /**\n * Edit a column\n * @see https://developer.github.com/v3/projects/columns/#update-a-project-column\n * @param {string} colId - the column id\n * @param {Object} options - the description of the column\n * @param {Requestable.callback} cb - will receive the modified column\n * @return {Promise} - the promise for the http request\n */\n updateProjectColumn(colId, options, cb) {\n return this._request('PATCH', `/projects/columns/${colId}`, options, cb);\n }\n\n /**\n * Delete a column\n * @see https://developer.github.com/v3/projects/columns/#delete-a-project-column\n * @param {string} colId - the column to be deleted\n * @param {Requestable.callback} cb - will receive true if the operation is successful\n * @return {Promise} - the promise for the http request\n */\n deleteProjectColumn(colId, cb) {\n return this._request('DELETE', `/projects/columns/${colId}`, null, cb);\n }\n\n /**\n * Move a column\n * @see https://developer.github.com/v3/projects/columns/#move-a-project-column\n * @param {string} colId - the column to be moved\n * @param {string} position - can be one of first, last, or after:,\n * where is the id value of a column in the same project.\n * @param {Requestable.callback} cb - will receive true if the operation is successful\n * @return {Promise} - the promise for the http request\n */\n moveProjectColumn(colId, position, cb) {\n return this._request(\n 'POST',\n `/projects/columns/${colId}/moves`,\n {position: position},\n cb\n );\n }\n\n /**\n * Get information about all cards of a project\n * @see https://developer.github.com/v3/projects/cards/#list-project-cards\n * @param {Requestable.callback} [cb] - will receive the list of cards\n * @return {Promise} - the promise for the http request\n */\n listProjectCards(cb) {\n return this.listProjectColumns()\n .then(({data}) => {\n return Promise.all(data.map((column) => {\n return this._requestAllPages(`/projects/columns/${column.id}/cards`, null);\n }));\n }).then((cardsInColumns) => {\n const cards = cardsInColumns.reduce((prev, {data}) => {\n prev.push(...data);\n return prev;\n }, []);\n if (cb) {\n cb(null, cards);\n }\n return cards;\n }).catch((err) => {\n if (cb) {\n cb(err);\n return;\n }\n throw err;\n });\n }\n\n /**\n * Get information about all cards of a column\n * @see https://developer.github.com/v3/projects/cards/#list-project-cards\n * @param {string} colId - the id of the column\n * @param {Requestable.callback} [cb] - will receive the list of cards\n * @return {Promise} - the promise for the http request\n */\n listColumnCards(colId, cb) {\n return this._requestAllPages(`/projects/columns/${colId}/cards`, null, cb);\n }\n\n /**\n * Get information about a card\n * @see https://developer.github.com/v3/projects/cards/#get-a-project-card\n * @param {string} cardId - the id of the card\n * @param {Requestable.callback} cb - will receive the card information\n * @return {Promise} - the promise for the http request\n */\n getProjectCard(cardId, cb) {\n return this._request('GET', `/projects/columns/cards/${cardId}`, null, cb);\n }\n\n /**\n * Create a new card\n * @see https://developer.github.com/v3/projects/cards/#create-a-project-card\n * @param {string} colId - the column id\n * @param {Object} options - the description of the card\n * @param {Requestable.callback} cb - will receive the newly created card\n * @return {Promise} - the promise for the http request\n */\n createProjectCard(colId, options, cb) {\n return this._request('POST', `/projects/columns/${colId}/cards`, options, cb);\n }\n\n /**\n * Edit a card\n * @see https://developer.github.com/v3/projects/cards/#update-a-project-card\n * @param {string} cardId - the card id\n * @param {Object} options - the description of the card\n * @param {Requestable.callback} cb - will receive the modified card\n * @return {Promise} - the promise for the http request\n */\n updateProjectCard(cardId, options, cb) {\n return this._request('PATCH', `/projects/columns/cards/${cardId}`, options, cb);\n }\n\n /**\n * Delete a card\n * @see https://developer.github.com/v3/projects/cards/#delete-a-project-card\n * @param {string} cardId - the card to be deleted\n * @param {Requestable.callback} cb - will receive true if the operation is successful\n * @return {Promise} - the promise for the http request\n */\n deleteProjectCard(cardId, cb) {\n return this._request('DELETE', `/projects/columns/cards/${cardId}`, null, cb);\n }\n\n /**\n * Move a card\n * @see https://developer.github.com/v3/projects/cards/#move-a-project-card\n * @param {string} cardId - the card to be moved\n * @param {string} position - can be one of top, bottom, or after:,\n * where is the id value of a card in the same project.\n * @param {string} colId - the id value of a column in the same project.\n * @param {Requestable.callback} cb - will receive true if the operation is successful\n * @return {Promise} - the promise for the http request\n */\n moveProjectCard(cardId, position, colId, cb) {\n return this._request(\n 'POST',\n `/projects/columns/cards/${cardId}/moves`,\n {position: position, column_id: colId}, // eslint-disable-line camelcase\n cb\n );\n }\n}\n\nmodule.exports = Project;\n","/**\n * @file\n * @copyright 2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n * Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\n\n/**\n * RateLimit allows users to query their rate-limit status\n */\nclass RateLimit extends Requestable {\n /**\n * construct a RateLimit\n * @param {Requestable.auth} auth - the credentials to authenticate to GitHub\n * @param {string} [apiBase] - the base Github API URL\n * @return {Promise} - the promise for the http request\n */\n constructor(auth, apiBase) {\n super(auth, apiBase);\n }\n\n /**\n * Query the current rate limit\n * @see https://developer.github.com/v3/rate_limit/\n * @param {Requestable.callback} [cb] - will receive the rate-limit data\n * @return {Promise} - the promise for the http request\n */\n getRateLimit(cb) {\n return this._request('GET', '/rate_limit', null, cb);\n }\n}\n\nmodule.exports = RateLimit;\n","/**\n * @file\n * @copyright 2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n * Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\nimport Utf8 from 'utf8';\nimport {\n Base64,\n} from 'js-base64';\nimport debug from 'debug';\nconst log = debug('github:repository');\n\n/**\n * Respository encapsulates the functionality to create, query, and modify files.\n */\nclass Repository extends Requestable {\n /**\n * Create a Repository.\n * @param {string} fullname - the full name of the repository\n * @param {Requestable.auth} [auth] - information required to authenticate to Github\n * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n */\n constructor(fullname, auth, apiBase) {\n super(auth, apiBase);\n this.__fullname = fullname;\n this.__currentTree = {\n branch: null,\n sha: null,\n };\n }\n\n /**\n * Get a reference\n * @see https://developer.github.com/v3/git/refs/#get-a-reference\n * @param {string} ref - the reference to get\n * @param {Requestable.callback} [cb] - will receive the reference's refSpec or a list of refSpecs that match `ref`\n * @return {Promise} - the promise for the http request\n */\n getRef(ref, cb) {\n return this._request('GET', `/repos/${this.__fullname}/git/refs/${ref}`, null, cb);\n }\n\n /**\n * Create a reference\n * @see https://developer.github.com/v3/git/refs/#create-a-reference\n * @param {Object} options - the object describing the ref\n * @param {Requestable.callback} [cb] - will receive the ref\n * @return {Promise} - the promise for the http request\n */\n createRef(options, cb) {\n return this._request('POST', `/repos/${this.__fullname}/git/refs`, options, cb);\n }\n\n /**\n * Delete a reference\n * @see https://developer.github.com/v3/git/refs/#delete-a-reference\n * @param {string} ref - the name of the ref to delte\n * @param {Requestable.callback} [cb] - will receive true if the request is successful\n * @return {Promise} - the promise for the http request\n */\n deleteRef(ref, cb) {\n return this._request('DELETE', `/repos/${this.__fullname}/git/refs/${ref}`, null, cb);\n }\n\n /**\n * Delete a repository\n * @see https://developer.github.com/v3/repos/#delete-a-repository\n * @param {Requestable.callback} [cb] - will receive true if the request is successful\n * @return {Promise} - the promise for the http request\n */\n deleteRepo(cb) {\n return this._request('DELETE', `/repos/${this.__fullname}`, null, cb);\n }\n\n /**\n * List the tags on a repository\n * @see https://developer.github.com/v3/repos/#list-tags\n * @param {Requestable.callback} [cb] - will receive the tag data\n * @return {Promise} - the promise for the http request\n */\n listTags(cb) {\n return this._request('GET', `/repos/${this.__fullname}/tags`, null, cb);\n }\n\n /**\n * List the open pull requests on the repository\n * @see https://developer.github.com/v3/pulls/#list-pull-requests\n * @param {Object} options - options to filter the search\n * @param {Requestable.callback} [cb] - will receive the list of PRs\n * @return {Promise} - the promise for the http request\n */\n listPullRequests(options, cb) {\n options = options || {};\n return this._request('GET', `/repos/${this.__fullname}/pulls`, options, cb);\n }\n\n /**\n * Get information about a specific pull request\n * @see https://developer.github.com/v3/pulls/#get-a-single-pull-request\n * @param {number} number - the PR you wish to fetch\n * @param {Requestable.callback} [cb] - will receive the PR from the API\n * @return {Promise} - the promise for the http request\n */\n getPullRequest(number, cb) {\n return this._request('GET', `/repos/${this.__fullname}/pulls/${number}`, null, cb);\n }\n\n /**\n * List the files of a specific pull request\n * @see https://developer.github.com/v3/pulls/#list-pull-requests-files\n * @param {number|string} number - the PR you wish to fetch\n * @param {Requestable.callback} [cb] - will receive the list of files from the API\n * @return {Promise} - the promise for the http request\n */\n listPullRequestFiles(number, cb) {\n return this._request('GET', `/repos/${this.__fullname}/pulls/${number}/files`, null, cb);\n }\n\n /**\n * Compare two branches/commits/repositories\n * @see https://developer.github.com/v3/repos/commits/#compare-two-commits\n * @param {string} base - the base commit\n * @param {string} head - the head commit\n * @param {Requestable.callback} cb - will receive the comparison\n * @return {Promise} - the promise for the http request\n */\n compareBranches(base, head, cb) {\n return this._request('GET', `/repos/${this.__fullname}/compare/${base}...${head}`, null, cb);\n }\n\n /**\n * List all the branches for the repository\n * @see https://developer.github.com/v3/repos/#list-branches\n * @param {Requestable.callback} cb - will receive the list of branches\n * @return {Promise} - the promise for the http request\n */\n listBranches(cb) {\n return this._request('GET', `/repos/${this.__fullname}/branches`, null, cb);\n }\n\n /**\n * Get a raw blob from the repository\n * @see https://developer.github.com/v3/git/blobs/#get-a-blob\n * @param {string} sha - the sha of the blob to fetch\n * @param {Requestable.callback} cb - will receive the blob from the API\n * @return {Promise} - the promise for the http request\n */\n getBlob(sha, cb) {\n return this._request('GET', `/repos/${this.__fullname}/git/blobs/${sha}`, null, cb, 'raw');\n }\n\n /**\n * Get a single branch\n * @see https://developer.github.com/v3/repos/branches/#get-branch\n * @param {string} branch - the name of the branch to fetch\n * @param {Requestable.callback} cb - will receive the branch from the API\n * @returns {Promise} - the promise for the http request\n */\n getBranch(branch, cb) {\n return this._request('GET', `/repos/${this.__fullname}/branches/${branch}`, null, cb);\n }\n\n /**\n * Get a commit from the repository\n * @see https://developer.github.com/v3/repos/commits/#get-a-single-commit\n * @param {string} sha - the sha for the commit to fetch\n * @param {Requestable.callback} cb - will receive the commit data\n * @return {Promise} - the promise for the http request\n */\n getCommit(sha, cb) {\n return this._request('GET', `/repos/${this.__fullname}/git/commits/${sha}`, null, cb);\n }\n\n /**\n * List the commits on a repository, optionally filtering by path, author or time range\n * @see https://developer.github.com/v3/repos/commits/#list-commits-on-a-repository\n * @param {Object} [options] - the filtering options for commits\n * @param {string} [options.sha] - the SHA or branch to start from\n * @param {string} [options.path] - the path to search on\n * @param {string} [options.author] - the commit author\n * @param {(Date|string)} [options.since] - only commits after this date will be returned\n * @param {(Date|string)} [options.until] - only commits before this date will be returned\n * @param {Requestable.callback} cb - will receive the list of commits found matching the criteria\n * @return {Promise} - the promise for the http request\n */\n listCommits(options, cb) {\n options = options || {};\n\n options.since = this._dateToISO(options.since);\n options.until = this._dateToISO(options.until);\n\n return this._request('GET', `/repos/${this.__fullname}/commits`, options, cb);\n }\n\n /**\n * Gets a single commit information for a repository\n * @see https://developer.github.com/v3/repos/commits/#get-a-single-commit\n * @param {string} ref - the reference for the commit-ish\n * @param {Requestable.callback} cb - will receive the commit information\n * @return {Promise} - the promise for the http request\n */\n getSingleCommit(ref, cb) {\n ref = ref || '';\n return this._request('GET', `/repos/${this.__fullname}/commits/${ref}`, null, cb);\n }\n\n /**\n * Get tha sha for a particular object in the repository. This is a convenience function\n * @see https://developer.github.com/v3/repos/contents/#get-contents\n * @param {string} [branch] - the branch to look in, or the repository's default branch if omitted\n * @param {string} path - the path of the file or directory\n * @param {Requestable.callback} cb - will receive a description of the requested object, including a `SHA` property\n * @return {Promise} - the promise for the http request\n */\n getSha(branch, path, cb) {\n branch = branch ? `?ref=${branch}` : '';\n return this._request('GET', `/repos/${this.__fullname}/contents/${path}${branch}`, null, cb);\n }\n\n /**\n * List the commit statuses for a particular sha, branch, or tag\n * @see https://developer.github.com/v3/repos/statuses/#list-statuses-for-a-specific-ref\n * @param {string} sha - the sha, branch, or tag to get statuses for\n * @param {Requestable.callback} cb - will receive the list of statuses\n * @return {Promise} - the promise for the http request\n */\n listStatuses(sha, cb) {\n return this._request('GET', `/repos/${this.__fullname}/commits/${sha}/statuses`, null, cb);\n }\n\n /**\n * Get a description of a git tree\n * @see https://developer.github.com/v3/git/trees/#get-a-tree\n * @param {string} treeSHA - the SHA of the tree to fetch\n * @param {Requestable.callback} cb - will receive the callback data\n * @return {Promise} - the promise for the http request\n */\n getTree(treeSHA, cb) {\n return this._request('GET', `/repos/${this.__fullname}/git/trees/${treeSHA}`, null, cb);\n }\n\n /**\n * Create a blob\n * @see https://developer.github.com/v3/git/blobs/#create-a-blob\n * @param {(string|Buffer|Blob)} content - the content to add to the repository\n * @param {Requestable.callback} cb - will receive the details of the created blob\n * @return {Promise} - the promise for the http request\n */\n createBlob(content, cb) {\n let postBody = this._getContentObject(content);\n\n log('sending content', postBody);\n return this._request('POST', `/repos/${this.__fullname}/git/blobs`, postBody, cb);\n }\n\n /**\n * Get the object that represents the provided content\n * @param {string|Buffer|Blob} content - the content to send to the server\n * @return {Object} the representation of `content` for the GitHub API\n */\n _getContentObject(content) {\n if (typeof content === 'string') {\n log('contet is a string');\n return {\n content: Utf8.encode(content),\n encoding: 'utf-8',\n };\n\n } else if (typeof Buffer !== 'undefined' && content instanceof Buffer) {\n log('We appear to be in Node');\n return {\n content: content.toString('base64'),\n encoding: 'base64',\n };\n\n } else if (typeof Blob !== 'undefined' && content instanceof Blob) {\n log('We appear to be in the browser');\n return {\n content: Base64.encode(content),\n encoding: 'base64',\n };\n\n } else { // eslint-disable-line\n log(`Not sure what this content is: ${typeof content}, ${JSON.stringify(content)}`);\n throw new Error('Unknown content passed to postBlob. Must be string or Buffer (node) or Blob (web)');\n }\n }\n\n /**\n * Update a tree in Git\n * @see https://developer.github.com/v3/git/trees/#create-a-tree\n * @param {string} baseTreeSHA - the SHA of the tree to update\n * @param {string} path - the path for the new file\n * @param {string} blobSHA - the SHA for the blob to put at `path`\n * @param {Requestable.callback} cb - will receive the new tree that is created\n * @return {Promise} - the promise for the http request\n * @deprecated use {@link Repository#createTree} instead\n */\n updateTree(baseTreeSHA, path, blobSHA, cb) {\n let newTree = {\n base_tree: baseTreeSHA, // eslint-disable-line\n tree: [{\n path: path,\n sha: blobSHA,\n mode: '100644',\n type: 'blob',\n }],\n };\n\n return this._request('POST', `/repos/${this.__fullname}/git/trees`, newTree, cb);\n }\n\n /**\n * Create a new tree in git\n * @see https://developer.github.com/v3/git/trees/#create-a-tree\n * @param {Object} tree - the tree to create\n * @param {string} baseSHA - the root sha of the tree\n * @param {Requestable.callback} cb - will receive the new tree that is created\n * @return {Promise} - the promise for the http request\n */\n createTree(tree, baseSHA, cb) {\n return this._request('POST', `/repos/${this.__fullname}/git/trees`, {\n tree,\n base_tree: baseSHA, // eslint-disable-line camelcase\n }, cb);\n }\n\n /**\n * Add a commit to the repository\n * @see https://developer.github.com/v3/git/commits/#create-a-commit\n * @param {string} parent - the SHA of the parent commit\n * @param {string} tree - the SHA of the tree for this commit\n * @param {string} message - the commit message\n * @param {Requestable.callback} cb - will receive the commit that is created\n * @return {Promise} - the promise for the http request\n */\n commit(parent, tree, message, cb) {\n let data = {\n message,\n tree,\n parents: [parent],\n };\n\n return this._request('POST', `/repos/${this.__fullname}/git/commits`, data, cb)\n .then((response) => {\n this.__currentTree.sha = response.data.sha; // Update latest commit\n return response;\n });\n }\n\n /**\n * Update a ref\n * @see https://developer.github.com/v3/git/refs/#update-a-reference\n * @param {string} ref - the ref to update\n * @param {string} commitSHA - the SHA to point the reference to\n * @param {boolean} force - indicates whether to force or ensure a fast-forward update\n * @param {Requestable.callback} cb - will receive the updated ref back\n * @return {Promise} - the promise for the http request\n */\n updateHead(ref, commitSHA, force, cb) {\n return this._request('PATCH', `/repos/${this.__fullname}/git/refs/${ref}`, {\n sha: commitSHA,\n force: force,\n }, cb);\n }\n\n /**\n * Update commit status\n * @see https://developer.github.com/v3/repos/statuses/\n * @param {string} commitSHA - the SHA of the commit that should be updated\n * @param {object} options - Commit status parameters\n * @param {string} options.state - The state of the status. Can be one of: pending, success, error, or failure.\n * @param {string} [options.target_url] - The target URL to associate with this status.\n * @param {string} [options.description] - A short description of the status.\n * @param {string} [options.context] - A string label to differentiate this status among CI systems.\n * @param {Requestable.callback} cb - will receive the updated commit back\n * @return {Promise} - the promise for the http request\n */\n updateStatus(commitSHA, options, cb) {\n return this._request('POST', `/repos/${this.__fullname}/statuses/${commitSHA}`, options, cb);\n }\n\n /**\n * Update repository information\n * @see https://developer.github.com/v3/repos/#edit\n * @param {object} options - New parameters that will be set to the repository\n * @param {string} options.name - Name of the repository\n * @param {string} [options.description] - A short description of the repository\n * @param {string} [options.homepage] - A URL with more information about the repository\n * @param {boolean} [options.private] - Either true to make the repository private, or false to make it public.\n * @param {boolean} [options.has_issues] - Either true to enable issues for this repository, false to disable them.\n * @param {boolean} [options.has_wiki] - Either true to enable the wiki for this repository, false to disable it.\n * @param {boolean} [options.has_downloads] - Either true to enable downloads, false to disable them.\n * @param {string} [options.default_branch] - Updates the default branch for this repository.\n * @param {Requestable.callback} cb - will receive the updated repository back\n * @return {Promise} - the promise for the http request\n */\n updateRepository(options, cb) {\n return this._request('PATCH', `/repos/${this.__fullname}`, options, cb);\n }\n\n /**\n * Get information about the repository\n * @see https://developer.github.com/v3/repos/#get\n * @param {Requestable.callback} cb - will receive the information about the repository\n * @return {Promise} - the promise for the http request\n */\n getDetails(cb) {\n return this._request('GET', `/repos/${this.__fullname}`, null, cb);\n }\n\n /**\n * List the contributors to the repository\n * @see https://developer.github.com/v3/repos/#list-contributors\n * @param {Requestable.callback} cb - will receive the list of contributors\n * @return {Promise} - the promise for the http request\n */\n getContributors(cb) {\n return this._request('GET', `/repos/${this.__fullname}/contributors`, null, cb);\n }\n\n /**\n * List the contributor stats to the repository\n * @see https://developer.github.com/v3/repos/#list-contributors\n * @param {Requestable.callback} cb - will receive the list of contributors\n * @return {Promise} - the promise for the http request\n */\n getContributorStats(cb) {\n return this._request('GET', `/repos/${this.__fullname}/stats/contributors`, null, cb);\n }\n\n /**\n * List the users who are collaborators on the repository. The currently authenticated user must have\n * push access to use this method\n * @see https://developer.github.com/v3/repos/collaborators/#list-collaborators\n * @param {Requestable.callback} cb - will receive the list of collaborators\n * @return {Promise} - the promise for the http request\n */\n getCollaborators(cb) {\n return this._request('GET', `/repos/${this.__fullname}/collaborators`, null, cb);\n }\n\n /**\n * Check if a user is a collaborator on the repository\n * @see https://developer.github.com/v3/repos/collaborators/#check-if-a-user-is-a-collaborator\n * @param {string} username - the user to check\n * @param {Requestable.callback} cb - will receive true if the user is a collaborator and false if they are not\n * @return {Promise} - the promise for the http request {Boolean} [description]\n */\n isCollaborator(username, cb) {\n return this._request('GET', `/repos/${this.__fullname}/collaborators/${username}`, null, cb);\n }\n\n /**\n * Get the contents of a repository\n * @see https://developer.github.com/v3/repos/contents/#get-contents\n * @param {string} ref - the ref to check\n * @param {string} path - the path containing the content to fetch\n * @param {boolean} raw - `true` if the results should be returned raw instead of GitHub's normalized format\n * @param {Requestable.callback} cb - will receive the fetched data\n * @return {Promise} - the promise for the http request\n */\n getContents(ref, path, raw, cb) {\n path = path ? `${encodeURI(path)}` : '';\n return this._request('GET', `/repos/${this.__fullname}/contents/${path}`, {\n ref,\n }, cb, raw);\n }\n\n /**\n * Get the README of a repository\n * @see https://developer.github.com/v3/repos/contents/#get-the-readme\n * @param {string} ref - the ref to check\n * @param {boolean} raw - `true` if the results should be returned raw instead of GitHub's normalized format\n * @param {Requestable.callback} cb - will receive the fetched data\n * @return {Promise} - the promise for the http request\n */\n getReadme(ref, raw, cb) {\n return this._request('GET', `/repos/${this.__fullname}/readme`, {\n ref,\n }, cb, raw);\n }\n\n /**\n * Fork a repository\n * @see https://developer.github.com/v3/repos/forks/#create-a-fork\n * @param {Requestable.callback} cb - will receive the information about the newly created fork\n * @return {Promise} - the promise for the http request\n */\n fork(cb) {\n return this._request('POST', `/repos/${this.__fullname}/forks`, null, cb);\n }\n\n /**\n * List a repository's forks\n * @see https://developer.github.com/v3/repos/forks/#list-forks\n * @param {Requestable.callback} cb - will receive the list of repositories forked from this one\n * @return {Promise} - the promise for the http request\n */\n listForks(cb) {\n return this._request('GET', `/repos/${this.__fullname}/forks`, null, cb);\n }\n\n /**\n * Create a new branch from an existing branch.\n * @param {string} [oldBranch=master] - the name of the existing branch\n * @param {string} newBranch - the name of the new branch\n * @param {Requestable.callback} cb - will receive the commit data for the head of the new branch\n * @return {Promise} - the promise for the http request\n */\n createBranch(oldBranch, newBranch, cb) {\n if (typeof newBranch === 'function') {\n cb = newBranch;\n newBranch = oldBranch;\n oldBranch = 'master';\n }\n\n return this.getRef(`heads/${oldBranch}`)\n .then((response) => {\n let sha = response.data.object.sha;\n return this.createRef({\n sha,\n ref: `refs/heads/${newBranch}`,\n }, cb);\n });\n }\n\n /**\n * Create a new pull request\n * @see https://developer.github.com/v3/pulls/#create-a-pull-request\n * @param {Object} options - the pull request description\n * @param {Requestable.callback} cb - will receive the new pull request\n * @return {Promise} - the promise for the http request\n */\n createPullRequest(options, cb) {\n return this._request('POST', `/repos/${this.__fullname}/pulls`, options, cb);\n }\n\n /**\n * Update a pull request\n * @see https://developer.github.com/v3/pulls/#update-a-pull-request\n * @param {number|string} number - the number of the pull request to update\n * @param {Object} options - the pull request description\n * @param {Requestable.callback} [cb] - will receive the pull request information\n * @return {Promise} - the promise for the http request\n */\n updatePullRequest(number, options, cb) {\n return this._request('PATCH', `/repos/${this.__fullname}/pulls/${number}`, options, cb);\n }\n\n /**\n * List the hooks for the repository\n * @see https://developer.github.com/v3/repos/hooks/#list-hooks\n * @param {Requestable.callback} cb - will receive the list of hooks\n * @return {Promise} - the promise for the http request\n */\n listHooks(cb) {\n return this._request('GET', `/repos/${this.__fullname}/hooks`, null, cb);\n }\n\n /**\n * Get a hook for the repository\n * @see https://developer.github.com/v3/repos/hooks/#get-single-hook\n * @param {number} id - the id of the webook\n * @param {Requestable.callback} cb - will receive the details of the webook\n * @return {Promise} - the promise for the http request\n */\n getHook(id, cb) {\n return this._request('GET', `/repos/${this.__fullname}/hooks/${id}`, null, cb);\n }\n\n /**\n * Add a new hook to the repository\n * @see https://developer.github.com/v3/repos/hooks/#create-a-hook\n * @param {Object} options - the configuration describing the new hook\n * @param {Requestable.callback} cb - will receive the new webhook\n * @return {Promise} - the promise for the http request\n */\n createHook(options, cb) {\n return this._request('POST', `/repos/${this.__fullname}/hooks`, options, cb);\n }\n\n /**\n * Edit an existing webhook\n * @see https://developer.github.com/v3/repos/hooks/#edit-a-hook\n * @param {number} id - the id of the webhook\n * @param {Object} options - the new description of the webhook\n * @param {Requestable.callback} cb - will receive the updated webhook\n * @return {Promise} - the promise for the http request\n */\n updateHook(id, options, cb) {\n return this._request('PATCH', `/repos/${this.__fullname}/hooks/${id}`, options, cb);\n }\n\n /**\n * Delete a webhook\n * @see https://developer.github.com/v3/repos/hooks/#delete-a-hook\n * @param {number} id - the id of the webhook to be deleted\n * @param {Requestable.callback} cb - will receive true if the call is successful\n * @return {Promise} - the promise for the http request\n */\n deleteHook(id, cb) {\n return this._request('DELETE', `/repos/${this.__fullname}/hooks/${id}`, null, cb);\n }\n\n /**\n * List the deploy keys for the repository\n * @see https://developer.github.com/v3/repos/keys/#list-deploy-keys\n * @param {Requestable.callback} cb - will receive the list of deploy keys\n * @return {Promise} - the promise for the http request\n */\n listKeys(cb) {\n return this._request('GET', `/repos/${this.__fullname}/keys`, null, cb);\n }\n\n /**\n * Get a deploy key for the repository\n * @see https://developer.github.com/v3/repos/keys/#get-a-deploy-key\n * @param {number} id - the id of the deploy key\n * @param {Requestable.callback} cb - will receive the details of the deploy key\n * @return {Promise} - the promise for the http request\n */\n getKey(id, cb) {\n return this._request('GET', `/repos/${this.__fullname}/keys/${id}`, null, cb);\n }\n\n /**\n * Add a new deploy key to the repository\n * @see https://developer.github.com/v3/repos/keys/#add-a-new-deploy-key\n * @param {Object} options - the configuration describing the new deploy key\n * @param {Requestable.callback} cb - will receive the new deploy key\n * @return {Promise} - the promise for the http request\n */\n createKey(options, cb) {\n return this._request('POST', `/repos/${this.__fullname}/keys`, options, cb);\n }\n\n /**\n * Delete a deploy key\n * @see https://developer.github.com/v3/repos/keys/#remove-a-deploy-key\n * @param {number} id - the id of the deploy key to be deleted\n * @param {Requestable.callback} cb - will receive true if the call is successful\n * @return {Promise} - the promise for the http request\n */\n deleteKey(id, cb) {\n return this._request('DELETE', `/repos/${this.__fullname}/keys/${id}`, null, cb);\n }\n\n /**\n * Delete a file from a branch\n * @see https://developer.github.com/v3/repos/contents/#delete-a-file\n * @param {string} branch - the branch to delete from, or the default branch if not specified\n * @param {string} path - the path of the file to remove\n * @param {Requestable.callback} cb - will receive the commit in which the delete occurred\n * @return {Promise} - the promise for the http request\n */\n deleteFile(branch, path, cb) {\n return this.getSha(branch, path)\n .then((response) => {\n const deleteCommit = {\n message: `Delete the file at '${path}'`,\n sha: response.data.sha,\n branch,\n };\n return this._request('DELETE', `/repos/${this.__fullname}/contents/${path}`, deleteCommit, cb);\n });\n }\n\n /**\n * Change all references in a repo from oldPath to new_path\n * @param {string} branch - the branch to carry out the reference change, or the default branch if not specified\n * @param {string} oldPath - original path\n * @param {string} newPath - new reference path\n * @param {Requestable.callback} cb - will receive the commit in which the move occurred\n * @return {Promise} - the promise for the http request\n */\n move(branch, oldPath, newPath, cb) {\n let oldSha;\n return this.getRef(`heads/${branch}`)\n .then(({data: {object}}) => this.getTree(`${object.sha}?recursive=true`))\n .then(({data: {tree, sha}}) => {\n oldSha = sha;\n let newTree = tree.map((ref) => {\n if (ref.path === oldPath) {\n ref.path = newPath;\n }\n if (ref.type === 'tree') {\n delete ref.sha;\n }\n return ref;\n });\n return this.createTree(newTree);\n })\n .then(({data: tree}) => this.commit(oldSha, tree.sha, `Renamed '${oldPath}' to '${newPath}'`))\n .then(({data: commit}) => this.updateHead(`heads/${branch}`, commit.sha, true, cb));\n }\n\n /**\n * Write a file to the repository\n * @see https://developer.github.com/v3/repos/contents/#update-a-file\n * @param {string} branch - the name of the branch\n * @param {string} path - the path for the file\n * @param {string} content - the contents of the file\n * @param {string} message - the commit message\n * @param {Object} [options] - commit options\n * @param {Object} [options.author] - the author of the commit\n * @param {Object} [options.commiter] - the committer\n * @param {boolean} [options.encode] - true if the content should be base64 encoded\n * @param {Requestable.callback} cb - will receive the new commit\n * @return {Promise} - the promise for the http request\n */\n writeFile(branch, path, content, message, options, cb) {\n if (typeof options === 'function') {\n cb = options;\n options = {};\n }\n let filePath = path ? encodeURI(path) : '';\n let shouldEncode = options.encode !== false;\n let commit = {\n branch,\n message,\n author: options.author,\n committer: options.committer,\n content: shouldEncode ? Base64.encode(content) : content,\n };\n\n return this.getSha(branch, filePath)\n .then((response) => {\n commit.sha = response.data.sha;\n return this._request('PUT', `/repos/${this.__fullname}/contents/${filePath}`, commit, cb);\n }, () => {\n return this._request('PUT', `/repos/${this.__fullname}/contents/${filePath}`, commit, cb);\n });\n }\n\n /**\n * Check if a repository is starred by you\n * @see https://developer.github.com/v3/activity/starring/#check-if-you-are-starring-a-repository\n * @param {Requestable.callback} cb - will receive true if the repository is starred and false if the repository\n * is not starred\n * @return {Promise} - the promise for the http request {Boolean} [description]\n */\n isStarred(cb) {\n return this._request204or404(`/user/starred/${this.__fullname}`, null, cb);\n }\n\n /**\n * Star a repository\n * @see https://developer.github.com/v3/activity/starring/#star-a-repository\n * @param {Requestable.callback} cb - will receive true if the repository is starred\n * @return {Promise} - the promise for the http request\n */\n star(cb) {\n return this._request('PUT', `/user/starred/${this.__fullname}`, null, cb);\n }\n\n /**\n * Unstar a repository\n * @see https://developer.github.com/v3/activity/starring/#unstar-a-repository\n * @param {Requestable.callback} cb - will receive true if the repository is unstarred\n * @return {Promise} - the promise for the http request\n */\n unstar(cb) {\n return this._request('DELETE', `/user/starred/${this.__fullname}`, null, cb);\n }\n\n /**\n * Create a new release\n * @see https://developer.github.com/v3/repos/releases/#create-a-release\n * @param {Object} options - the description of the release\n * @param {Requestable.callback} cb - will receive the newly created release\n * @return {Promise} - the promise for the http request\n */\n createRelease(options, cb) {\n return this._request('POST', `/repos/${this.__fullname}/releases`, options, cb);\n }\n\n /**\n * Edit a release\n * @see https://developer.github.com/v3/repos/releases/#edit-a-release\n * @param {string} id - the id of the release\n * @param {Object} options - the description of the release\n * @param {Requestable.callback} cb - will receive the modified release\n * @return {Promise} - the promise for the http request\n */\n updateRelease(id, options, cb) {\n return this._request('PATCH', `/repos/${this.__fullname}/releases/${id}`, options, cb);\n }\n\n /**\n * Get information about all releases\n * @see https://developer.github.com/v3/repos/releases/#list-releases-for-a-repository\n * @param {Requestable.callback} cb - will receive the release information\n * @return {Promise} - the promise for the http request\n */\n listReleases(cb) {\n return this._request('GET', `/repos/${this.__fullname}/releases`, null, cb);\n }\n\n /**\n * Get information about a release\n * @see https://developer.github.com/v3/repos/releases/#get-a-single-release\n * @param {string} id - the id of the release\n * @param {Requestable.callback} cb - will receive the release information\n * @return {Promise} - the promise for the http request\n */\n getRelease(id, cb) {\n return this._request('GET', `/repos/${this.__fullname}/releases/${id}`, null, cb);\n }\n\n /**\n * Delete a release\n * @see https://developer.github.com/v3/repos/releases/#delete-a-release\n * @param {string} id - the release to be deleted\n * @param {Requestable.callback} cb - will receive true if the operation is successful\n * @return {Promise} - the promise for the http request\n */\n deleteRelease(id, cb) {\n return this._request('DELETE', `/repos/${this.__fullname}/releases/${id}`, null, cb);\n }\n\n /**\n * Merge a pull request\n * @see https://developer.github.com/v3/pulls/#merge-a-pull-request-merge-button\n * @param {number|string} number - the number of the pull request to merge\n * @param {Object} options - the merge options for the pull request\n * @param {Requestable.callback} [cb] - will receive the merge information if the operation is successful\n * @return {Promise} - the promise for the http request\n */\n mergePullRequest(number, options, cb) {\n return this._request('PUT', `/repos/${this.__fullname}/pulls/${number}/merge`, options, cb);\n }\n\n /**\n * Get information about all projects\n * @see https://developer.github.com/v3/projects/#list-repository-projects\n * @param {Requestable.callback} [cb] - will receive the list of projects\n * @return {Promise} - the promise for the http request\n */\n listProjects(cb) {\n return this._requestAllPages(`/repos/${this.__fullname}/projects`, {AcceptHeader: 'inertia-preview'}, cb);\n }\n\n /**\n * Create a new project\n * @see https://developer.github.com/v3/projects/#create-a-repository-project\n * @param {Object} options - the description of the project\n * @param {Requestable.callback} cb - will receive the newly created project\n * @return {Promise} - the promise for the http request\n */\n createProject(options, cb) {\n options = options || {};\n options.AcceptHeader = 'inertia-preview';\n return this._request('POST', `/repos/${this.__fullname}/projects`, options, cb);\n }\n\n}\n\nmodule.exports = Repository;\n","/**\n * @file\n * @copyright 2016 Yahoo Inc.\n * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n * Github.js is freely distributable.\n */\n\nimport axios from 'axios';\nimport debug from 'debug';\nimport {Base64} from 'js-base64';\n\nconst log = debug('github:request');\n\n/**\n * The error structure returned when a network call fails\n */\nclass ResponseError extends Error {\n /**\n * Construct a new ResponseError\n * @param {string} message - an message to return instead of the the default error message\n * @param {string} path - the requested path\n * @param {Object} response - the object returned by Axios\n */\n constructor(message, path, response) {\n super(message);\n this.path = path;\n this.request = response.config;\n this.response = (response || {}).response || response;\n this.status = response.status;\n }\n}\n\n/**\n * Requestable wraps the logic for making http requests to the API\n */\nclass Requestable {\n /**\n * Either a username and password or an oauth token for Github\n * @typedef {Object} Requestable.auth\n * @prop {string} [username] - the Github username\n * @prop {string} [password] - the user's password\n * @prop {token} [token] - an OAuth token\n */\n /**\n * Initialize the http internals.\n * @param {Requestable.auth} [auth] - the credentials to authenticate to Github. If auth is\n * not provided request will be made unauthenticated\n * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n * @param {string} [AcceptHeader=v3] - the accept header for the requests\n */\n constructor(auth, apiBase, AcceptHeader) {\n this.__apiBase = apiBase || 'https://api.github.com';\n this.__auth = {\n token: auth.token,\n username: auth.username,\n password: auth.password,\n };\n this.__AcceptHeader = AcceptHeader || 'v3';\n\n if (auth.token) {\n this.__authorizationHeader = 'token ' + auth.token;\n } else if (auth.username && auth.password) {\n this.__authorizationHeader = 'Basic ' + Base64.encode(auth.username + ':' + auth.password);\n }\n }\n\n /**\n * Compute the URL to use to make a request.\n * @private\n * @param {string} path - either a URL relative to the API base or an absolute URL\n * @return {string} - the URL to use\n */\n __getURL(path) {\n let url = path;\n\n if (path.indexOf('//') === -1) {\n url = this.__apiBase + path;\n }\n\n let newCacheBuster = 'timestamp=' + new Date().getTime();\n return url.replace(/(timestamp=\\d+)/, newCacheBuster);\n }\n\n /**\n * Compute the headers required for an API request.\n * @private\n * @param {boolean} raw - if the request should be treated as JSON or as a raw request\n * @param {string} AcceptHeader - the accept header for the request\n * @return {Object} - the headers to use in the request\n */\n __getRequestHeaders(raw, AcceptHeader) {\n let headers = {\n 'Content-Type': 'application/json;charset=UTF-8',\n 'Accept': 'application/vnd.github.' + (AcceptHeader || this.__AcceptHeader),\n };\n\n if (raw) {\n headers.Accept += '.raw';\n }\n headers.Accept += '+json';\n\n if (this.__authorizationHeader) {\n headers.Authorization = this.__authorizationHeader;\n }\n\n return headers;\n }\n\n /**\n * Sets the default options for API requests\n * @protected\n * @param {Object} [requestOptions={}] - the current options for the request\n * @return {Object} - the options to pass to the request\n */\n _getOptionsWithDefaults(requestOptions = {}) {\n if (!(requestOptions.visibility || requestOptions.affiliation)) {\n requestOptions.type = requestOptions.type || 'all';\n }\n requestOptions.sort = requestOptions.sort || 'updated';\n requestOptions.per_page = requestOptions.per_page || '100'; // eslint-disable-line\n\n return requestOptions;\n }\n\n /**\n * if a `Date` is passed to this function it will be converted to an ISO string\n * @param {*} date - the object to attempt to cooerce into an ISO date string\n * @return {string} - the ISO representation of `date` or whatever was passed in if it was not a date\n */\n _dateToISO(date) {\n if (date && (date instanceof Date)) {\n date = date.toISOString();\n }\n\n return date;\n }\n\n /**\n * A function that receives the result of the API request.\n * @callback Requestable.callback\n * @param {Requestable.Error} error - the error returned by the API or `null`\n * @param {(Object|true)} result - the data returned by the API or `true` if the API returns `204 No Content`\n * @param {Object} request - the raw {@linkcode https://github.com/mzabriskie/axios#response-schema Response}\n */\n /**\n * Make a request.\n * @param {string} method - the method for the request (GET, PUT, POST, DELETE)\n * @param {string} path - the path for the request\n * @param {*} [data] - the data to send to the server. For HTTP methods that don't have a body the data\n * will be sent as query parameters\n * @param {Requestable.callback} [cb] - the callback for the request\n * @param {boolean} [raw=false] - if the request should be sent as raw. If this is a falsy value then the\n * request will be made as JSON\n * @return {Promise} - the Promise for the http request\n */\n _request(method, path, data, cb, raw) {\n const url = this.__getURL(path);\n\n const AcceptHeader = (data || {}).AcceptHeader;\n if (AcceptHeader) {\n delete data.AcceptHeader;\n }\n const headers = this.__getRequestHeaders(raw, AcceptHeader);\n\n let queryParams = {};\n\n const shouldUseDataAsParams = data && (typeof data === 'object') && methodHasNoBody(method);\n if (shouldUseDataAsParams) {\n queryParams = data;\n data = undefined;\n }\n\n const config = {\n url: url,\n method: method,\n headers: headers,\n params: queryParams,\n data: data,\n responseType: raw ? 'text' : 'json',\n };\n\n log(`${config.method} to ${config.url}`);\n const requestPromise = axios(config).catch(callbackErrorOrThrow(cb, path));\n\n if (cb) {\n requestPromise.then((response) => {\n if (response.data && Object.keys(response.data).length > 0) {\n // When data has results\n cb(null, response.data, response);\n } else if (config.method !== 'GET' && Object.keys(response.data).length < 1) {\n // True when successful submit a request and receive a empty object\n cb(null, (response.status < 300), response);\n } else {\n cb(null, response.data, response);\n }\n });\n }\n\n return requestPromise;\n }\n\n /**\n * Make a request to an endpoint the returns 204 when true and 404 when false\n * @param {string} path - the path to request\n * @param {Object} data - any query parameters for the request\n * @param {Requestable.callback} cb - the callback that will receive `true` or `false`\n * @param {method} [method=GET] - HTTP Method to use\n * @return {Promise} - the promise for the http request\n */\n _request204or404(path, data, cb, method = 'GET') {\n return this._request(method, path, data)\n .then(function success(response) {\n if (cb) {\n cb(null, true, response);\n }\n return true;\n }, function failure(response) {\n if (response.response.status === 404) {\n if (cb) {\n cb(null, false, response);\n }\n return false;\n }\n\n if (cb) {\n cb(response);\n }\n throw response;\n });\n }\n\n /**\n * Make a request and fetch all the available data. Github will paginate responses so for queries\n * that might span multiple pages this method is preferred to {@link Requestable#request}\n * @param {string} path - the path to request\n * @param {Object} options - the query parameters to include\n * @param {Requestable.callback} [cb] - the function to receive the data. The returned data will always be an array.\n * @param {Object[]} results - the partial results. This argument is intended for interal use only.\n * @return {Promise} - a promise which will resolve when all pages have been fetched\n * @deprecated This will be folded into {@link Requestable#_request} in the 2.0 release.\n */\n _requestAllPages(path, options, cb, results) {\n results = results || [];\n\n return this._request('GET', path, options)\n .then((response) => {\n let thisGroup;\n if (response.data instanceof Array) {\n thisGroup = response.data;\n } else if (response.data.items instanceof Array) {\n thisGroup = response.data.items;\n } else {\n let message = `cannot figure out how to append ${response.data} to the result set`;\n throw new ResponseError(message, path, response);\n }\n results.push(...thisGroup);\n\n const nextUrl = getNextPage(response.headers.link);\n if (nextUrl && typeof options.page !== 'number') {\n log(`getting next page: ${nextUrl}`);\n return this._requestAllPages(nextUrl, options, cb, results);\n }\n\n if (cb) {\n cb(null, results, response);\n }\n\n response.data = results;\n return response;\n }).catch(callbackErrorOrThrow(cb, path));\n }\n}\n\nmodule.exports = Requestable;\n\n// ////////////////////////// //\n// Private helper functions //\n// ////////////////////////// //\nconst METHODS_WITH_NO_BODY = ['GET', 'HEAD', 'DELETE'];\nfunction methodHasNoBody(method) {\n return METHODS_WITH_NO_BODY.indexOf(method) !== -1;\n}\n\nfunction getNextPage(linksHeader = '') {\n const links = linksHeader.split(/\\s*,\\s*/); // splits and strips the urls\n return links.reduce(function(nextUrl, link) {\n if (link.search(/rel=\"next\"/) !== -1) {\n return (link.match(/<(.*)>/) || [])[1];\n }\n\n return nextUrl;\n }, undefined);\n}\n\nfunction callbackErrorOrThrow(cb, path) {\n return function handler(object) {\n let error;\n if (object.hasOwnProperty('config')) {\n const {response: {status, statusText}, config: {method, url}} = object;\n let message = (`${status} error making request ${method} ${url}: \"${statusText}\"`);\n error = new ResponseError(message, path, object);\n log(`${message} ${JSON.stringify(object.data)}`);\n } else {\n error = object;\n }\n if (cb) {\n log('going to error callback');\n cb(error);\n } else {\n log('throwing error');\n throw error;\n }\n };\n}\n","/**\n * @file\n * @copyright 2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n * Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\nimport debug from 'debug';\nconst log = debug('github:search');\n\n/**\n * Wrap the Search API\n */\nclass Search extends Requestable {\n /**\n * Create a Search\n * @param {Object} defaults - defaults for the search\n * @param {Requestable.auth} [auth] - information required to authenticate to Github\n * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n */\n constructor(defaults, auth, apiBase) {\n super(auth, apiBase);\n this.__defaults = this._getOptionsWithDefaults(defaults);\n }\n\n /**\n * Available search options\n * @see https://developer.github.com/v3/search/#parameters\n * @typedef {Object} Search.Params\n * @param {string} q - the query to make\n * @param {string} sort - the sort field, one of `stars`, `forks`, or `updated`.\n * Default is [best match](https://developer.github.com/v3/search/#ranking-search-results)\n * @param {string} order - the ordering, either `asc` or `desc`\n */\n /**\n * Perform a search on the GitHub API\n * @private\n * @param {string} path - the scope of the search\n * @param {Search.Params} [withOptions] - additional parameters for the search\n * @param {Requestable.callback} [cb] - will receive the results of the search\n * @return {Promise} - the promise for the http request\n */\n _search(path, withOptions = {}, cb = undefined) {\n let requestOptions = {};\n Object.keys(this.__defaults).forEach((prop) => {\n requestOptions[prop] = this.__defaults[prop];\n });\n Object.keys(withOptions).forEach((prop) => {\n requestOptions[prop] = withOptions[prop];\n });\n\n log(`searching ${path} with options:`, requestOptions);\n return this._requestAllPages(`/search/${path}`, requestOptions, cb);\n }\n\n /**\n * Search for repositories\n * @see https://developer.github.com/v3/search/#search-repositories\n * @param {Search.Params} [options] - additional parameters for the search\n * @param {Requestable.callback} [cb] - will receive the results of the search\n * @return {Promise} - the promise for the http request\n */\n forRepositories(options, cb) {\n return this._search('repositories', options, cb);\n }\n\n /**\n * Search for code\n * @see https://developer.github.com/v3/search/#search-code\n * @param {Search.Params} [options] - additional parameters for the search\n * @param {Requestable.callback} [cb] - will receive the results of the search\n * @return {Promise} - the promise for the http request\n */\n forCode(options, cb) {\n return this._search('code', options, cb);\n }\n\n /**\n * Search for issues\n * @see https://developer.github.com/v3/search/#search-issues\n * @param {Search.Params} [options] - additional parameters for the search\n * @param {Requestable.callback} [cb] - will receive the results of the search\n * @return {Promise} - the promise for the http request\n */\n forIssues(options, cb) {\n return this._search('issues', options, cb);\n }\n\n /**\n * Search for users\n * @see https://developer.github.com/v3/search/#search-users\n * @param {Search.Params} [options] - additional parameters for the search\n * @param {Requestable.callback} [cb] - will receive the results of the search\n * @return {Promise} - the promise for the http request\n */\n forUsers(options, cb) {\n return this._search('users', options, cb);\n }\n}\n\nmodule.exports = Search;\n","/**\n * @file\n * @copyright 2016 Matt Smith (Development Seed)\n * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n * Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\nimport debug from 'debug';\nconst log = debug('github:team');\n\n/**\n * A Team allows scoping of API requests to a particular Github Organization Team.\n */\nclass Team extends Requestable {\n /**\n * Create a Team.\n * @param {string} [teamId] - the id for the team\n * @param {Requestable.auth} [auth] - information required to authenticate to Github\n * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n */\n constructor(teamId, auth, apiBase) {\n super(auth, apiBase);\n this.__teamId = teamId;\n }\n\n /**\n * Get Team information\n * @see https://developer.github.com/v3/orgs/teams/#get-team\n * @param {Requestable.callback} [cb] - will receive the team\n * @return {Promise} - the promise for the http request\n */\n getTeam(cb) {\n log(`Fetching Team ${this.__teamId}`);\n return this._request('Get', `/teams/${this.__teamId}`, undefined, cb);\n }\n\n /**\n * List the Team's repositories\n * @see https://developer.github.com/v3/orgs/teams/#list-team-repos\n * @param {Requestable.callback} [cb] - will receive the list of repositories\n * @return {Promise} - the promise for the http request\n */\n listRepos(cb) {\n log(`Fetching repositories for Team ${this.__teamId}`);\n return this._requestAllPages(`/teams/${this.__teamId}/repos`, undefined, cb);\n }\n\n /**\n * Edit Team information\n * @see https://developer.github.com/v3/orgs/teams/#edit-team\n * @param {object} options - Parameters for team edit\n * @param {string} options.name - The name of the team\n * @param {string} [options.description] - Team description\n * @param {string} [options.repo_names] - Repos to add the team to\n * @param {string} [options.privacy=secret] - The level of privacy the team should have. Can be either one\n * of: `secret`, or `closed`\n * @param {Requestable.callback} [cb] - will receive the updated team\n * @return {Promise} - the promise for the http request\n */\n editTeam(options, cb) {\n log(`Editing Team ${this.__teamId}`);\n return this._request('PATCH', `/teams/${this.__teamId}`, options, cb);\n }\n\n /**\n * List the users who are members of the Team\n * @see https://developer.github.com/v3/orgs/teams/#list-team-members\n * @param {object} options - Parameters for listing team users\n * @param {string} [options.role=all] - can be one of: `all`, `maintainer`, or `member`\n * @param {Requestable.callback} [cb] - will receive the list of users\n * @return {Promise} - the promise for the http request\n */\n listMembers(options, cb) {\n log(`Getting members of Team ${this.__teamId}`);\n return this._requestAllPages(`/teams/${this.__teamId}/members`, options, cb);\n }\n\n /**\n * Get Team membership status for a user\n * @see https://developer.github.com/v3/orgs/teams/#get-team-membership\n * @param {string} username - can be one of: `all`, `maintainer`, or `member`\n * @param {Requestable.callback} [cb] - will receive the membership status of a user\n * @return {Promise} - the promise for the http request\n */\n getMembership(username, cb) {\n log(`Getting membership of user ${username} in Team ${this.__teamId}`);\n return this._request('GET', `/teams/${this.__teamId}/memberships/${username}`, undefined, cb);\n }\n\n /**\n * Add a member to the Team\n * @see https://developer.github.com/v3/orgs/teams/#add-team-membership\n * @param {string} username - can be one of: `all`, `maintainer`, or `member`\n * @param {object} options - Parameters for adding a team member\n * @param {string} [options.role=member] - The role that this user should have in the team. Can be one\n * of: `member`, or `maintainer`\n * @param {Requestable.callback} [cb] - will receive the membership status of added user\n * @return {Promise} - the promise for the http request\n */\n addMembership(username, options, cb) {\n log(`Adding user ${username} to Team ${this.__teamId}`);\n return this._request('PUT', `/teams/${this.__teamId}/memberships/${username}`, options, cb);\n }\n\n /**\n * Get repo management status for team\n * @see https://developer.github.com/v3/orgs/teams/#remove-team-membership\n * @param {string} owner - Organization name\n * @param {string} repo - Repo name\n * @param {Requestable.callback} [cb] - will receive the membership status of added user\n * @return {Promise} - the promise for the http request\n */\n isManagedRepo(owner, repo, cb) {\n log(`Getting repo management by Team ${this.__teamId} for repo ${owner}/${repo}`);\n return this._request204or404(`/teams/${this.__teamId}/repos/${owner}/${repo}`, undefined, cb);\n }\n\n /**\n * Add or Update repo management status for team\n * @see https://developer.github.com/v3/orgs/teams/#add-or-update-team-repository\n * @param {string} owner - Organization name\n * @param {string} repo - Repo name\n * @param {object} options - Parameters for adding or updating repo management for the team\n * @param {string} [options.permission] - The permission to grant the team on this repository. Can be one\n * of: `pull`, `push`, or `admin`\n * @param {Requestable.callback} [cb] - will receive the membership status of added user\n * @return {Promise} - the promise for the http request\n */\n manageRepo(owner, repo, options, cb) {\n log(`Adding or Updating repo management by Team ${this.__teamId} for repo ${owner}/${repo}`);\n return this._request204or404(`/teams/${this.__teamId}/repos/${owner}/${repo}`, options, cb, 'PUT');\n }\n\n /**\n * Remove repo management status for team\n * @see https://developer.github.com/v3/orgs/teams/#remove-team-repository\n * @param {string} owner - Organization name\n * @param {string} repo - Repo name\n * @param {Requestable.callback} [cb] - will receive the membership status of added user\n * @return {Promise} - the promise for the http request\n */\n unmanageRepo(owner, repo, cb) {\n log(`Remove repo management by Team ${this.__teamId} for repo ${owner}/${repo}`);\n return this._request204or404(`/teams/${this.__teamId}/repos/${owner}/${repo}`, undefined, cb, 'DELETE');\n }\n\n /**\n * Delete Team\n * @see https://developer.github.com/v3/orgs/teams/#delete-team\n * @param {Requestable.callback} [cb] - will receive the list of repositories\n * @return {Promise} - the promise for the http request\n */\n deleteTeam(cb) {\n log(`Deleting Team ${this.__teamId}`);\n return this._request204or404(`/teams/${this.__teamId}`, undefined, cb, 'DELETE');\n }\n}\n\nmodule.exports = Team;\n","/**\n * @file\n * @copyright 2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n * Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\nimport debug from 'debug';\nconst log = debug('github:user');\n\n/**\n * A User allows scoping of API requests to a particular Github user.\n */\nclass User extends Requestable {\n /**\n * Create a User.\n * @param {string} [username] - the user to use for user-scoped queries\n * @param {Requestable.auth} [auth] - information required to authenticate to Github\n * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n */\n constructor(username, auth, apiBase) {\n super(auth, apiBase);\n this.__user = username;\n }\n\n /**\n * Get the url for the request. (dependent on if we're requesting for the authenticated user or not)\n * @private\n * @param {string} endpoint - the endpoint being requested\n * @return {string} - the resolved endpoint\n */\n __getScopedUrl(endpoint) {\n if (this.__user) {\n return endpoint ?\n `/users/${this.__user}/${endpoint}` :\n `/users/${this.__user}`\n ;\n\n } else { // eslint-disable-line\n switch (endpoint) {\n case '':\n return '/user';\n\n case 'notifications':\n case 'gists':\n return `/${endpoint}`;\n\n default:\n return `/user/${endpoint}`;\n }\n }\n }\n\n /**\n * List the user's repositories\n * @see https://developer.github.com/v3/repos/#list-user-repositories\n * @param {Object} [options={}] - any options to refine the search\n * @param {Requestable.callback} [cb] - will receive the list of repositories\n * @return {Promise} - the promise for the http request\n */\n listRepos(options, cb) {\n if (typeof options === 'function') {\n cb = options;\n options = {};\n }\n\n options = this._getOptionsWithDefaults(options);\n\n log(`Fetching repositories with options: ${JSON.stringify(options)}`);\n return this._requestAllPages(this.__getScopedUrl('repos'), options, cb);\n }\n\n /**\n * List the orgs that the user belongs to\n * @see https://developer.github.com/v3/orgs/#list-user-organizations\n * @param {Requestable.callback} [cb] - will receive the list of organizations\n * @return {Promise} - the promise for the http request\n */\n listOrgs(cb) {\n return this._request('GET', this.__getScopedUrl('orgs'), null, cb);\n }\n\n /**\n * List the user's gists\n * @see https://developer.github.com/v3/gists/#list-a-users-gists\n * @param {Requestable.callback} [cb] - will receive the list of gists\n * @return {Promise} - the promise for the http request\n */\n listGists(cb) {\n return this._request('GET', this.__getScopedUrl('gists'), null, cb);\n }\n\n /**\n * List the user's starred gists\n * @see https://developer.github.com/v3/gists/#list-starred-gists\n * @param {Requestable.callback} [cb] - will receive the list of gists\n * @return {Promise} - the promise for the http request\n */\n listStarredGists(cb) {\n return this._request('GET', this.__getScopedUrl('gists/starred'), null, cb);\n }\n\n /**\n * List the user's notifications\n * @see https://developer.github.com/v3/activity/notifications/#list-your-notifications\n * @param {Object} [options={}] - any options to refine the search\n * @param {Requestable.callback} [cb] - will receive the list of repositories\n * @return {Promise} - the promise for the http request\n */\n listNotifications(options, cb) {\n options = options || {};\n if (typeof options === 'function') {\n cb = options;\n options = {};\n }\n\n options.since = this._dateToISO(options.since);\n options.before = this._dateToISO(options.before);\n\n return this._request('GET', this.__getScopedUrl('notifications'), options, cb);\n }\n\n /**\n * Show the user's profile\n * @see https://developer.github.com/v3/users/#get-a-single-user\n * @param {Requestable.callback} [cb] - will receive the user's information\n * @return {Promise} - the promise for the http request\n */\n getProfile(cb) {\n return this._request('GET', this.__getScopedUrl(''), null, cb);\n }\n\n /**\n * Gets the list of starred repositories for the user\n * @see https://developer.github.com/v3/activity/starring/#list-repositories-being-starred\n * @param {Requestable.callback} [cb] - will receive the list of starred repositories\n * @return {Promise} - the promise for the http request\n */\n listStarredRepos(cb) {\n let requestOptions = this._getOptionsWithDefaults();\n return this._requestAllPages(this.__getScopedUrl('starred'), requestOptions, cb);\n }\n\n /**\n * List email addresses for a user\n * @see https://developer.github.com/v3/users/emails/#list-email-addresses-for-a-user\n * @param {Requestable.callback} [cb] - will receive the list of emails\n * @return {Promise} - the promise for the http request\n */\n getEmails(cb) {\n return this._request('GET', '/user/emails', null, cb);\n }\n\n /**\n * Have the authenticated user follow this user\n * @see https://developer.github.com/v3/users/followers/#follow-a-user\n * @param {string} username - the user to follow\n * @param {Requestable.callback} [cb] - will receive true if the request succeeds\n * @return {Promise} - the promise for the http request\n */\n follow(username, cb) {\n return this._request('PUT', `/user/following/${this.__user}`, null, cb);\n }\n\n /**\n * Have the currently authenticated user unfollow this user\n * @see https://developer.github.com/v3/users/followers/#follow-a-user\n * @param {string} username - the user to unfollow\n * @param {Requestable.callback} [cb] - receives true if the request succeeds\n * @return {Promise} - the promise for the http request\n */\n unfollow(username, cb) {\n return this._request('DELETE', `/user/following/${this.__user}`, null, cb);\n }\n\n /**\n * Create a new repository for the currently authenticated user\n * @see https://developer.github.com/v3/repos/#create\n * @param {object} options - the repository definition\n * @param {Requestable.callback} [cb] - will receive the API response\n * @return {Promise} - the promise for the http request\n */\n createRepo(options, cb) {\n return this._request('POST', '/user/repos', options, cb);\n }\n}\n\nmodule.exports = User;\n","module.exports = require('./lib/axios');","'use strict';\n\nvar utils = require('./../utils');\nvar settle = require('./../core/settle');\nvar buildURL = require('./../helpers/buildURL');\nvar parseHeaders = require('./../helpers/parseHeaders');\nvar isURLSameOrigin = require('./../helpers/isURLSameOrigin');\nvar createError = require('../core/createError');\nvar btoa = (typeof window !== 'undefined' && window.btoa && window.btoa.bind(window)) || require('./../helpers/btoa');\n\nmodule.exports = function xhrAdapter(config) {\n return new Promise(function dispatchXhrRequest(resolve, reject) {\n var requestData = config.data;\n var requestHeaders = config.headers;\n\n if (utils.isFormData(requestData)) {\n delete requestHeaders['Content-Type']; // Let the browser set it\n }\n\n var request = new XMLHttpRequest();\n var loadEvent = 'onreadystatechange';\n var xDomain = false;\n\n // For IE 8/9 CORS support\n // Only supports POST and GET calls and doesn't returns the response headers.\n // DON'T do this for testing b/c XMLHttpRequest is mocked, not XDomainRequest.\n if (process.env.NODE_ENV !== 'test' &&\n typeof window !== 'undefined' &&\n window.XDomainRequest && !('withCredentials' in request) &&\n !isURLSameOrigin(config.url)) {\n request = new window.XDomainRequest();\n loadEvent = 'onload';\n xDomain = true;\n request.onprogress = function handleProgress() {};\n request.ontimeout = function handleTimeout() {};\n }\n\n // HTTP basic authentication\n if (config.auth) {\n var username = config.auth.username || '';\n var password = config.auth.password || '';\n requestHeaders.Authorization = 'Basic ' + btoa(username + ':' + password);\n }\n\n request.open(config.method.toUpperCase(), buildURL(config.url, config.params, config.paramsSerializer), true);\n\n // Set the request timeout in MS\n request.timeout = config.timeout;\n\n // Listen for ready state\n request[loadEvent] = function handleLoad() {\n if (!request || (request.readyState !== 4 && !xDomain)) {\n return;\n }\n\n // The request errored out and we didn't get a response, this will be\n // handled by onerror instead\n // With one exception: request that using file: protocol, most browsers\n // will return status as 0 even though it's a successful request\n if (request.status === 0 && !(request.responseURL && request.responseURL.indexOf('file:') === 0)) {\n return;\n }\n\n // Prepare the response\n var responseHeaders = 'getAllResponseHeaders' in request ? parseHeaders(request.getAllResponseHeaders()) : null;\n var responseData = !config.responseType || config.responseType === 'text' ? request.responseText : request.response;\n var response = {\n data: responseData,\n // IE sends 1223 instead of 204 (https://github.com/mzabriskie/axios/issues/201)\n status: request.status === 1223 ? 204 : request.status,\n statusText: request.status === 1223 ? 'No Content' : request.statusText,\n headers: responseHeaders,\n config: config,\n request: request\n };\n\n settle(resolve, reject, response);\n\n // Clean up request\n request = null;\n };\n\n // Handle low level network errors\n request.onerror = function handleError() {\n // Real errors are hidden from us by the browser\n // onerror should only fire if it's a network error\n reject(createError('Network Error', config));\n\n // Clean up request\n request = null;\n };\n\n // Handle timeout\n request.ontimeout = function handleTimeout() {\n reject(createError('timeout of ' + config.timeout + 'ms exceeded', config, 'ECONNABORTED'));\n\n // Clean up request\n request = null;\n };\n\n // Add xsrf header\n // This is only done if running in a standard browser environment.\n // Specifically not if we're in a web worker, or react-native.\n if (utils.isStandardBrowserEnv()) {\n var cookies = require('./../helpers/cookies');\n\n // Add xsrf header\n var xsrfValue = (config.withCredentials || isURLSameOrigin(config.url)) && config.xsrfCookieName ?\n cookies.read(config.xsrfCookieName) :\n undefined;\n\n if (xsrfValue) {\n requestHeaders[config.xsrfHeaderName] = xsrfValue;\n }\n }\n\n // Add headers to the request\n if ('setRequestHeader' in request) {\n utils.forEach(requestHeaders, function setRequestHeader(val, key) {\n if (typeof requestData === 'undefined' && key.toLowerCase() === 'content-type') {\n // Remove Content-Type if data is undefined\n delete requestHeaders[key];\n } else {\n // Otherwise add header to the request\n request.setRequestHeader(key, val);\n }\n });\n }\n\n // Add withCredentials to request if needed\n if (config.withCredentials) {\n request.withCredentials = true;\n }\n\n // Add responseType to request if needed\n if (config.responseType) {\n try {\n request.responseType = config.responseType;\n } catch (e) {\n if (request.responseType !== 'json') {\n throw e;\n }\n }\n }\n\n // Handle progress if needed\n if (typeof config.onDownloadProgress === 'function') {\n request.addEventListener('progress', config.onDownloadProgress);\n }\n\n // Not all browsers support upload events\n if (typeof config.onUploadProgress === 'function' && request.upload) {\n request.upload.addEventListener('progress', config.onUploadProgress);\n }\n\n if (config.cancelToken) {\n // Handle cancellation\n config.cancelToken.promise.then(function onCanceled(cancel) {\n if (!request) {\n return;\n }\n\n request.abort();\n reject(cancel);\n // Clean up request\n request = null;\n });\n }\n\n if (requestData === undefined) {\n requestData = null;\n }\n\n // Send the request\n request.send(requestData);\n });\n};\n","'use strict';\n\nvar utils = require('./utils');\nvar bind = require('./helpers/bind');\nvar Axios = require('./core/Axios');\nvar defaults = require('./defaults');\n\n/**\n * Create an instance of Axios\n *\n * @param {Object} defaultConfig The default config for the instance\n * @return {Axios} A new instance of Axios\n */\nfunction createInstance(defaultConfig) {\n var context = new Axios(defaultConfig);\n var instance = bind(Axios.prototype.request, context);\n\n // Copy axios.prototype to instance\n utils.extend(instance, Axios.prototype, context);\n\n // Copy context to instance\n utils.extend(instance, context);\n\n return instance;\n}\n\n// Create the default instance to be exported\nvar axios = createInstance(defaults);\n\n// Expose Axios class to allow class inheritance\naxios.Axios = Axios;\n\n// Factory for creating new instances\naxios.create = function create(instanceConfig) {\n return createInstance(utils.merge(defaults, instanceConfig));\n};\n\n// Expose Cancel & CancelToken\naxios.Cancel = require('./cancel/Cancel');\naxios.CancelToken = require('./cancel/CancelToken');\naxios.isCancel = require('./cancel/isCancel');\n\n// Expose all/spread\naxios.all = function all(promises) {\n return Promise.all(promises);\n};\naxios.spread = require('./helpers/spread');\n\nmodule.exports = axios;\n\n// Allow use of default import syntax in TypeScript\nmodule.exports.default = axios;\n","'use strict';\n\n/**\n * A `Cancel` is an object that is thrown when an operation is canceled.\n *\n * @class\n * @param {string=} message The message.\n */\nfunction Cancel(message) {\n this.message = message;\n}\n\nCancel.prototype.toString = function toString() {\n return 'Cancel' + (this.message ? ': ' + this.message : '');\n};\n\nCancel.prototype.__CANCEL__ = true;\n\nmodule.exports = Cancel;\n","'use strict';\n\nvar Cancel = require('./Cancel');\n\n/**\n * A `CancelToken` is an object that can be used to request cancellation of an operation.\n *\n * @class\n * @param {Function} executor The executor function.\n */\nfunction CancelToken(executor) {\n if (typeof executor !== 'function') {\n throw new TypeError('executor must be a function.');\n }\n\n var resolvePromise;\n this.promise = new Promise(function promiseExecutor(resolve) {\n resolvePromise = resolve;\n });\n\n var token = this;\n executor(function cancel(message) {\n if (token.reason) {\n // Cancellation has already been requested\n return;\n }\n\n token.reason = new Cancel(message);\n resolvePromise(token.reason);\n });\n}\n\n/**\n * Throws a `Cancel` if cancellation has been requested.\n */\nCancelToken.prototype.throwIfRequested = function throwIfRequested() {\n if (this.reason) {\n throw this.reason;\n }\n};\n\n/**\n * Returns an object that contains a new `CancelToken` and a function that, when called,\n * cancels the `CancelToken`.\n */\nCancelToken.source = function source() {\n var cancel;\n var token = new CancelToken(function executor(c) {\n cancel = c;\n });\n return {\n token: token,\n cancel: cancel\n };\n};\n\nmodule.exports = CancelToken;\n","'use strict';\n\nmodule.exports = function isCancel(value) {\n return !!(value && value.__CANCEL__);\n};\n","'use strict';\n\nvar defaults = require('./../defaults');\nvar utils = require('./../utils');\nvar InterceptorManager = require('./InterceptorManager');\nvar dispatchRequest = require('./dispatchRequest');\nvar isAbsoluteURL = require('./../helpers/isAbsoluteURL');\nvar combineURLs = require('./../helpers/combineURLs');\n\n/**\n * Create a new instance of Axios\n *\n * @param {Object} instanceConfig The default config for the instance\n */\nfunction Axios(instanceConfig) {\n this.defaults = instanceConfig;\n this.interceptors = {\n request: new InterceptorManager(),\n response: new InterceptorManager()\n };\n}\n\n/**\n * Dispatch a request\n *\n * @param {Object} config The config specific for this request (merged with this.defaults)\n */\nAxios.prototype.request = function request(config) {\n /*eslint no-param-reassign:0*/\n // Allow for axios('example/url'[, config]) a la fetch API\n if (typeof config === 'string') {\n config = utils.merge({\n url: arguments[0]\n }, arguments[1]);\n }\n\n config = utils.merge(defaults, this.defaults, { method: 'get' }, config);\n\n // Support baseURL config\n if (config.baseURL && !isAbsoluteURL(config.url)) {\n config.url = combineURLs(config.baseURL, config.url);\n }\n\n // Hook up interceptors middleware\n var chain = [dispatchRequest, undefined];\n var promise = Promise.resolve(config);\n\n this.interceptors.request.forEach(function unshiftRequestInterceptors(interceptor) {\n chain.unshift(interceptor.fulfilled, interceptor.rejected);\n });\n\n this.interceptors.response.forEach(function pushResponseInterceptors(interceptor) {\n chain.push(interceptor.fulfilled, interceptor.rejected);\n });\n\n while (chain.length) {\n promise = promise.then(chain.shift(), chain.shift());\n }\n\n return promise;\n};\n\n// Provide aliases for supported request methods\nutils.forEach(['delete', 'get', 'head'], function forEachMethodNoData(method) {\n /*eslint func-names:0*/\n Axios.prototype[method] = function(url, config) {\n return this.request(utils.merge(config || {}, {\n method: method,\n url: url\n }));\n };\n});\n\nutils.forEach(['post', 'put', 'patch'], function forEachMethodWithData(method) {\n /*eslint func-names:0*/\n Axios.prototype[method] = function(url, data, config) {\n return this.request(utils.merge(config || {}, {\n method: method,\n url: url,\n data: data\n }));\n };\n});\n\nmodule.exports = Axios;\n","'use strict';\n\nvar utils = require('./../utils');\n\nfunction InterceptorManager() {\n this.handlers = [];\n}\n\n/**\n * Add a new interceptor to the stack\n *\n * @param {Function} fulfilled The function to handle `then` for a `Promise`\n * @param {Function} rejected The function to handle `reject` for a `Promise`\n *\n * @return {Number} An ID used to remove interceptor later\n */\nInterceptorManager.prototype.use = function use(fulfilled, rejected) {\n this.handlers.push({\n fulfilled: fulfilled,\n rejected: rejected\n });\n return this.handlers.length - 1;\n};\n\n/**\n * Remove an interceptor from the stack\n *\n * @param {Number} id The ID that was returned by `use`\n */\nInterceptorManager.prototype.eject = function eject(id) {\n if (this.handlers[id]) {\n this.handlers[id] = null;\n }\n};\n\n/**\n * Iterate over all the registered interceptors\n *\n * This method is particularly useful for skipping over any\n * interceptors that may have become `null` calling `eject`.\n *\n * @param {Function} fn The function to call for each interceptor\n */\nInterceptorManager.prototype.forEach = function forEach(fn) {\n utils.forEach(this.handlers, function forEachHandler(h) {\n if (h !== null) {\n fn(h);\n }\n });\n};\n\nmodule.exports = InterceptorManager;\n","'use strict';\n\nvar enhanceError = require('./enhanceError');\n\n/**\n * Create an Error with the specified message, config, error code, and response.\n *\n * @param {string} message The error message.\n * @param {Object} config The config.\n * @param {string} [code] The error code (for example, 'ECONNABORTED').\n @ @param {Object} [response] The response.\n * @returns {Error} The created error.\n */\nmodule.exports = function createError(message, config, code, response) {\n var error = new Error(message);\n return enhanceError(error, config, code, response);\n};\n","'use strict';\n\nvar utils = require('./../utils');\nvar transformData = require('./transformData');\nvar isCancel = require('../cancel/isCancel');\nvar defaults = require('../defaults');\n\n/**\n * Throws a `Cancel` if cancellation has been requested.\n */\nfunction throwIfCancellationRequested(config) {\n if (config.cancelToken) {\n config.cancelToken.throwIfRequested();\n }\n}\n\n/**\n * Dispatch a request to the server using the configured adapter.\n *\n * @param {object} config The config that is to be used for the request\n * @returns {Promise} The Promise to be fulfilled\n */\nmodule.exports = function dispatchRequest(config) {\n throwIfCancellationRequested(config);\n\n // Ensure headers exist\n config.headers = config.headers || {};\n\n // Transform request data\n config.data = transformData(\n config.data,\n config.headers,\n config.transformRequest\n );\n\n // Flatten headers\n config.headers = utils.merge(\n config.headers.common || {},\n config.headers[config.method] || {},\n config.headers || {}\n );\n\n utils.forEach(\n ['delete', 'get', 'head', 'post', 'put', 'patch', 'common'],\n function cleanHeaderConfig(method) {\n delete config.headers[method];\n }\n );\n\n var adapter = config.adapter || defaults.adapter;\n\n return adapter(config).then(function onAdapterResolution(response) {\n throwIfCancellationRequested(config);\n\n // Transform response data\n response.data = transformData(\n response.data,\n response.headers,\n config.transformResponse\n );\n\n return response;\n }, function onAdapterRejection(reason) {\n if (!isCancel(reason)) {\n throwIfCancellationRequested(config);\n\n // Transform response data\n if (reason && reason.response) {\n reason.response.data = transformData(\n reason.response.data,\n reason.response.headers,\n config.transformResponse\n );\n }\n }\n\n return Promise.reject(reason);\n });\n};\n","'use strict';\n\n/**\n * Update an Error with the specified config, error code, and response.\n *\n * @param {Error} error The error to update.\n * @param {Object} config The config.\n * @param {string} [code] The error code (for example, 'ECONNABORTED').\n @ @param {Object} [response] The response.\n * @returns {Error} The error.\n */\nmodule.exports = function enhanceError(error, config, code, response) {\n error.config = config;\n if (code) {\n error.code = code;\n }\n error.response = response;\n return error;\n};\n","'use strict';\n\nvar createError = require('./createError');\n\n/**\n * Resolve or reject a Promise based on response status.\n *\n * @param {Function} resolve A function that resolves the promise.\n * @param {Function} reject A function that rejects the promise.\n * @param {object} response The response.\n */\nmodule.exports = function settle(resolve, reject, response) {\n var validateStatus = response.config.validateStatus;\n // Note: status is not exposed by XDomainRequest\n if (!response.status || !validateStatus || validateStatus(response.status)) {\n resolve(response);\n } else {\n reject(createError(\n 'Request failed with status code ' + response.status,\n response.config,\n null,\n response\n ));\n }\n};\n","'use strict';\n\nvar utils = require('./../utils');\n\n/**\n * Transform the data for a request or a response\n *\n * @param {Object|String} data The data to be transformed\n * @param {Array} headers The headers for the request or response\n * @param {Array|Function} fns A single function or Array of functions\n * @returns {*} The resulting transformed data\n */\nmodule.exports = function transformData(data, headers, fns) {\n /*eslint no-param-reassign:0*/\n utils.forEach(fns, function transform(fn) {\n data = fn(data, headers);\n });\n\n return data;\n};\n","'use strict';\n\nvar utils = require('./utils');\nvar normalizeHeaderName = require('./helpers/normalizeHeaderName');\n\nvar PROTECTION_PREFIX = /^\\)\\]\\}',?\\n/;\nvar DEFAULT_CONTENT_TYPE = {\n 'Content-Type': 'application/x-www-form-urlencoded'\n};\n\nfunction setContentTypeIfUnset(headers, value) {\n if (!utils.isUndefined(headers) && utils.isUndefined(headers['Content-Type'])) {\n headers['Content-Type'] = value;\n }\n}\n\nfunction getDefaultAdapter() {\n var adapter;\n if (typeof XMLHttpRequest !== 'undefined') {\n // For browsers use XHR adapter\n adapter = require('./adapters/xhr');\n } else if (typeof process !== 'undefined') {\n // For node use HTTP adapter\n adapter = require('./adapters/http');\n }\n return adapter;\n}\n\nvar defaults = {\n adapter: getDefaultAdapter(),\n\n transformRequest: [function transformRequest(data, headers) {\n normalizeHeaderName(headers, 'Content-Type');\n if (utils.isFormData(data) ||\n utils.isArrayBuffer(data) ||\n utils.isStream(data) ||\n utils.isFile(data) ||\n utils.isBlob(data)\n ) {\n return data;\n }\n if (utils.isArrayBufferView(data)) {\n return data.buffer;\n }\n if (utils.isURLSearchParams(data)) {\n setContentTypeIfUnset(headers, 'application/x-www-form-urlencoded;charset=utf-8');\n return data.toString();\n }\n if (utils.isObject(data)) {\n setContentTypeIfUnset(headers, 'application/json;charset=utf-8');\n return JSON.stringify(data);\n }\n return data;\n }],\n\n transformResponse: [function transformResponse(data) {\n /*eslint no-param-reassign:0*/\n if (typeof data === 'string') {\n data = data.replace(PROTECTION_PREFIX, '');\n try {\n data = JSON.parse(data);\n } catch (e) { /* Ignore */ }\n }\n return data;\n }],\n\n timeout: 0,\n\n xsrfCookieName: 'XSRF-TOKEN',\n xsrfHeaderName: 'X-XSRF-TOKEN',\n\n maxContentLength: -1,\n\n validateStatus: function validateStatus(status) {\n return status >= 200 && status < 300;\n }\n};\n\ndefaults.headers = {\n common: {\n 'Accept': 'application/json, text/plain, */*'\n }\n};\n\nutils.forEach(['delete', 'get', 'head'], function forEachMehtodNoData(method) {\n defaults.headers[method] = {};\n});\n\nutils.forEach(['post', 'put', 'patch'], function forEachMethodWithData(method) {\n defaults.headers[method] = utils.merge(DEFAULT_CONTENT_TYPE);\n});\n\nmodule.exports = defaults;\n","'use strict';\n\nmodule.exports = function bind(fn, thisArg) {\n return function wrap() {\n var args = new Array(arguments.length);\n for (var i = 0; i < args.length; i++) {\n args[i] = arguments[i];\n }\n return fn.apply(thisArg, args);\n };\n};\n","'use strict';\n\n// btoa polyfill for IE<10 courtesy https://github.com/davidchambers/Base64.js\n\nvar chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=';\n\nfunction E() {\n this.message = 'String contains an invalid character';\n}\nE.prototype = new Error;\nE.prototype.code = 5;\nE.prototype.name = 'InvalidCharacterError';\n\nfunction btoa(input) {\n var str = String(input);\n var output = '';\n for (\n // initialize result and counter\n var block, charCode, idx = 0, map = chars;\n // if the next str index does not exist:\n // change the mapping table to \"=\"\n // check if d has no fractional digits\n str.charAt(idx | 0) || (map = '=', idx % 1);\n // \"8 - idx % 1 * 8\" generates the sequence 2, 4, 6, 8\n output += map.charAt(63 & block >> 8 - idx % 1 * 8)\n ) {\n charCode = str.charCodeAt(idx += 3 / 4);\n if (charCode > 0xFF) {\n throw new E();\n }\n block = block << 8 | charCode;\n }\n return output;\n}\n\nmodule.exports = btoa;\n","'use strict';\n\nvar utils = require('./../utils');\n\nfunction encode(val) {\n return encodeURIComponent(val).\n replace(/%40/gi, '@').\n replace(/%3A/gi, ':').\n replace(/%24/g, '$').\n replace(/%2C/gi, ',').\n replace(/%20/g, '+').\n replace(/%5B/gi, '[').\n replace(/%5D/gi, ']');\n}\n\n/**\n * Build a URL by appending params to the end\n *\n * @param {string} url The base of the url (e.g., http://www.google.com)\n * @param {object} [params] The params to be appended\n * @returns {string} The formatted url\n */\nmodule.exports = function buildURL(url, params, paramsSerializer) {\n /*eslint no-param-reassign:0*/\n if (!params) {\n return url;\n }\n\n var serializedParams;\n if (paramsSerializer) {\n serializedParams = paramsSerializer(params);\n } else if (utils.isURLSearchParams(params)) {\n serializedParams = params.toString();\n } else {\n var parts = [];\n\n utils.forEach(params, function serialize(val, key) {\n if (val === null || typeof val === 'undefined') {\n return;\n }\n\n if (utils.isArray(val)) {\n key = key + '[]';\n }\n\n if (!utils.isArray(val)) {\n val = [val];\n }\n\n utils.forEach(val, function parseValue(v) {\n if (utils.isDate(v)) {\n v = v.toISOString();\n } else if (utils.isObject(v)) {\n v = JSON.stringify(v);\n }\n parts.push(encode(key) + '=' + encode(v));\n });\n });\n\n serializedParams = parts.join('&');\n }\n\n if (serializedParams) {\n url += (url.indexOf('?') === -1 ? '?' : '&') + serializedParams;\n }\n\n return url;\n};\n","'use strict';\n\n/**\n * Creates a new URL by combining the specified URLs\n *\n * @param {string} baseURL The base URL\n * @param {string} relativeURL The relative URL\n * @returns {string} The combined URL\n */\nmodule.exports = function combineURLs(baseURL, relativeURL) {\n return baseURL.replace(/\\/+$/, '') + '/' + relativeURL.replace(/^\\/+/, '');\n};\n","'use strict';\n\nvar utils = require('./../utils');\n\nmodule.exports = (\n utils.isStandardBrowserEnv() ?\n\n // Standard browser envs support document.cookie\n (function standardBrowserEnv() {\n return {\n write: function write(name, value, expires, path, domain, secure) {\n var cookie = [];\n cookie.push(name + '=' + encodeURIComponent(value));\n\n if (utils.isNumber(expires)) {\n cookie.push('expires=' + new Date(expires).toGMTString());\n }\n\n if (utils.isString(path)) {\n cookie.push('path=' + path);\n }\n\n if (utils.isString(domain)) {\n cookie.push('domain=' + domain);\n }\n\n if (secure === true) {\n cookie.push('secure');\n }\n\n document.cookie = cookie.join('; ');\n },\n\n read: function read(name) {\n var match = document.cookie.match(new RegExp('(^|;\\\\s*)(' + name + ')=([^;]*)'));\n return (match ? decodeURIComponent(match[3]) : null);\n },\n\n remove: function remove(name) {\n this.write(name, '', Date.now() - 86400000);\n }\n };\n })() :\n\n // Non standard browser env (web workers, react-native) lack needed support.\n (function nonStandardBrowserEnv() {\n return {\n write: function write() {},\n read: function read() { return null; },\n remove: function remove() {}\n };\n })()\n);\n","'use strict';\n\n/**\n * Determines whether the specified URL is absolute\n *\n * @param {string} url The URL to test\n * @returns {boolean} True if the specified URL is absolute, otherwise false\n */\nmodule.exports = function isAbsoluteURL(url) {\n // A URL is considered absolute if it begins with \"://\" or \"//\" (protocol-relative URL).\n // RFC 3986 defines scheme name as a sequence of characters beginning with a letter and followed\n // by any combination of letters, digits, plus, period, or hyphen.\n return /^([a-z][a-z\\d\\+\\-\\.]*:)?\\/\\//i.test(url);\n};\n","'use strict';\n\nvar utils = require('./../utils');\n\nmodule.exports = (\n utils.isStandardBrowserEnv() ?\n\n // Standard browser envs have full support of the APIs needed to test\n // whether the request URL is of the same origin as current location.\n (function standardBrowserEnv() {\n var msie = /(msie|trident)/i.test(navigator.userAgent);\n var urlParsingNode = document.createElement('a');\n var originURL;\n\n /**\n * Parse a URL to discover it's components\n *\n * @param {String} url The URL to be parsed\n * @returns {Object}\n */\n function resolveURL(url) {\n var href = url;\n\n if (msie) {\n // IE needs attribute set twice to normalize properties\n urlParsingNode.setAttribute('href', href);\n href = urlParsingNode.href;\n }\n\n urlParsingNode.setAttribute('href', href);\n\n // urlParsingNode provides the UrlUtils interface - http://url.spec.whatwg.org/#urlutils\n return {\n href: urlParsingNode.href,\n protocol: urlParsingNode.protocol ? urlParsingNode.protocol.replace(/:$/, '') : '',\n host: urlParsingNode.host,\n search: urlParsingNode.search ? urlParsingNode.search.replace(/^\\?/, '') : '',\n hash: urlParsingNode.hash ? urlParsingNode.hash.replace(/^#/, '') : '',\n hostname: urlParsingNode.hostname,\n port: urlParsingNode.port,\n pathname: (urlParsingNode.pathname.charAt(0) === '/') ?\n urlParsingNode.pathname :\n '/' + urlParsingNode.pathname\n };\n }\n\n originURL = resolveURL(window.location.href);\n\n /**\n * Determine if a URL shares the same origin as the current location\n *\n * @param {String} requestURL The URL to test\n * @returns {boolean} True if URL shares the same origin, otherwise false\n */\n return function isURLSameOrigin(requestURL) {\n var parsed = (utils.isString(requestURL)) ? resolveURL(requestURL) : requestURL;\n return (parsed.protocol === originURL.protocol &&\n parsed.host === originURL.host);\n };\n })() :\n\n // Non standard browser envs (web workers, react-native) lack needed support.\n (function nonStandardBrowserEnv() {\n return function isURLSameOrigin() {\n return true;\n };\n })()\n);\n","'use strict';\n\nvar utils = require('../utils');\n\nmodule.exports = function normalizeHeaderName(headers, normalizedName) {\n utils.forEach(headers, function processHeader(value, name) {\n if (name !== normalizedName && name.toUpperCase() === normalizedName.toUpperCase()) {\n headers[normalizedName] = value;\n delete headers[name];\n }\n });\n};\n","'use strict';\n\nvar utils = require('./../utils');\n\n/**\n * Parse headers into an object\n *\n * ```\n * Date: Wed, 27 Aug 2014 08:58:49 GMT\n * Content-Type: application/json\n * Connection: keep-alive\n * Transfer-Encoding: chunked\n * ```\n *\n * @param {String} headers Headers needing to be parsed\n * @returns {Object} Headers parsed into an object\n */\nmodule.exports = function parseHeaders(headers) {\n var parsed = {};\n var key;\n var val;\n var i;\n\n if (!headers) { return parsed; }\n\n utils.forEach(headers.split('\\n'), function parser(line) {\n i = line.indexOf(':');\n key = utils.trim(line.substr(0, i)).toLowerCase();\n val = utils.trim(line.substr(i + 1));\n\n if (key) {\n parsed[key] = parsed[key] ? parsed[key] + ', ' + val : val;\n }\n });\n\n return parsed;\n};\n","'use strict';\n\n/**\n * Syntactic sugar for invoking a function and expanding an array for arguments.\n *\n * Common use case would be to use `Function.prototype.apply`.\n *\n * ```js\n * function f(x, y, z) {}\n * var args = [1, 2, 3];\n * f.apply(null, args);\n * ```\n *\n * With `spread` this example can be re-written.\n *\n * ```js\n * spread(function(x, y, z) {})([1, 2, 3]);\n * ```\n *\n * @param {Function} callback\n * @returns {Function}\n */\nmodule.exports = function spread(callback) {\n return function wrap(arr) {\n return callback.apply(null, arr);\n };\n};\n","'use strict';\n\nvar bind = require('./helpers/bind');\n\n/*global toString:true*/\n\n// utils is a library of generic helper functions non-specific to axios\n\nvar toString = Object.prototype.toString;\n\n/**\n * Determine if a value is an Array\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if value is an Array, otherwise false\n */\nfunction isArray(val) {\n return toString.call(val) === '[object Array]';\n}\n\n/**\n * Determine if a value is an ArrayBuffer\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if value is an ArrayBuffer, otherwise false\n */\nfunction isArrayBuffer(val) {\n return toString.call(val) === '[object ArrayBuffer]';\n}\n\n/**\n * Determine if a value is a FormData\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if value is an FormData, otherwise false\n */\nfunction isFormData(val) {\n return (typeof FormData !== 'undefined') && (val instanceof FormData);\n}\n\n/**\n * Determine if a value is a view on an ArrayBuffer\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if value is a view on an ArrayBuffer, otherwise false\n */\nfunction isArrayBufferView(val) {\n var result;\n if ((typeof ArrayBuffer !== 'undefined') && (ArrayBuffer.isView)) {\n result = ArrayBuffer.isView(val);\n } else {\n result = (val) && (val.buffer) && (val.buffer instanceof ArrayBuffer);\n }\n return result;\n}\n\n/**\n * Determine if a value is a String\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if value is a String, otherwise false\n */\nfunction isString(val) {\n return typeof val === 'string';\n}\n\n/**\n * Determine if a value is a Number\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if value is a Number, otherwise false\n */\nfunction isNumber(val) {\n return typeof val === 'number';\n}\n\n/**\n * Determine if a value is undefined\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if the value is undefined, otherwise false\n */\nfunction isUndefined(val) {\n return typeof val === 'undefined';\n}\n\n/**\n * Determine if a value is an Object\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if value is an Object, otherwise false\n */\nfunction isObject(val) {\n return val !== null && typeof val === 'object';\n}\n\n/**\n * Determine if a value is a Date\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if value is a Date, otherwise false\n */\nfunction isDate(val) {\n return toString.call(val) === '[object Date]';\n}\n\n/**\n * Determine if a value is a File\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if value is a File, otherwise false\n */\nfunction isFile(val) {\n return toString.call(val) === '[object File]';\n}\n\n/**\n * Determine if a value is a Blob\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if value is a Blob, otherwise false\n */\nfunction isBlob(val) {\n return toString.call(val) === '[object Blob]';\n}\n\n/**\n * Determine if a value is a Function\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if value is a Function, otherwise false\n */\nfunction isFunction(val) {\n return toString.call(val) === '[object Function]';\n}\n\n/**\n * Determine if a value is a Stream\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if value is a Stream, otherwise false\n */\nfunction isStream(val) {\n return isObject(val) && isFunction(val.pipe);\n}\n\n/**\n * Determine if a value is a URLSearchParams object\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if value is a URLSearchParams object, otherwise false\n */\nfunction isURLSearchParams(val) {\n return typeof URLSearchParams !== 'undefined' && val instanceof URLSearchParams;\n}\n\n/**\n * Trim excess whitespace off the beginning and end of a string\n *\n * @param {String} str The String to trim\n * @returns {String} The String freed of excess whitespace\n */\nfunction trim(str) {\n return str.replace(/^\\s*/, '').replace(/\\s*$/, '');\n}\n\n/**\n * Determine if we're running in a standard browser environment\n *\n * This allows axios to run in a web worker, and react-native.\n * Both environments support XMLHttpRequest, but not fully standard globals.\n *\n * web workers:\n * typeof window -> undefined\n * typeof document -> undefined\n *\n * react-native:\n * typeof document.createElement -> undefined\n */\nfunction isStandardBrowserEnv() {\n return (\n typeof window !== 'undefined' &&\n typeof document !== 'undefined' &&\n typeof document.createElement === 'function'\n );\n}\n\n/**\n * Iterate over an Array or an Object invoking a function for each item.\n *\n * If `obj` is an Array callback will be called passing\n * the value, index, and complete array for each item.\n *\n * If 'obj' is an Object callback will be called passing\n * the value, key, and complete object for each property.\n *\n * @param {Object|Array} obj The object to iterate\n * @param {Function} fn The callback to invoke for each item\n */\nfunction forEach(obj, fn) {\n // Don't bother if no value provided\n if (obj === null || typeof obj === 'undefined') {\n return;\n }\n\n // Force an array if not already something iterable\n if (typeof obj !== 'object' && !isArray(obj)) {\n /*eslint no-param-reassign:0*/\n obj = [obj];\n }\n\n if (isArray(obj)) {\n // Iterate over array values\n for (var i = 0, l = obj.length; i < l; i++) {\n fn.call(null, obj[i], i, obj);\n }\n } else {\n // Iterate over object keys\n for (var key in obj) {\n if (Object.prototype.hasOwnProperty.call(obj, key)) {\n fn.call(null, obj[key], key, obj);\n }\n }\n }\n}\n\n/**\n * Accepts varargs expecting each argument to be an object, then\n * immutably merges the properties of each object and returns result.\n *\n * When multiple objects contain the same key the later object in\n * the arguments list will take precedence.\n *\n * Example:\n *\n * ```js\n * var result = merge({foo: 123}, {foo: 456});\n * console.log(result.foo); // outputs 456\n * ```\n *\n * @param {Object} obj1 Object to merge\n * @returns {Object} Result of all merge properties\n */\nfunction merge(/* obj1, obj2, obj3, ... */) {\n var result = {};\n function assignValue(val, key) {\n if (typeof result[key] === 'object' && typeof val === 'object') {\n result[key] = merge(result[key], val);\n } else {\n result[key] = val;\n }\n }\n\n for (var i = 0, l = arguments.length; i < l; i++) {\n forEach(arguments[i], assignValue);\n }\n return result;\n}\n\n/**\n * Extends object a by mutably adding to it the properties of object b.\n *\n * @param {Object} a The object to be extended\n * @param {Object} b The object to copy properties from\n * @param {Object} thisArg The object to bind function to\n * @return {Object} The resulting value of object a\n */\nfunction extend(a, b, thisArg) {\n forEach(b, function assignValue(val, key) {\n if (thisArg && typeof val === 'function') {\n a[key] = bind(val, thisArg);\n } else {\n a[key] = val;\n }\n });\n return a;\n}\n\nmodule.exports = {\n isArray: isArray,\n isArrayBuffer: isArrayBuffer,\n isFormData: isFormData,\n isArrayBufferView: isArrayBufferView,\n isString: isString,\n isNumber: isNumber,\n isObject: isObject,\n isUndefined: isUndefined,\n isDate: isDate,\n isFile: isFile,\n isBlob: isBlob,\n isFunction: isFunction,\n isStream: isStream,\n isURLSearchParams: isURLSearchParams,\n isStandardBrowserEnv: isStandardBrowserEnv,\n forEach: forEach,\n merge: merge,\n extend: extend,\n trim: trim\n};\n","'use strict'\n\nexports.byteLength = byteLength\nexports.toByteArray = toByteArray\nexports.fromByteArray = fromByteArray\n\nvar lookup = []\nvar revLookup = []\nvar Arr = typeof Uint8Array !== 'undefined' ? Uint8Array : Array\n\nvar code = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'\nfor (var i = 0, len = code.length; i < len; ++i) {\n lookup[i] = code[i]\n revLookup[code.charCodeAt(i)] = i\n}\n\nrevLookup['-'.charCodeAt(0)] = 62\nrevLookup['_'.charCodeAt(0)] = 63\n\nfunction placeHoldersCount (b64) {\n var len = b64.length\n if (len % 4 > 0) {\n throw new Error('Invalid string. Length must be a multiple of 4')\n }\n\n // the number of equal signs (place holders)\n // if there are two placeholders, than the two characters before it\n // represent one byte\n // if there is only one, then the three characters before it represent 2 bytes\n // this is just a cheap hack to not do indexOf twice\n return b64[len - 2] === '=' ? 2 : b64[len - 1] === '=' ? 1 : 0\n}\n\nfunction byteLength (b64) {\n // base64 is 4/3 + up to two characters of the original data\n return b64.length * 3 / 4 - placeHoldersCount(b64)\n}\n\nfunction toByteArray (b64) {\n var i, j, l, tmp, placeHolders, arr\n var len = b64.length\n placeHolders = placeHoldersCount(b64)\n\n arr = new Arr(len * 3 / 4 - placeHolders)\n\n // if there are placeholders, only get up to the last complete 4 chars\n l = placeHolders > 0 ? len - 4 : len\n\n var L = 0\n\n for (i = 0, j = 0; i < l; i += 4, j += 3) {\n tmp = (revLookup[b64.charCodeAt(i)] << 18) | (revLookup[b64.charCodeAt(i + 1)] << 12) | (revLookup[b64.charCodeAt(i + 2)] << 6) | revLookup[b64.charCodeAt(i + 3)]\n arr[L++] = (tmp >> 16) & 0xFF\n arr[L++] = (tmp >> 8) & 0xFF\n arr[L++] = tmp & 0xFF\n }\n\n if (placeHolders === 2) {\n tmp = (revLookup[b64.charCodeAt(i)] << 2) | (revLookup[b64.charCodeAt(i + 1)] >> 4)\n arr[L++] = tmp & 0xFF\n } else if (placeHolders === 1) {\n tmp = (revLookup[b64.charCodeAt(i)] << 10) | (revLookup[b64.charCodeAt(i + 1)] << 4) | (revLookup[b64.charCodeAt(i + 2)] >> 2)\n arr[L++] = (tmp >> 8) & 0xFF\n arr[L++] = tmp & 0xFF\n }\n\n return arr\n}\n\nfunction tripletToBase64 (num) {\n return lookup[num >> 18 & 0x3F] + lookup[num >> 12 & 0x3F] + lookup[num >> 6 & 0x3F] + lookup[num & 0x3F]\n}\n\nfunction encodeChunk (uint8, start, end) {\n var tmp\n var output = []\n for (var i = start; i < end; i += 3) {\n tmp = (uint8[i] << 16) + (uint8[i + 1] << 8) + (uint8[i + 2])\n output.push(tripletToBase64(tmp))\n }\n return output.join('')\n}\n\nfunction fromByteArray (uint8) {\n var tmp\n var len = uint8.length\n var extraBytes = len % 3 // if we have 1 byte left, pad 2 bytes\n var output = ''\n var parts = []\n var maxChunkLength = 16383 // must be multiple of 3\n\n // go through the array every three bytes, we'll deal with trailing stuff later\n for (var i = 0, len2 = len - extraBytes; i < len2; i += maxChunkLength) {\n parts.push(encodeChunk(uint8, i, (i + maxChunkLength) > len2 ? len2 : (i + maxChunkLength)))\n }\n\n // pad the end with zeros, but make sure to not forget the extra bytes\n if (extraBytes === 1) {\n tmp = uint8[len - 1]\n output += lookup[tmp >> 2]\n output += lookup[(tmp << 4) & 0x3F]\n output += '=='\n } else if (extraBytes === 2) {\n tmp = (uint8[len - 2] << 8) + (uint8[len - 1])\n output += lookup[tmp >> 10]\n output += lookup[(tmp >> 4) & 0x3F]\n output += lookup[(tmp << 2) & 0x3F]\n output += '='\n }\n\n parts.push(output)\n\n return parts.join('')\n}\n","/*!\n * The buffer module from node.js, for the browser.\n *\n * @author Feross Aboukhadijeh \n * @license MIT\n */\n/* eslint-disable no-proto */\n\n'use strict'\n\nvar base64 = require('base64-js')\nvar ieee754 = require('ieee754')\nvar isArray = require('isarray')\n\nexports.Buffer = Buffer\nexports.SlowBuffer = SlowBuffer\nexports.INSPECT_MAX_BYTES = 50\n\n/**\n * If `Buffer.TYPED_ARRAY_SUPPORT`:\n * === true Use Uint8Array implementation (fastest)\n * === false Use Object implementation (most compatible, even IE6)\n *\n * Browsers that support typed arrays are IE 10+, Firefox 4+, Chrome 7+, Safari 5.1+,\n * Opera 11.6+, iOS 4.2+.\n *\n * Due to various browser bugs, sometimes the Object implementation will be used even\n * when the browser supports typed arrays.\n *\n * Note:\n *\n * - Firefox 4-29 lacks support for adding new properties to `Uint8Array` instances,\n * See: https://bugzilla.mozilla.org/show_bug.cgi?id=695438.\n *\n * - Chrome 9-10 is missing the `TypedArray.prototype.subarray` function.\n *\n * - IE10 has a broken `TypedArray.prototype.subarray` function which returns arrays of\n * incorrect length in some situations.\n\n * We detect these buggy browsers and set `Buffer.TYPED_ARRAY_SUPPORT` to `false` so they\n * get the Object implementation, which is slower but behaves correctly.\n */\nBuffer.TYPED_ARRAY_SUPPORT = global.TYPED_ARRAY_SUPPORT !== undefined\n ? global.TYPED_ARRAY_SUPPORT\n : typedArraySupport()\n\n/*\n * Export kMaxLength after typed array support is determined.\n */\nexports.kMaxLength = kMaxLength()\n\nfunction typedArraySupport () {\n try {\n var arr = new Uint8Array(1)\n arr.__proto__ = {__proto__: Uint8Array.prototype, foo: function () { return 42 }}\n return arr.foo() === 42 && // typed array instances can be augmented\n typeof arr.subarray === 'function' && // chrome 9-10 lack `subarray`\n arr.subarray(1, 1).byteLength === 0 // ie10 has broken `subarray`\n } catch (e) {\n return false\n }\n}\n\nfunction kMaxLength () {\n return Buffer.TYPED_ARRAY_SUPPORT\n ? 0x7fffffff\n : 0x3fffffff\n}\n\nfunction createBuffer (that, length) {\n if (kMaxLength() < length) {\n throw new RangeError('Invalid typed array length')\n }\n if (Buffer.TYPED_ARRAY_SUPPORT) {\n // Return an augmented `Uint8Array` instance, for best performance\n that = new Uint8Array(length)\n that.__proto__ = Buffer.prototype\n } else {\n // Fallback: Return an object instance of the Buffer class\n if (that === null) {\n that = new Buffer(length)\n }\n that.length = length\n }\n\n return that\n}\n\n/**\n * The Buffer constructor returns instances of `Uint8Array` that have their\n * prototype changed to `Buffer.prototype`. Furthermore, `Buffer` is a subclass of\n * `Uint8Array`, so the returned instances will have all the node `Buffer` methods\n * and the `Uint8Array` methods. Square bracket notation works as expected -- it\n * returns a single octet.\n *\n * The `Uint8Array` prototype remains unmodified.\n */\n\nfunction Buffer (arg, encodingOrOffset, length) {\n if (!Buffer.TYPED_ARRAY_SUPPORT && !(this instanceof Buffer)) {\n return new Buffer(arg, encodingOrOffset, length)\n }\n\n // Common case.\n if (typeof arg === 'number') {\n if (typeof encodingOrOffset === 'string') {\n throw new Error(\n 'If encoding is specified then the first argument must be a string'\n )\n }\n return allocUnsafe(this, arg)\n }\n return from(this, arg, encodingOrOffset, length)\n}\n\nBuffer.poolSize = 8192 // not used by this implementation\n\n// TODO: Legacy, not needed anymore. Remove in next major version.\nBuffer._augment = function (arr) {\n arr.__proto__ = Buffer.prototype\n return arr\n}\n\nfunction from (that, value, encodingOrOffset, length) {\n if (typeof value === 'number') {\n throw new TypeError('\"value\" argument must not be a number')\n }\n\n if (typeof ArrayBuffer !== 'undefined' && value instanceof ArrayBuffer) {\n return fromArrayBuffer(that, value, encodingOrOffset, length)\n }\n\n if (typeof value === 'string') {\n return fromString(that, value, encodingOrOffset)\n }\n\n return fromObject(that, value)\n}\n\n/**\n * Functionally equivalent to Buffer(arg, encoding) but throws a TypeError\n * if value is a number.\n * Buffer.from(str[, encoding])\n * Buffer.from(array)\n * Buffer.from(buffer)\n * Buffer.from(arrayBuffer[, byteOffset[, length]])\n **/\nBuffer.from = function (value, encodingOrOffset, length) {\n return from(null, value, encodingOrOffset, length)\n}\n\nif (Buffer.TYPED_ARRAY_SUPPORT) {\n Buffer.prototype.__proto__ = Uint8Array.prototype\n Buffer.__proto__ = Uint8Array\n if (typeof Symbol !== 'undefined' && Symbol.species &&\n Buffer[Symbol.species] === Buffer) {\n // Fix subarray() in ES2016. See: https://github.com/feross/buffer/pull/97\n Object.defineProperty(Buffer, Symbol.species, {\n value: null,\n configurable: true\n })\n }\n}\n\nfunction assertSize (size) {\n if (typeof size !== 'number') {\n throw new TypeError('\"size\" argument must be a number')\n } else if (size < 0) {\n throw new RangeError('\"size\" argument must not be negative')\n }\n}\n\nfunction alloc (that, size, fill, encoding) {\n assertSize(size)\n if (size <= 0) {\n return createBuffer(that, size)\n }\n if (fill !== undefined) {\n // Only pay attention to encoding if it's a string. This\n // prevents accidentally sending in a number that would\n // be interpretted as a start offset.\n return typeof encoding === 'string'\n ? createBuffer(that, size).fill(fill, encoding)\n : createBuffer(that, size).fill(fill)\n }\n return createBuffer(that, size)\n}\n\n/**\n * Creates a new filled Buffer instance.\n * alloc(size[, fill[, encoding]])\n **/\nBuffer.alloc = function (size, fill, encoding) {\n return alloc(null, size, fill, encoding)\n}\n\nfunction allocUnsafe (that, size) {\n assertSize(size)\n that = createBuffer(that, size < 0 ? 0 : checked(size) | 0)\n if (!Buffer.TYPED_ARRAY_SUPPORT) {\n for (var i = 0; i < size; ++i) {\n that[i] = 0\n }\n }\n return that\n}\n\n/**\n * Equivalent to Buffer(num), by default creates a non-zero-filled Buffer instance.\n * */\nBuffer.allocUnsafe = function (size) {\n return allocUnsafe(null, size)\n}\n/**\n * Equivalent to SlowBuffer(num), by default creates a non-zero-filled Buffer instance.\n */\nBuffer.allocUnsafeSlow = function (size) {\n return allocUnsafe(null, size)\n}\n\nfunction fromString (that, string, encoding) {\n if (typeof encoding !== 'string' || encoding === '') {\n encoding = 'utf8'\n }\n\n if (!Buffer.isEncoding(encoding)) {\n throw new TypeError('\"encoding\" must be a valid string encoding')\n }\n\n var length = byteLength(string, encoding) | 0\n that = createBuffer(that, length)\n\n var actual = that.write(string, encoding)\n\n if (actual !== length) {\n // Writing a hex string, for example, that contains invalid characters will\n // cause everything after the first invalid character to be ignored. (e.g.\n // 'abxxcd' will be treated as 'ab')\n that = that.slice(0, actual)\n }\n\n return that\n}\n\nfunction fromArrayLike (that, array) {\n var length = array.length < 0 ? 0 : checked(array.length) | 0\n that = createBuffer(that, length)\n for (var i = 0; i < length; i += 1) {\n that[i] = array[i] & 255\n }\n return that\n}\n\nfunction fromArrayBuffer (that, array, byteOffset, length) {\n array.byteLength // this throws if `array` is not a valid ArrayBuffer\n\n if (byteOffset < 0 || array.byteLength < byteOffset) {\n throw new RangeError('\\'offset\\' is out of bounds')\n }\n\n if (array.byteLength < byteOffset + (length || 0)) {\n throw new RangeError('\\'length\\' is out of bounds')\n }\n\n if (byteOffset === undefined && length === undefined) {\n array = new Uint8Array(array)\n } else if (length === undefined) {\n array = new Uint8Array(array, byteOffset)\n } else {\n array = new Uint8Array(array, byteOffset, length)\n }\n\n if (Buffer.TYPED_ARRAY_SUPPORT) {\n // Return an augmented `Uint8Array` instance, for best performance\n that = array\n that.__proto__ = Buffer.prototype\n } else {\n // Fallback: Return an object instance of the Buffer class\n that = fromArrayLike(that, array)\n }\n return that\n}\n\nfunction fromObject (that, obj) {\n if (Buffer.isBuffer(obj)) {\n var len = checked(obj.length) | 0\n that = createBuffer(that, len)\n\n if (that.length === 0) {\n return that\n }\n\n obj.copy(that, 0, 0, len)\n return that\n }\n\n if (obj) {\n if ((typeof ArrayBuffer !== 'undefined' &&\n obj.buffer instanceof ArrayBuffer) || 'length' in obj) {\n if (typeof obj.length !== 'number' || isnan(obj.length)) {\n return createBuffer(that, 0)\n }\n return fromArrayLike(that, obj)\n }\n\n if (obj.type === 'Buffer' && isArray(obj.data)) {\n return fromArrayLike(that, obj.data)\n }\n }\n\n throw new TypeError('First argument must be a string, Buffer, ArrayBuffer, Array, or array-like object.')\n}\n\nfunction checked (length) {\n // Note: cannot use `length < kMaxLength()` here because that fails when\n // length is NaN (which is otherwise coerced to zero.)\n if (length >= kMaxLength()) {\n throw new RangeError('Attempt to allocate Buffer larger than maximum ' +\n 'size: 0x' + kMaxLength().toString(16) + ' bytes')\n }\n return length | 0\n}\n\nfunction SlowBuffer (length) {\n if (+length != length) { // eslint-disable-line eqeqeq\n length = 0\n }\n return Buffer.alloc(+length)\n}\n\nBuffer.isBuffer = function isBuffer (b) {\n return !!(b != null && b._isBuffer)\n}\n\nBuffer.compare = function compare (a, b) {\n if (!Buffer.isBuffer(a) || !Buffer.isBuffer(b)) {\n throw new TypeError('Arguments must be Buffers')\n }\n\n if (a === b) return 0\n\n var x = a.length\n var y = b.length\n\n for (var i = 0, len = Math.min(x, y); i < len; ++i) {\n if (a[i] !== b[i]) {\n x = a[i]\n y = b[i]\n break\n }\n }\n\n if (x < y) return -1\n if (y < x) return 1\n return 0\n}\n\nBuffer.isEncoding = function isEncoding (encoding) {\n switch (String(encoding).toLowerCase()) {\n case 'hex':\n case 'utf8':\n case 'utf-8':\n case 'ascii':\n case 'latin1':\n case 'binary':\n case 'base64':\n case 'ucs2':\n case 'ucs-2':\n case 'utf16le':\n case 'utf-16le':\n return true\n default:\n return false\n }\n}\n\nBuffer.concat = function concat (list, length) {\n if (!isArray(list)) {\n throw new TypeError('\"list\" argument must be an Array of Buffers')\n }\n\n if (list.length === 0) {\n return Buffer.alloc(0)\n }\n\n var i\n if (length === undefined) {\n length = 0\n for (i = 0; i < list.length; ++i) {\n length += list[i].length\n }\n }\n\n var buffer = Buffer.allocUnsafe(length)\n var pos = 0\n for (i = 0; i < list.length; ++i) {\n var buf = list[i]\n if (!Buffer.isBuffer(buf)) {\n throw new TypeError('\"list\" argument must be an Array of Buffers')\n }\n buf.copy(buffer, pos)\n pos += buf.length\n }\n return buffer\n}\n\nfunction byteLength (string, encoding) {\n if (Buffer.isBuffer(string)) {\n return string.length\n }\n if (typeof ArrayBuffer !== 'undefined' && typeof ArrayBuffer.isView === 'function' &&\n (ArrayBuffer.isView(string) || string instanceof ArrayBuffer)) {\n return string.byteLength\n }\n if (typeof string !== 'string') {\n string = '' + string\n }\n\n var len = string.length\n if (len === 0) return 0\n\n // Use a for loop to avoid recursion\n var loweredCase = false\n for (;;) {\n switch (encoding) {\n case 'ascii':\n case 'latin1':\n case 'binary':\n return len\n case 'utf8':\n case 'utf-8':\n case undefined:\n return utf8ToBytes(string).length\n case 'ucs2':\n case 'ucs-2':\n case 'utf16le':\n case 'utf-16le':\n return len * 2\n case 'hex':\n return len >>> 1\n case 'base64':\n return base64ToBytes(string).length\n default:\n if (loweredCase) return utf8ToBytes(string).length // assume utf8\n encoding = ('' + encoding).toLowerCase()\n loweredCase = true\n }\n }\n}\nBuffer.byteLength = byteLength\n\nfunction slowToString (encoding, start, end) {\n var loweredCase = false\n\n // No need to verify that \"this.length <= MAX_UINT32\" since it's a read-only\n // property of a typed array.\n\n // This behaves neither like String nor Uint8Array in that we set start/end\n // to their upper/lower bounds if the value passed is out of range.\n // undefined is handled specially as per ECMA-262 6th Edition,\n // Section 13.3.3.7 Runtime Semantics: KeyedBindingInitialization.\n if (start === undefined || start < 0) {\n start = 0\n }\n // Return early if start > this.length. Done here to prevent potential uint32\n // coercion fail below.\n if (start > this.length) {\n return ''\n }\n\n if (end === undefined || end > this.length) {\n end = this.length\n }\n\n if (end <= 0) {\n return ''\n }\n\n // Force coersion to uint32. This will also coerce falsey/NaN values to 0.\n end >>>= 0\n start >>>= 0\n\n if (end <= start) {\n return ''\n }\n\n if (!encoding) encoding = 'utf8'\n\n while (true) {\n switch (encoding) {\n case 'hex':\n return hexSlice(this, start, end)\n\n case 'utf8':\n case 'utf-8':\n return utf8Slice(this, start, end)\n\n case 'ascii':\n return asciiSlice(this, start, end)\n\n case 'latin1':\n case 'binary':\n return latin1Slice(this, start, end)\n\n case 'base64':\n return base64Slice(this, start, end)\n\n case 'ucs2':\n case 'ucs-2':\n case 'utf16le':\n case 'utf-16le':\n return utf16leSlice(this, start, end)\n\n default:\n if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)\n encoding = (encoding + '').toLowerCase()\n loweredCase = true\n }\n }\n}\n\n// The property is used by `Buffer.isBuffer` and `is-buffer` (in Safari 5-7) to detect\n// Buffer instances.\nBuffer.prototype._isBuffer = true\n\nfunction swap (b, n, m) {\n var i = b[n]\n b[n] = b[m]\n b[m] = i\n}\n\nBuffer.prototype.swap16 = function swap16 () {\n var len = this.length\n if (len % 2 !== 0) {\n throw new RangeError('Buffer size must be a multiple of 16-bits')\n }\n for (var i = 0; i < len; i += 2) {\n swap(this, i, i + 1)\n }\n return this\n}\n\nBuffer.prototype.swap32 = function swap32 () {\n var len = this.length\n if (len % 4 !== 0) {\n throw new RangeError('Buffer size must be a multiple of 32-bits')\n }\n for (var i = 0; i < len; i += 4) {\n swap(this, i, i + 3)\n swap(this, i + 1, i + 2)\n }\n return this\n}\n\nBuffer.prototype.swap64 = function swap64 () {\n var len = this.length\n if (len % 8 !== 0) {\n throw new RangeError('Buffer size must be a multiple of 64-bits')\n }\n for (var i = 0; i < len; i += 8) {\n swap(this, i, i + 7)\n swap(this, i + 1, i + 6)\n swap(this, i + 2, i + 5)\n swap(this, i + 3, i + 4)\n }\n return this\n}\n\nBuffer.prototype.toString = function toString () {\n var length = this.length | 0\n if (length === 0) return ''\n if (arguments.length === 0) return utf8Slice(this, 0, length)\n return slowToString.apply(this, arguments)\n}\n\nBuffer.prototype.equals = function equals (b) {\n if (!Buffer.isBuffer(b)) throw new TypeError('Argument must be a Buffer')\n if (this === b) return true\n return Buffer.compare(this, b) === 0\n}\n\nBuffer.prototype.inspect = function inspect () {\n var str = ''\n var max = exports.INSPECT_MAX_BYTES\n if (this.length > 0) {\n str = this.toString('hex', 0, max).match(/.{2}/g).join(' ')\n if (this.length > max) str += ' ... '\n }\n return ''\n}\n\nBuffer.prototype.compare = function compare (target, start, end, thisStart, thisEnd) {\n if (!Buffer.isBuffer(target)) {\n throw new TypeError('Argument must be a Buffer')\n }\n\n if (start === undefined) {\n start = 0\n }\n if (end === undefined) {\n end = target ? target.length : 0\n }\n if (thisStart === undefined) {\n thisStart = 0\n }\n if (thisEnd === undefined) {\n thisEnd = this.length\n }\n\n if (start < 0 || end > target.length || thisStart < 0 || thisEnd > this.length) {\n throw new RangeError('out of range index')\n }\n\n if (thisStart >= thisEnd && start >= end) {\n return 0\n }\n if (thisStart >= thisEnd) {\n return -1\n }\n if (start >= end) {\n return 1\n }\n\n start >>>= 0\n end >>>= 0\n thisStart >>>= 0\n thisEnd >>>= 0\n\n if (this === target) return 0\n\n var x = thisEnd - thisStart\n var y = end - start\n var len = Math.min(x, y)\n\n var thisCopy = this.slice(thisStart, thisEnd)\n var targetCopy = target.slice(start, end)\n\n for (var i = 0; i < len; ++i) {\n if (thisCopy[i] !== targetCopy[i]) {\n x = thisCopy[i]\n y = targetCopy[i]\n break\n }\n }\n\n if (x < y) return -1\n if (y < x) return 1\n return 0\n}\n\n// Finds either the first index of `val` in `buffer` at offset >= `byteOffset`,\n// OR the last index of `val` in `buffer` at offset <= `byteOffset`.\n//\n// Arguments:\n// - buffer - a Buffer to search\n// - val - a string, Buffer, or number\n// - byteOffset - an index into `buffer`; will be clamped to an int32\n// - encoding - an optional encoding, relevant is val is a string\n// - dir - true for indexOf, false for lastIndexOf\nfunction bidirectionalIndexOf (buffer, val, byteOffset, encoding, dir) {\n // Empty buffer means no match\n if (buffer.length === 0) return -1\n\n // Normalize byteOffset\n if (typeof byteOffset === 'string') {\n encoding = byteOffset\n byteOffset = 0\n } else if (byteOffset > 0x7fffffff) {\n byteOffset = 0x7fffffff\n } else if (byteOffset < -0x80000000) {\n byteOffset = -0x80000000\n }\n byteOffset = +byteOffset // Coerce to Number.\n if (isNaN(byteOffset)) {\n // byteOffset: it it's undefined, null, NaN, \"foo\", etc, search whole buffer\n byteOffset = dir ? 0 : (buffer.length - 1)\n }\n\n // Normalize byteOffset: negative offsets start from the end of the buffer\n if (byteOffset < 0) byteOffset = buffer.length + byteOffset\n if (byteOffset >= buffer.length) {\n if (dir) return -1\n else byteOffset = buffer.length - 1\n } else if (byteOffset < 0) {\n if (dir) byteOffset = 0\n else return -1\n }\n\n // Normalize val\n if (typeof val === 'string') {\n val = Buffer.from(val, encoding)\n }\n\n // Finally, search either indexOf (if dir is true) or lastIndexOf\n if (Buffer.isBuffer(val)) {\n // Special case: looking for empty string/buffer always fails\n if (val.length === 0) {\n return -1\n }\n return arrayIndexOf(buffer, val, byteOffset, encoding, dir)\n } else if (typeof val === 'number') {\n val = val & 0xFF // Search for a byte value [0-255]\n if (Buffer.TYPED_ARRAY_SUPPORT &&\n typeof Uint8Array.prototype.indexOf === 'function') {\n if (dir) {\n return Uint8Array.prototype.indexOf.call(buffer, val, byteOffset)\n } else {\n return Uint8Array.prototype.lastIndexOf.call(buffer, val, byteOffset)\n }\n }\n return arrayIndexOf(buffer, [ val ], byteOffset, encoding, dir)\n }\n\n throw new TypeError('val must be string, number or Buffer')\n}\n\nfunction arrayIndexOf (arr, val, byteOffset, encoding, dir) {\n var indexSize = 1\n var arrLength = arr.length\n var valLength = val.length\n\n if (encoding !== undefined) {\n encoding = String(encoding).toLowerCase()\n if (encoding === 'ucs2' || encoding === 'ucs-2' ||\n encoding === 'utf16le' || encoding === 'utf-16le') {\n if (arr.length < 2 || val.length < 2) {\n return -1\n }\n indexSize = 2\n arrLength /= 2\n valLength /= 2\n byteOffset /= 2\n }\n }\n\n function read (buf, i) {\n if (indexSize === 1) {\n return buf[i]\n } else {\n return buf.readUInt16BE(i * indexSize)\n }\n }\n\n var i\n if (dir) {\n var foundIndex = -1\n for (i = byteOffset; i < arrLength; i++) {\n if (read(arr, i) === read(val, foundIndex === -1 ? 0 : i - foundIndex)) {\n if (foundIndex === -1) foundIndex = i\n if (i - foundIndex + 1 === valLength) return foundIndex * indexSize\n } else {\n if (foundIndex !== -1) i -= i - foundIndex\n foundIndex = -1\n }\n }\n } else {\n if (byteOffset + valLength > arrLength) byteOffset = arrLength - valLength\n for (i = byteOffset; i >= 0; i--) {\n var found = true\n for (var j = 0; j < valLength; j++) {\n if (read(arr, i + j) !== read(val, j)) {\n found = false\n break\n }\n }\n if (found) return i\n }\n }\n\n return -1\n}\n\nBuffer.prototype.includes = function includes (val, byteOffset, encoding) {\n return this.indexOf(val, byteOffset, encoding) !== -1\n}\n\nBuffer.prototype.indexOf = function indexOf (val, byteOffset, encoding) {\n return bidirectionalIndexOf(this, val, byteOffset, encoding, true)\n}\n\nBuffer.prototype.lastIndexOf = function lastIndexOf (val, byteOffset, encoding) {\n return bidirectionalIndexOf(this, val, byteOffset, encoding, false)\n}\n\nfunction hexWrite (buf, string, offset, length) {\n offset = Number(offset) || 0\n var remaining = buf.length - offset\n if (!length) {\n length = remaining\n } else {\n length = Number(length)\n if (length > remaining) {\n length = remaining\n }\n }\n\n // must be an even number of digits\n var strLen = string.length\n if (strLen % 2 !== 0) throw new TypeError('Invalid hex string')\n\n if (length > strLen / 2) {\n length = strLen / 2\n }\n for (var i = 0; i < length; ++i) {\n var parsed = parseInt(string.substr(i * 2, 2), 16)\n if (isNaN(parsed)) return i\n buf[offset + i] = parsed\n }\n return i\n}\n\nfunction utf8Write (buf, string, offset, length) {\n return blitBuffer(utf8ToBytes(string, buf.length - offset), buf, offset, length)\n}\n\nfunction asciiWrite (buf, string, offset, length) {\n return blitBuffer(asciiToBytes(string), buf, offset, length)\n}\n\nfunction latin1Write (buf, string, offset, length) {\n return asciiWrite(buf, string, offset, length)\n}\n\nfunction base64Write (buf, string, offset, length) {\n return blitBuffer(base64ToBytes(string), buf, offset, length)\n}\n\nfunction ucs2Write (buf, string, offset, length) {\n return blitBuffer(utf16leToBytes(string, buf.length - offset), buf, offset, length)\n}\n\nBuffer.prototype.write = function write (string, offset, length, encoding) {\n // Buffer#write(string)\n if (offset === undefined) {\n encoding = 'utf8'\n length = this.length\n offset = 0\n // Buffer#write(string, encoding)\n } else if (length === undefined && typeof offset === 'string') {\n encoding = offset\n length = this.length\n offset = 0\n // Buffer#write(string, offset[, length][, encoding])\n } else if (isFinite(offset)) {\n offset = offset | 0\n if (isFinite(length)) {\n length = length | 0\n if (encoding === undefined) encoding = 'utf8'\n } else {\n encoding = length\n length = undefined\n }\n // legacy write(string, encoding, offset, length) - remove in v0.13\n } else {\n throw new Error(\n 'Buffer.write(string, encoding, offset[, length]) is no longer supported'\n )\n }\n\n var remaining = this.length - offset\n if (length === undefined || length > remaining) length = remaining\n\n if ((string.length > 0 && (length < 0 || offset < 0)) || offset > this.length) {\n throw new RangeError('Attempt to write outside buffer bounds')\n }\n\n if (!encoding) encoding = 'utf8'\n\n var loweredCase = false\n for (;;) {\n switch (encoding) {\n case 'hex':\n return hexWrite(this, string, offset, length)\n\n case 'utf8':\n case 'utf-8':\n return utf8Write(this, string, offset, length)\n\n case 'ascii':\n return asciiWrite(this, string, offset, length)\n\n case 'latin1':\n case 'binary':\n return latin1Write(this, string, offset, length)\n\n case 'base64':\n // Warning: maxLength not taken into account in base64Write\n return base64Write(this, string, offset, length)\n\n case 'ucs2':\n case 'ucs-2':\n case 'utf16le':\n case 'utf-16le':\n return ucs2Write(this, string, offset, length)\n\n default:\n if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)\n encoding = ('' + encoding).toLowerCase()\n loweredCase = true\n }\n }\n}\n\nBuffer.prototype.toJSON = function toJSON () {\n return {\n type: 'Buffer',\n data: Array.prototype.slice.call(this._arr || this, 0)\n }\n}\n\nfunction base64Slice (buf, start, end) {\n if (start === 0 && end === buf.length) {\n return base64.fromByteArray(buf)\n } else {\n return base64.fromByteArray(buf.slice(start, end))\n }\n}\n\nfunction utf8Slice (buf, start, end) {\n end = Math.min(buf.length, end)\n var res = []\n\n var i = start\n while (i < end) {\n var firstByte = buf[i]\n var codePoint = null\n var bytesPerSequence = (firstByte > 0xEF) ? 4\n : (firstByte > 0xDF) ? 3\n : (firstByte > 0xBF) ? 2\n : 1\n\n if (i + bytesPerSequence <= end) {\n var secondByte, thirdByte, fourthByte, tempCodePoint\n\n switch (bytesPerSequence) {\n case 1:\n if (firstByte < 0x80) {\n codePoint = firstByte\n }\n break\n case 2:\n secondByte = buf[i + 1]\n if ((secondByte & 0xC0) === 0x80) {\n tempCodePoint = (firstByte & 0x1F) << 0x6 | (secondByte & 0x3F)\n if (tempCodePoint > 0x7F) {\n codePoint = tempCodePoint\n }\n }\n break\n case 3:\n secondByte = buf[i + 1]\n thirdByte = buf[i + 2]\n if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80) {\n tempCodePoint = (firstByte & 0xF) << 0xC | (secondByte & 0x3F) << 0x6 | (thirdByte & 0x3F)\n if (tempCodePoint > 0x7FF && (tempCodePoint < 0xD800 || tempCodePoint > 0xDFFF)) {\n codePoint = tempCodePoint\n }\n }\n break\n case 4:\n secondByte = buf[i + 1]\n thirdByte = buf[i + 2]\n fourthByte = buf[i + 3]\n if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80 && (fourthByte & 0xC0) === 0x80) {\n tempCodePoint = (firstByte & 0xF) << 0x12 | (secondByte & 0x3F) << 0xC | (thirdByte & 0x3F) << 0x6 | (fourthByte & 0x3F)\n if (tempCodePoint > 0xFFFF && tempCodePoint < 0x110000) {\n codePoint = tempCodePoint\n }\n }\n }\n }\n\n if (codePoint === null) {\n // we did not generate a valid codePoint so insert a\n // replacement char (U+FFFD) and advance only 1 byte\n codePoint = 0xFFFD\n bytesPerSequence = 1\n } else if (codePoint > 0xFFFF) {\n // encode to utf16 (surrogate pair dance)\n codePoint -= 0x10000\n res.push(codePoint >>> 10 & 0x3FF | 0xD800)\n codePoint = 0xDC00 | codePoint & 0x3FF\n }\n\n res.push(codePoint)\n i += bytesPerSequence\n }\n\n return decodeCodePointsArray(res)\n}\n\n// Based on http://stackoverflow.com/a/22747272/680742, the browser with\n// the lowest limit is Chrome, with 0x10000 args.\n// We go 1 magnitude less, for safety\nvar MAX_ARGUMENTS_LENGTH = 0x1000\n\nfunction decodeCodePointsArray (codePoints) {\n var len = codePoints.length\n if (len <= MAX_ARGUMENTS_LENGTH) {\n return String.fromCharCode.apply(String, codePoints) // avoid extra slice()\n }\n\n // Decode in chunks to avoid \"call stack size exceeded\".\n var res = ''\n var i = 0\n while (i < len) {\n res += String.fromCharCode.apply(\n String,\n codePoints.slice(i, i += MAX_ARGUMENTS_LENGTH)\n )\n }\n return res\n}\n\nfunction asciiSlice (buf, start, end) {\n var ret = ''\n end = Math.min(buf.length, end)\n\n for (var i = start; i < end; ++i) {\n ret += String.fromCharCode(buf[i] & 0x7F)\n }\n return ret\n}\n\nfunction latin1Slice (buf, start, end) {\n var ret = ''\n end = Math.min(buf.length, end)\n\n for (var i = start; i < end; ++i) {\n ret += String.fromCharCode(buf[i])\n }\n return ret\n}\n\nfunction hexSlice (buf, start, end) {\n var len = buf.length\n\n if (!start || start < 0) start = 0\n if (!end || end < 0 || end > len) end = len\n\n var out = ''\n for (var i = start; i < end; ++i) {\n out += toHex(buf[i])\n }\n return out\n}\n\nfunction utf16leSlice (buf, start, end) {\n var bytes = buf.slice(start, end)\n var res = ''\n for (var i = 0; i < bytes.length; i += 2) {\n res += String.fromCharCode(bytes[i] + bytes[i + 1] * 256)\n }\n return res\n}\n\nBuffer.prototype.slice = function slice (start, end) {\n var len = this.length\n start = ~~start\n end = end === undefined ? len : ~~end\n\n if (start < 0) {\n start += len\n if (start < 0) start = 0\n } else if (start > len) {\n start = len\n }\n\n if (end < 0) {\n end += len\n if (end < 0) end = 0\n } else if (end > len) {\n end = len\n }\n\n if (end < start) end = start\n\n var newBuf\n if (Buffer.TYPED_ARRAY_SUPPORT) {\n newBuf = this.subarray(start, end)\n newBuf.__proto__ = Buffer.prototype\n } else {\n var sliceLen = end - start\n newBuf = new Buffer(sliceLen, undefined)\n for (var i = 0; i < sliceLen; ++i) {\n newBuf[i] = this[i + start]\n }\n }\n\n return newBuf\n}\n\n/*\n * Need to make sure that buffer isn't trying to write out of bounds.\n */\nfunction checkOffset (offset, ext, length) {\n if ((offset % 1) !== 0 || offset < 0) throw new RangeError('offset is not uint')\n if (offset + ext > length) throw new RangeError('Trying to access beyond buffer length')\n}\n\nBuffer.prototype.readUIntLE = function readUIntLE (offset, byteLength, noAssert) {\n offset = offset | 0\n byteLength = byteLength | 0\n if (!noAssert) checkOffset(offset, byteLength, this.length)\n\n var val = this[offset]\n var mul = 1\n var i = 0\n while (++i < byteLength && (mul *= 0x100)) {\n val += this[offset + i] * mul\n }\n\n return val\n}\n\nBuffer.prototype.readUIntBE = function readUIntBE (offset, byteLength, noAssert) {\n offset = offset | 0\n byteLength = byteLength | 0\n if (!noAssert) {\n checkOffset(offset, byteLength, this.length)\n }\n\n var val = this[offset + --byteLength]\n var mul = 1\n while (byteLength > 0 && (mul *= 0x100)) {\n val += this[offset + --byteLength] * mul\n }\n\n return val\n}\n\nBuffer.prototype.readUInt8 = function readUInt8 (offset, noAssert) {\n if (!noAssert) checkOffset(offset, 1, this.length)\n return this[offset]\n}\n\nBuffer.prototype.readUInt16LE = function readUInt16LE (offset, noAssert) {\n if (!noAssert) checkOffset(offset, 2, this.length)\n return this[offset] | (this[offset + 1] << 8)\n}\n\nBuffer.prototype.readUInt16BE = function readUInt16BE (offset, noAssert) {\n if (!noAssert) checkOffset(offset, 2, this.length)\n return (this[offset] << 8) | this[offset + 1]\n}\n\nBuffer.prototype.readUInt32LE = function readUInt32LE (offset, noAssert) {\n if (!noAssert) checkOffset(offset, 4, this.length)\n\n return ((this[offset]) |\n (this[offset + 1] << 8) |\n (this[offset + 2] << 16)) +\n (this[offset + 3] * 0x1000000)\n}\n\nBuffer.prototype.readUInt32BE = function readUInt32BE (offset, noAssert) {\n if (!noAssert) checkOffset(offset, 4, this.length)\n\n return (this[offset] * 0x1000000) +\n ((this[offset + 1] << 16) |\n (this[offset + 2] << 8) |\n this[offset + 3])\n}\n\nBuffer.prototype.readIntLE = function readIntLE (offset, byteLength, noAssert) {\n offset = offset | 0\n byteLength = byteLength | 0\n if (!noAssert) checkOffset(offset, byteLength, this.length)\n\n var val = this[offset]\n var mul = 1\n var i = 0\n while (++i < byteLength && (mul *= 0x100)) {\n val += this[offset + i] * mul\n }\n mul *= 0x80\n\n if (val >= mul) val -= Math.pow(2, 8 * byteLength)\n\n return val\n}\n\nBuffer.prototype.readIntBE = function readIntBE (offset, byteLength, noAssert) {\n offset = offset | 0\n byteLength = byteLength | 0\n if (!noAssert) checkOffset(offset, byteLength, this.length)\n\n var i = byteLength\n var mul = 1\n var val = this[offset + --i]\n while (i > 0 && (mul *= 0x100)) {\n val += this[offset + --i] * mul\n }\n mul *= 0x80\n\n if (val >= mul) val -= Math.pow(2, 8 * byteLength)\n\n return val\n}\n\nBuffer.prototype.readInt8 = function readInt8 (offset, noAssert) {\n if (!noAssert) checkOffset(offset, 1, this.length)\n if (!(this[offset] & 0x80)) return (this[offset])\n return ((0xff - this[offset] + 1) * -1)\n}\n\nBuffer.prototype.readInt16LE = function readInt16LE (offset, noAssert) {\n if (!noAssert) checkOffset(offset, 2, this.length)\n var val = this[offset] | (this[offset + 1] << 8)\n return (val & 0x8000) ? val | 0xFFFF0000 : val\n}\n\nBuffer.prototype.readInt16BE = function readInt16BE (offset, noAssert) {\n if (!noAssert) checkOffset(offset, 2, this.length)\n var val = this[offset + 1] | (this[offset] << 8)\n return (val & 0x8000) ? val | 0xFFFF0000 : val\n}\n\nBuffer.prototype.readInt32LE = function readInt32LE (offset, noAssert) {\n if (!noAssert) checkOffset(offset, 4, this.length)\n\n return (this[offset]) |\n (this[offset + 1] << 8) |\n (this[offset + 2] << 16) |\n (this[offset + 3] << 24)\n}\n\nBuffer.prototype.readInt32BE = function readInt32BE (offset, noAssert) {\n if (!noAssert) checkOffset(offset, 4, this.length)\n\n return (this[offset] << 24) |\n (this[offset + 1] << 16) |\n (this[offset + 2] << 8) |\n (this[offset + 3])\n}\n\nBuffer.prototype.readFloatLE = function readFloatLE (offset, noAssert) {\n if (!noAssert) checkOffset(offset, 4, this.length)\n return ieee754.read(this, offset, true, 23, 4)\n}\n\nBuffer.prototype.readFloatBE = function readFloatBE (offset, noAssert) {\n if (!noAssert) checkOffset(offset, 4, this.length)\n return ieee754.read(this, offset, false, 23, 4)\n}\n\nBuffer.prototype.readDoubleLE = function readDoubleLE (offset, noAssert) {\n if (!noAssert) checkOffset(offset, 8, this.length)\n return ieee754.read(this, offset, true, 52, 8)\n}\n\nBuffer.prototype.readDoubleBE = function readDoubleBE (offset, noAssert) {\n if (!noAssert) checkOffset(offset, 8, this.length)\n return ieee754.read(this, offset, false, 52, 8)\n}\n\nfunction checkInt (buf, value, offset, ext, max, min) {\n if (!Buffer.isBuffer(buf)) throw new TypeError('\"buffer\" argument must be a Buffer instance')\n if (value > max || value < min) throw new RangeError('\"value\" argument is out of bounds')\n if (offset + ext > buf.length) throw new RangeError('Index out of range')\n}\n\nBuffer.prototype.writeUIntLE = function writeUIntLE (value, offset, byteLength, noAssert) {\n value = +value\n offset = offset | 0\n byteLength = byteLength | 0\n if (!noAssert) {\n var maxBytes = Math.pow(2, 8 * byteLength) - 1\n checkInt(this, value, offset, byteLength, maxBytes, 0)\n }\n\n var mul = 1\n var i = 0\n this[offset] = value & 0xFF\n while (++i < byteLength && (mul *= 0x100)) {\n this[offset + i] = (value / mul) & 0xFF\n }\n\n return offset + byteLength\n}\n\nBuffer.prototype.writeUIntBE = function writeUIntBE (value, offset, byteLength, noAssert) {\n value = +value\n offset = offset | 0\n byteLength = byteLength | 0\n if (!noAssert) {\n var maxBytes = Math.pow(2, 8 * byteLength) - 1\n checkInt(this, value, offset, byteLength, maxBytes, 0)\n }\n\n var i = byteLength - 1\n var mul = 1\n this[offset + i] = value & 0xFF\n while (--i >= 0 && (mul *= 0x100)) {\n this[offset + i] = (value / mul) & 0xFF\n }\n\n return offset + byteLength\n}\n\nBuffer.prototype.writeUInt8 = function writeUInt8 (value, offset, noAssert) {\n value = +value\n offset = offset | 0\n if (!noAssert) checkInt(this, value, offset, 1, 0xff, 0)\n if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value)\n this[offset] = (value & 0xff)\n return offset + 1\n}\n\nfunction objectWriteUInt16 (buf, value, offset, littleEndian) {\n if (value < 0) value = 0xffff + value + 1\n for (var i = 0, j = Math.min(buf.length - offset, 2); i < j; ++i) {\n buf[offset + i] = (value & (0xff << (8 * (littleEndian ? i : 1 - i)))) >>>\n (littleEndian ? i : 1 - i) * 8\n }\n}\n\nBuffer.prototype.writeUInt16LE = function writeUInt16LE (value, offset, noAssert) {\n value = +value\n offset = offset | 0\n if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)\n if (Buffer.TYPED_ARRAY_SUPPORT) {\n this[offset] = (value & 0xff)\n this[offset + 1] = (value >>> 8)\n } else {\n objectWriteUInt16(this, value, offset, true)\n }\n return offset + 2\n}\n\nBuffer.prototype.writeUInt16BE = function writeUInt16BE (value, offset, noAssert) {\n value = +value\n offset = offset | 0\n if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)\n if (Buffer.TYPED_ARRAY_SUPPORT) {\n this[offset] = (value >>> 8)\n this[offset + 1] = (value & 0xff)\n } else {\n objectWriteUInt16(this, value, offset, false)\n }\n return offset + 2\n}\n\nfunction objectWriteUInt32 (buf, value, offset, littleEndian) {\n if (value < 0) value = 0xffffffff + value + 1\n for (var i = 0, j = Math.min(buf.length - offset, 4); i < j; ++i) {\n buf[offset + i] = (value >>> (littleEndian ? i : 3 - i) * 8) & 0xff\n }\n}\n\nBuffer.prototype.writeUInt32LE = function writeUInt32LE (value, offset, noAssert) {\n value = +value\n offset = offset | 0\n if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)\n if (Buffer.TYPED_ARRAY_SUPPORT) {\n this[offset + 3] = (value >>> 24)\n this[offset + 2] = (value >>> 16)\n this[offset + 1] = (value >>> 8)\n this[offset] = (value & 0xff)\n } else {\n objectWriteUInt32(this, value, offset, true)\n }\n return offset + 4\n}\n\nBuffer.prototype.writeUInt32BE = function writeUInt32BE (value, offset, noAssert) {\n value = +value\n offset = offset | 0\n if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)\n if (Buffer.TYPED_ARRAY_SUPPORT) {\n this[offset] = (value >>> 24)\n this[offset + 1] = (value >>> 16)\n this[offset + 2] = (value >>> 8)\n this[offset + 3] = (value & 0xff)\n } else {\n objectWriteUInt32(this, value, offset, false)\n }\n return offset + 4\n}\n\nBuffer.prototype.writeIntLE = function writeIntLE (value, offset, byteLength, noAssert) {\n value = +value\n offset = offset | 0\n if (!noAssert) {\n var limit = Math.pow(2, 8 * byteLength - 1)\n\n checkInt(this, value, offset, byteLength, limit - 1, -limit)\n }\n\n var i = 0\n var mul = 1\n var sub = 0\n this[offset] = value & 0xFF\n while (++i < byteLength && (mul *= 0x100)) {\n if (value < 0 && sub === 0 && this[offset + i - 1] !== 0) {\n sub = 1\n }\n this[offset + i] = ((value / mul) >> 0) - sub & 0xFF\n }\n\n return offset + byteLength\n}\n\nBuffer.prototype.writeIntBE = function writeIntBE (value, offset, byteLength, noAssert) {\n value = +value\n offset = offset | 0\n if (!noAssert) {\n var limit = Math.pow(2, 8 * byteLength - 1)\n\n checkInt(this, value, offset, byteLength, limit - 1, -limit)\n }\n\n var i = byteLength - 1\n var mul = 1\n var sub = 0\n this[offset + i] = value & 0xFF\n while (--i >= 0 && (mul *= 0x100)) {\n if (value < 0 && sub === 0 && this[offset + i + 1] !== 0) {\n sub = 1\n }\n this[offset + i] = ((value / mul) >> 0) - sub & 0xFF\n }\n\n return offset + byteLength\n}\n\nBuffer.prototype.writeInt8 = function writeInt8 (value, offset, noAssert) {\n value = +value\n offset = offset | 0\n if (!noAssert) checkInt(this, value, offset, 1, 0x7f, -0x80)\n if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value)\n if (value < 0) value = 0xff + value + 1\n this[offset] = (value & 0xff)\n return offset + 1\n}\n\nBuffer.prototype.writeInt16LE = function writeInt16LE (value, offset, noAssert) {\n value = +value\n offset = offset | 0\n if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000)\n if (Buffer.TYPED_ARRAY_SUPPORT) {\n this[offset] = (value & 0xff)\n this[offset + 1] = (value >>> 8)\n } else {\n objectWriteUInt16(this, value, offset, true)\n }\n return offset + 2\n}\n\nBuffer.prototype.writeInt16BE = function writeInt16BE (value, offset, noAssert) {\n value = +value\n offset = offset | 0\n if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000)\n if (Buffer.TYPED_ARRAY_SUPPORT) {\n this[offset] = (value >>> 8)\n this[offset + 1] = (value & 0xff)\n } else {\n objectWriteUInt16(this, value, offset, false)\n }\n return offset + 2\n}\n\nBuffer.prototype.writeInt32LE = function writeInt32LE (value, offset, noAssert) {\n value = +value\n offset = offset | 0\n if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)\n if (Buffer.TYPED_ARRAY_SUPPORT) {\n this[offset] = (value & 0xff)\n this[offset + 1] = (value >>> 8)\n this[offset + 2] = (value >>> 16)\n this[offset + 3] = (value >>> 24)\n } else {\n objectWriteUInt32(this, value, offset, true)\n }\n return offset + 4\n}\n\nBuffer.prototype.writeInt32BE = function writeInt32BE (value, offset, noAssert) {\n value = +value\n offset = offset | 0\n if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)\n if (value < 0) value = 0xffffffff + value + 1\n if (Buffer.TYPED_ARRAY_SUPPORT) {\n this[offset] = (value >>> 24)\n this[offset + 1] = (value >>> 16)\n this[offset + 2] = (value >>> 8)\n this[offset + 3] = (value & 0xff)\n } else {\n objectWriteUInt32(this, value, offset, false)\n }\n return offset + 4\n}\n\nfunction checkIEEE754 (buf, value, offset, ext, max, min) {\n if (offset + ext > buf.length) throw new RangeError('Index out of range')\n if (offset < 0) throw new RangeError('Index out of range')\n}\n\nfunction writeFloat (buf, value, offset, littleEndian, noAssert) {\n if (!noAssert) {\n checkIEEE754(buf, value, offset, 4, 3.4028234663852886e+38, -3.4028234663852886e+38)\n }\n ieee754.write(buf, value, offset, littleEndian, 23, 4)\n return offset + 4\n}\n\nBuffer.prototype.writeFloatLE = function writeFloatLE (value, offset, noAssert) {\n return writeFloat(this, value, offset, true, noAssert)\n}\n\nBuffer.prototype.writeFloatBE = function writeFloatBE (value, offset, noAssert) {\n return writeFloat(this, value, offset, false, noAssert)\n}\n\nfunction writeDouble (buf, value, offset, littleEndian, noAssert) {\n if (!noAssert) {\n checkIEEE754(buf, value, offset, 8, 1.7976931348623157E+308, -1.7976931348623157E+308)\n }\n ieee754.write(buf, value, offset, littleEndian, 52, 8)\n return offset + 8\n}\n\nBuffer.prototype.writeDoubleLE = function writeDoubleLE (value, offset, noAssert) {\n return writeDouble(this, value, offset, true, noAssert)\n}\n\nBuffer.prototype.writeDoubleBE = function writeDoubleBE (value, offset, noAssert) {\n return writeDouble(this, value, offset, false, noAssert)\n}\n\n// copy(targetBuffer, targetStart=0, sourceStart=0, sourceEnd=buffer.length)\nBuffer.prototype.copy = function copy (target, targetStart, start, end) {\n if (!start) start = 0\n if (!end && end !== 0) end = this.length\n if (targetStart >= target.length) targetStart = target.length\n if (!targetStart) targetStart = 0\n if (end > 0 && end < start) end = start\n\n // Copy 0 bytes; we're done\n if (end === start) return 0\n if (target.length === 0 || this.length === 0) return 0\n\n // Fatal error conditions\n if (targetStart < 0) {\n throw new RangeError('targetStart out of bounds')\n }\n if (start < 0 || start >= this.length) throw new RangeError('sourceStart out of bounds')\n if (end < 0) throw new RangeError('sourceEnd out of bounds')\n\n // Are we oob?\n if (end > this.length) end = this.length\n if (target.length - targetStart < end - start) {\n end = target.length - targetStart + start\n }\n\n var len = end - start\n var i\n\n if (this === target && start < targetStart && targetStart < end) {\n // descending copy from end\n for (i = len - 1; i >= 0; --i) {\n target[i + targetStart] = this[i + start]\n }\n } else if (len < 1000 || !Buffer.TYPED_ARRAY_SUPPORT) {\n // ascending copy from start\n for (i = 0; i < len; ++i) {\n target[i + targetStart] = this[i + start]\n }\n } else {\n Uint8Array.prototype.set.call(\n target,\n this.subarray(start, start + len),\n targetStart\n )\n }\n\n return len\n}\n\n// Usage:\n// buffer.fill(number[, offset[, end]])\n// buffer.fill(buffer[, offset[, end]])\n// buffer.fill(string[, offset[, end]][, encoding])\nBuffer.prototype.fill = function fill (val, start, end, encoding) {\n // Handle string cases:\n if (typeof val === 'string') {\n if (typeof start === 'string') {\n encoding = start\n start = 0\n end = this.length\n } else if (typeof end === 'string') {\n encoding = end\n end = this.length\n }\n if (val.length === 1) {\n var code = val.charCodeAt(0)\n if (code < 256) {\n val = code\n }\n }\n if (encoding !== undefined && typeof encoding !== 'string') {\n throw new TypeError('encoding must be a string')\n }\n if (typeof encoding === 'string' && !Buffer.isEncoding(encoding)) {\n throw new TypeError('Unknown encoding: ' + encoding)\n }\n } else if (typeof val === 'number') {\n val = val & 255\n }\n\n // Invalid ranges are not set to a default, so can range check early.\n if (start < 0 || this.length < start || this.length < end) {\n throw new RangeError('Out of range index')\n }\n\n if (end <= start) {\n return this\n }\n\n start = start >>> 0\n end = end === undefined ? this.length : end >>> 0\n\n if (!val) val = 0\n\n var i\n if (typeof val === 'number') {\n for (i = start; i < end; ++i) {\n this[i] = val\n }\n } else {\n var bytes = Buffer.isBuffer(val)\n ? val\n : utf8ToBytes(new Buffer(val, encoding).toString())\n var len = bytes.length\n for (i = 0; i < end - start; ++i) {\n this[i + start] = bytes[i % len]\n }\n }\n\n return this\n}\n\n// HELPER FUNCTIONS\n// ================\n\nvar INVALID_BASE64_RE = /[^+\\/0-9A-Za-z-_]/g\n\nfunction base64clean (str) {\n // Node strips out invalid characters like \\n and \\t from the string, base64-js does not\n str = stringtrim(str).replace(INVALID_BASE64_RE, '')\n // Node converts strings with length < 2 to ''\n if (str.length < 2) return ''\n // Node allows for non-padded base64 strings (missing trailing ===), base64-js does not\n while (str.length % 4 !== 0) {\n str = str + '='\n }\n return str\n}\n\nfunction stringtrim (str) {\n if (str.trim) return str.trim()\n return str.replace(/^\\s+|\\s+$/g, '')\n}\n\nfunction toHex (n) {\n if (n < 16) return '0' + n.toString(16)\n return n.toString(16)\n}\n\nfunction utf8ToBytes (string, units) {\n units = units || Infinity\n var codePoint\n var length = string.length\n var leadSurrogate = null\n var bytes = []\n\n for (var i = 0; i < length; ++i) {\n codePoint = string.charCodeAt(i)\n\n // is surrogate component\n if (codePoint > 0xD7FF && codePoint < 0xE000) {\n // last char was a lead\n if (!leadSurrogate) {\n // no lead yet\n if (codePoint > 0xDBFF) {\n // unexpected trail\n if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n continue\n } else if (i + 1 === length) {\n // unpaired lead\n if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n continue\n }\n\n // valid lead\n leadSurrogate = codePoint\n\n continue\n }\n\n // 2 leads in a row\n if (codePoint < 0xDC00) {\n if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n leadSurrogate = codePoint\n continue\n }\n\n // valid surrogate pair\n codePoint = (leadSurrogate - 0xD800 << 10 | codePoint - 0xDC00) + 0x10000\n } else if (leadSurrogate) {\n // valid bmp char, but last char was a lead\n if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n }\n\n leadSurrogate = null\n\n // encode utf8\n if (codePoint < 0x80) {\n if ((units -= 1) < 0) break\n bytes.push(codePoint)\n } else if (codePoint < 0x800) {\n if ((units -= 2) < 0) break\n bytes.push(\n codePoint >> 0x6 | 0xC0,\n codePoint & 0x3F | 0x80\n )\n } else if (codePoint < 0x10000) {\n if ((units -= 3) < 0) break\n bytes.push(\n codePoint >> 0xC | 0xE0,\n codePoint >> 0x6 & 0x3F | 0x80,\n codePoint & 0x3F | 0x80\n )\n } else if (codePoint < 0x110000) {\n if ((units -= 4) < 0) break\n bytes.push(\n codePoint >> 0x12 | 0xF0,\n codePoint >> 0xC & 0x3F | 0x80,\n codePoint >> 0x6 & 0x3F | 0x80,\n codePoint & 0x3F | 0x80\n )\n } else {\n throw new Error('Invalid code point')\n }\n }\n\n return bytes\n}\n\nfunction asciiToBytes (str) {\n var byteArray = []\n for (var i = 0; i < str.length; ++i) {\n // Node's code seems to be doing this and not & 0x7F..\n byteArray.push(str.charCodeAt(i) & 0xFF)\n }\n return byteArray\n}\n\nfunction utf16leToBytes (str, units) {\n var c, hi, lo\n var byteArray = []\n for (var i = 0; i < str.length; ++i) {\n if ((units -= 2) < 0) break\n\n c = str.charCodeAt(i)\n hi = c >> 8\n lo = c % 256\n byteArray.push(lo)\n byteArray.push(hi)\n }\n\n return byteArray\n}\n\nfunction base64ToBytes (str) {\n return base64.toByteArray(base64clean(str))\n}\n\nfunction blitBuffer (src, dst, offset, length) {\n for (var i = 0; i < length; ++i) {\n if ((i + offset >= dst.length) || (i >= src.length)) break\n dst[i + offset] = src[i]\n }\n return i\n}\n\nfunction isnan (val) {\n return val !== val // eslint-disable-line no-self-compare\n}\n","/**\n * This is the web browser implementation of `debug()`.\n *\n * Expose `debug()` as the module.\n */\n\nexports = module.exports = require('./debug');\nexports.log = log;\nexports.formatArgs = formatArgs;\nexports.save = save;\nexports.load = load;\nexports.useColors = useColors;\nexports.storage = 'undefined' != typeof chrome\n && 'undefined' != typeof chrome.storage\n ? chrome.storage.local\n : localstorage();\n\n/**\n * Colors.\n */\n\nexports.colors = [\n 'lightseagreen',\n 'forestgreen',\n 'goldenrod',\n 'dodgerblue',\n 'darkorchid',\n 'crimson'\n];\n\n/**\n * Currently only WebKit-based Web Inspectors, Firefox >= v31,\n * and the Firebug extension (any Firefox version) are known\n * to support \"%c\" CSS customizations.\n *\n * TODO: add a `localStorage` variable to explicitly enable/disable colors\n */\n\nfunction useColors() {\n // NB: In an Electron preload script, document will be defined but not fully\n // initialized. Since we know we're in Chrome, we'll just detect this case\n // explicitly\n if (typeof window !== 'undefined' && window && typeof window.process !== 'undefined' && window.process.type === 'renderer') {\n return true;\n }\n\n // is webkit? http://stackoverflow.com/a/16459606/376773\n // document is undefined in react-native: https://github.com/facebook/react-native/pull/1632\n return (typeof document !== 'undefined' && document && 'WebkitAppearance' in document.documentElement.style) ||\n // is firebug? http://stackoverflow.com/a/398120/376773\n (typeof window !== 'undefined' && window && window.console && (console.firebug || (console.exception && console.table))) ||\n // is firefox >= v31?\n // https://developer.mozilla.org/en-US/docs/Tools/Web_Console#Styling_messages\n (typeof navigator !== 'undefined' && navigator && navigator.userAgent && navigator.userAgent.toLowerCase().match(/firefox\\/(\\d+)/) && parseInt(RegExp.$1, 10) >= 31) ||\n // double check webkit in userAgent just in case we are in a worker\n (typeof navigator !== 'undefined' && navigator && navigator.userAgent && navigator.userAgent.toLowerCase().match(/applewebkit\\/(\\d+)/));\n}\n\n/**\n * Map %j to `JSON.stringify()`, since no Web Inspectors do that by default.\n */\n\nexports.formatters.j = function(v) {\n try {\n return JSON.stringify(v);\n } catch (err) {\n return '[UnexpectedJSONParseError]: ' + err.message;\n }\n};\n\n\n/**\n * Colorize log arguments if enabled.\n *\n * @api public\n */\n\nfunction formatArgs(args) {\n var useColors = this.useColors;\n\n args[0] = (useColors ? '%c' : '')\n + this.namespace\n + (useColors ? ' %c' : ' ')\n + args[0]\n + (useColors ? '%c ' : ' ')\n + '+' + exports.humanize(this.diff);\n\n if (!useColors) return;\n\n var c = 'color: ' + this.color;\n args.splice(1, 0, c, 'color: inherit')\n\n // the final \"%c\" is somewhat tricky, because there could be other\n // arguments passed either before or after the %c, so we need to\n // figure out the correct index to insert the CSS into\n var index = 0;\n var lastC = 0;\n args[0].replace(/%[a-zA-Z%]/g, function(match) {\n if ('%%' === match) return;\n index++;\n if ('%c' === match) {\n // we only are interested in the *last* %c\n // (the user may have provided their own)\n lastC = index;\n }\n });\n\n args.splice(lastC, 0, c);\n}\n\n/**\n * Invokes `console.log()` when available.\n * No-op when `console.log` is not a \"function\".\n *\n * @api public\n */\n\nfunction log() {\n // this hackery is required for IE8/9, where\n // the `console.log` function doesn't have 'apply'\n return 'object' === typeof console\n && console.log\n && Function.prototype.apply.call(console.log, console, arguments);\n}\n\n/**\n * Save `namespaces`.\n *\n * @param {String} namespaces\n * @api private\n */\n\nfunction save(namespaces) {\n try {\n if (null == namespaces) {\n exports.storage.removeItem('debug');\n } else {\n exports.storage.debug = namespaces;\n }\n } catch(e) {}\n}\n\n/**\n * Load `namespaces`.\n *\n * @return {String} returns the previously persisted debug modes\n * @api private\n */\n\nfunction load() {\n try {\n return exports.storage.debug;\n } catch(e) {}\n\n // If debug isn't set in LS, and we're in Electron, try to load $DEBUG\n if (typeof process !== 'undefined' && 'env' in process) {\n return process.env.DEBUG;\n }\n}\n\n/**\n * Enable namespaces listed in `localStorage.debug` initially.\n */\n\nexports.enable(load());\n\n/**\n * Localstorage attempts to return the localstorage.\n *\n * This is necessary because safari throws\n * when a user disables cookies/localstorage\n * and you attempt to access it.\n *\n * @return {LocalStorage}\n * @api private\n */\n\nfunction localstorage() {\n try {\n return window.localStorage;\n } catch (e) {}\n}\n","\n/**\n * This is the common logic for both the Node.js and web browser\n * implementations of `debug()`.\n *\n * Expose `debug()` as the module.\n */\n\nexports = module.exports = createDebug.debug = createDebug.default = createDebug;\nexports.coerce = coerce;\nexports.disable = disable;\nexports.enable = enable;\nexports.enabled = enabled;\nexports.humanize = require('ms');\n\n/**\n * The currently active debug mode names, and names to skip.\n */\n\nexports.names = [];\nexports.skips = [];\n\n/**\n * Map of special \"%n\" handling functions, for the debug \"format\" argument.\n *\n * Valid key names are a single, lower or upper-case letter, i.e. \"n\" and \"N\".\n */\n\nexports.formatters = {};\n\n/**\n * Previous log timestamp.\n */\n\nvar prevTime;\n\n/**\n * Select a color.\n * @param {String} namespace\n * @return {Number}\n * @api private\n */\n\nfunction selectColor(namespace) {\n var hash = 0, i;\n\n for (i in namespace) {\n hash = ((hash << 5) - hash) + namespace.charCodeAt(i);\n hash |= 0; // Convert to 32bit integer\n }\n\n return exports.colors[Math.abs(hash) % exports.colors.length];\n}\n\n/**\n * Create a debugger with the given `namespace`.\n *\n * @param {String} namespace\n * @return {Function}\n * @api public\n */\n\nfunction createDebug(namespace) {\n\n function debug() {\n // disabled?\n if (!debug.enabled) return;\n\n var self = debug;\n\n // set `diff` timestamp\n var curr = +new Date();\n var ms = curr - (prevTime || curr);\n self.diff = ms;\n self.prev = prevTime;\n self.curr = curr;\n prevTime = curr;\n\n // turn the `arguments` into a proper Array\n var args = new Array(arguments.length);\n for (var i = 0; i < args.length; i++) {\n args[i] = arguments[i];\n }\n\n args[0] = exports.coerce(args[0]);\n\n if ('string' !== typeof args[0]) {\n // anything else let's inspect with %O\n args.unshift('%O');\n }\n\n // apply any `formatters` transformations\n var index = 0;\n args[0] = args[0].replace(/%([a-zA-Z%])/g, function(match, format) {\n // if we encounter an escaped % then don't increase the array index\n if (match === '%%') return match;\n index++;\n var formatter = exports.formatters[format];\n if ('function' === typeof formatter) {\n var val = args[index];\n match = formatter.call(self, val);\n\n // now we need to remove `args[index]` since it's inlined in the `format`\n args.splice(index, 1);\n index--;\n }\n return match;\n });\n\n // apply env-specific formatting (colors, etc.)\n exports.formatArgs.call(self, args);\n\n var logFn = debug.log || exports.log || console.log.bind(console);\n logFn.apply(self, args);\n }\n\n debug.namespace = namespace;\n debug.enabled = exports.enabled(namespace);\n debug.useColors = exports.useColors();\n debug.color = selectColor(namespace);\n\n // env-specific initialization logic for debug instances\n if ('function' === typeof exports.init) {\n exports.init(debug);\n }\n\n return debug;\n}\n\n/**\n * Enables a debug mode by namespaces. This can include modes\n * separated by a colon and wildcards.\n *\n * @param {String} namespaces\n * @api public\n */\n\nfunction enable(namespaces) {\n exports.save(namespaces);\n\n var split = (namespaces || '').split(/[\\s,]+/);\n var len = split.length;\n\n for (var i = 0; i < len; i++) {\n if (!split[i]) continue; // ignore empty strings\n namespaces = split[i].replace(/\\*/g, '.*?');\n if (namespaces[0] === '-') {\n exports.skips.push(new RegExp('^' + namespaces.substr(1) + '$'));\n } else {\n exports.names.push(new RegExp('^' + namespaces + '$'));\n }\n }\n}\n\n/**\n * Disable debug output.\n *\n * @api public\n */\n\nfunction disable() {\n exports.enable('');\n}\n\n/**\n * Returns true if the given mode name is enabled, false otherwise.\n *\n * @param {String} name\n * @return {Boolean}\n * @api public\n */\n\nfunction enabled(name) {\n var i, len;\n for (i = 0, len = exports.skips.length; i < len; i++) {\n if (exports.skips[i].test(name)) {\n return false;\n }\n }\n for (i = 0, len = exports.names.length; i < len; i++) {\n if (exports.names[i].test(name)) {\n return true;\n }\n }\n return false;\n}\n\n/**\n * Coerce `val`.\n *\n * @param {Mixed} val\n * @return {Mixed}\n * @api private\n */\n\nfunction coerce(val) {\n if (val instanceof Error) return val.stack || val.message;\n return val;\n}\n","exports.read = function (buffer, offset, isLE, mLen, nBytes) {\n var e, m\n var eLen = nBytes * 8 - mLen - 1\n var eMax = (1 << eLen) - 1\n var eBias = eMax >> 1\n var nBits = -7\n var i = isLE ? (nBytes - 1) : 0\n var d = isLE ? -1 : 1\n var s = buffer[offset + i]\n\n i += d\n\n e = s & ((1 << (-nBits)) - 1)\n s >>= (-nBits)\n nBits += eLen\n for (; nBits > 0; e = e * 256 + buffer[offset + i], i += d, nBits -= 8) {}\n\n m = e & ((1 << (-nBits)) - 1)\n e >>= (-nBits)\n nBits += mLen\n for (; nBits > 0; m = m * 256 + buffer[offset + i], i += d, nBits -= 8) {}\n\n if (e === 0) {\n e = 1 - eBias\n } else if (e === eMax) {\n return m ? NaN : ((s ? -1 : 1) * Infinity)\n } else {\n m = m + Math.pow(2, mLen)\n e = e - eBias\n }\n return (s ? -1 : 1) * m * Math.pow(2, e - mLen)\n}\n\nexports.write = function (buffer, value, offset, isLE, mLen, nBytes) {\n var e, m, c\n var eLen = nBytes * 8 - mLen - 1\n var eMax = (1 << eLen) - 1\n var eBias = eMax >> 1\n var rt = (mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0)\n var i = isLE ? 0 : (nBytes - 1)\n var d = isLE ? 1 : -1\n var s = value < 0 || (value === 0 && 1 / value < 0) ? 1 : 0\n\n value = Math.abs(value)\n\n if (isNaN(value) || value === Infinity) {\n m = isNaN(value) ? 1 : 0\n e = eMax\n } else {\n e = Math.floor(Math.log(value) / Math.LN2)\n if (value * (c = Math.pow(2, -e)) < 1) {\n e--\n c *= 2\n }\n if (e + eBias >= 1) {\n value += rt / c\n } else {\n value += rt * Math.pow(2, 1 - eBias)\n }\n if (value * c >= 2) {\n e++\n c /= 2\n }\n\n if (e + eBias >= eMax) {\n m = 0\n e = eMax\n } else if (e + eBias >= 1) {\n m = (value * c - 1) * Math.pow(2, mLen)\n e = e + eBias\n } else {\n m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen)\n e = 0\n }\n }\n\n for (; mLen >= 8; buffer[offset + i] = m & 0xff, i += d, m /= 256, mLen -= 8) {}\n\n e = (e << mLen) | m\n eLen += mLen\n for (; eLen > 0; buffer[offset + i] = e & 0xff, i += d, e /= 256, eLen -= 8) {}\n\n buffer[offset + i - d] |= s * 128\n}\n","var toString = {}.toString;\n\nmodule.exports = Array.isArray || function (arr) {\n return toString.call(arr) == '[object Array]';\n};\n","/*\n * $Id: base64.js,v 2.15 2014/04/05 12:58:57 dankogai Exp dankogai $\n *\n * Licensed under the MIT license.\n * http://opensource.org/licenses/mit-license\n *\n * References:\n * http://en.wikipedia.org/wiki/Base64\n */\n\n(function(global) {\n 'use strict';\n // existing version for noConflict()\n var _Base64 = global.Base64;\n var version = \"2.1.9\";\n // if node.js, we use Buffer\n var buffer;\n if (typeof module !== 'undefined' && module.exports) {\n try {\n buffer = require('buffer').Buffer;\n } catch (err) {}\n }\n // constants\n var b64chars\n = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';\n var b64tab = function(bin) {\n var t = {};\n for (var i = 0, l = bin.length; i < l; i++) t[bin.charAt(i)] = i;\n return t;\n }(b64chars);\n var fromCharCode = String.fromCharCode;\n // encoder stuff\n var cb_utob = function(c) {\n if (c.length < 2) {\n var cc = c.charCodeAt(0);\n return cc < 0x80 ? c\n : cc < 0x800 ? (fromCharCode(0xc0 | (cc >>> 6))\n + fromCharCode(0x80 | (cc & 0x3f)))\n : (fromCharCode(0xe0 | ((cc >>> 12) & 0x0f))\n + fromCharCode(0x80 | ((cc >>> 6) & 0x3f))\n + fromCharCode(0x80 | ( cc & 0x3f)));\n } else {\n var cc = 0x10000\n + (c.charCodeAt(0) - 0xD800) * 0x400\n + (c.charCodeAt(1) - 0xDC00);\n return (fromCharCode(0xf0 | ((cc >>> 18) & 0x07))\n + fromCharCode(0x80 | ((cc >>> 12) & 0x3f))\n + fromCharCode(0x80 | ((cc >>> 6) & 0x3f))\n + fromCharCode(0x80 | ( cc & 0x3f)));\n }\n };\n var re_utob = /[\\uD800-\\uDBFF][\\uDC00-\\uDFFFF]|[^\\x00-\\x7F]/g;\n var utob = function(u) {\n return u.replace(re_utob, cb_utob);\n };\n var cb_encode = function(ccc) {\n var padlen = [0, 2, 1][ccc.length % 3],\n ord = ccc.charCodeAt(0) << 16\n | ((ccc.length > 1 ? ccc.charCodeAt(1) : 0) << 8)\n | ((ccc.length > 2 ? ccc.charCodeAt(2) : 0)),\n chars = [\n b64chars.charAt( ord >>> 18),\n b64chars.charAt((ord >>> 12) & 63),\n padlen >= 2 ? '=' : b64chars.charAt((ord >>> 6) & 63),\n padlen >= 1 ? '=' : b64chars.charAt(ord & 63)\n ];\n return chars.join('');\n };\n var btoa = global.btoa ? function(b) {\n return global.btoa(b);\n } : function(b) {\n return b.replace(/[\\s\\S]{1,3}/g, cb_encode);\n };\n var _encode = buffer ? function (u) {\n return (u.constructor === buffer.constructor ? u : new buffer(u))\n .toString('base64')\n }\n : function (u) { return btoa(utob(u)) }\n ;\n var encode = function(u, urisafe) {\n return !urisafe\n ? _encode(String(u))\n : _encode(String(u)).replace(/[+\\/]/g, function(m0) {\n return m0 == '+' ? '-' : '_';\n }).replace(/=/g, '');\n };\n var encodeURI = function(u) { return encode(u, true) };\n // decoder stuff\n var re_btou = new RegExp([\n '[\\xC0-\\xDF][\\x80-\\xBF]',\n '[\\xE0-\\xEF][\\x80-\\xBF]{2}',\n '[\\xF0-\\xF7][\\x80-\\xBF]{3}'\n ].join('|'), 'g');\n var cb_btou = function(cccc) {\n switch(cccc.length) {\n case 4:\n var cp = ((0x07 & cccc.charCodeAt(0)) << 18)\n | ((0x3f & cccc.charCodeAt(1)) << 12)\n | ((0x3f & cccc.charCodeAt(2)) << 6)\n | (0x3f & cccc.charCodeAt(3)),\n offset = cp - 0x10000;\n return (fromCharCode((offset >>> 10) + 0xD800)\n + fromCharCode((offset & 0x3FF) + 0xDC00));\n case 3:\n return fromCharCode(\n ((0x0f & cccc.charCodeAt(0)) << 12)\n | ((0x3f & cccc.charCodeAt(1)) << 6)\n | (0x3f & cccc.charCodeAt(2))\n );\n default:\n return fromCharCode(\n ((0x1f & cccc.charCodeAt(0)) << 6)\n | (0x3f & cccc.charCodeAt(1))\n );\n }\n };\n var btou = function(b) {\n return b.replace(re_btou, cb_btou);\n };\n var cb_decode = function(cccc) {\n var len = cccc.length,\n padlen = len % 4,\n n = (len > 0 ? b64tab[cccc.charAt(0)] << 18 : 0)\n | (len > 1 ? b64tab[cccc.charAt(1)] << 12 : 0)\n | (len > 2 ? b64tab[cccc.charAt(2)] << 6 : 0)\n | (len > 3 ? b64tab[cccc.charAt(3)] : 0),\n chars = [\n fromCharCode( n >>> 16),\n fromCharCode((n >>> 8) & 0xff),\n fromCharCode( n & 0xff)\n ];\n chars.length -= [0, 0, 2, 1][padlen];\n return chars.join('');\n };\n var atob = global.atob ? function(a) {\n return global.atob(a);\n } : function(a){\n return a.replace(/[\\s\\S]{1,4}/g, cb_decode);\n };\n var _decode = buffer ? function(a) {\n return (a.constructor === buffer.constructor\n ? a : new buffer(a, 'base64')).toString();\n }\n : function(a) { return btou(atob(a)) };\n var decode = function(a){\n return _decode(\n String(a).replace(/[-_]/g, function(m0) { return m0 == '-' ? '+' : '/' })\n .replace(/[^A-Za-z0-9\\+\\/]/g, '')\n );\n };\n var noConflict = function() {\n var Base64 = global.Base64;\n global.Base64 = _Base64;\n return Base64;\n };\n // export Base64\n global.Base64 = {\n VERSION: version,\n atob: atob,\n btoa: btoa,\n fromBase64: decode,\n toBase64: encode,\n utob: utob,\n encode: encode,\n encodeURI: encodeURI,\n btou: btou,\n decode: decode,\n noConflict: noConflict\n };\n // if ES5 is available, make Base64.extendString() available\n if (typeof Object.defineProperty === 'function') {\n var noEnum = function(v){\n return {value:v,enumerable:false,writable:true,configurable:true};\n };\n global.Base64.extendString = function () {\n Object.defineProperty(\n String.prototype, 'fromBase64', noEnum(function () {\n return decode(this)\n }));\n Object.defineProperty(\n String.prototype, 'toBase64', noEnum(function (urisafe) {\n return encode(this, urisafe)\n }));\n Object.defineProperty(\n String.prototype, 'toBase64URI', noEnum(function () {\n return encode(this, true)\n }));\n };\n }\n // that's it!\n if (global['Meteor']) {\n Base64 = global.Base64; // for normal export in Meteor.js\n }\n})(this);\n","/**\n * Helpers.\n */\n\nvar s = 1000\nvar m = s * 60\nvar h = m * 60\nvar d = h * 24\nvar y = d * 365.25\n\n/**\n * Parse or format the given `val`.\n *\n * Options:\n *\n * - `long` verbose formatting [false]\n *\n * @param {String|Number} val\n * @param {Object} options\n * @throws {Error} throw an error if val is not a non-empty string or a number\n * @return {String|Number}\n * @api public\n */\n\nmodule.exports = function (val, options) {\n options = options || {}\n var type = typeof val\n if (type === 'string' && val.length > 0) {\n return parse(val)\n } else if (type === 'number' && isNaN(val) === false) {\n return options.long ?\n\t\t\tfmtLong(val) :\n\t\t\tfmtShort(val)\n }\n throw new Error('val is not a non-empty string or a valid number. val=' + JSON.stringify(val))\n}\n\n/**\n * Parse the given `str` and return milliseconds.\n *\n * @param {String} str\n * @return {Number}\n * @api private\n */\n\nfunction parse(str) {\n str = String(str)\n if (str.length > 10000) {\n return\n }\n var match = /^((?:\\d+)?\\.?\\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|years?|yrs?|y)?$/i.exec(str)\n if (!match) {\n return\n }\n var n = parseFloat(match[1])\n var type = (match[2] || 'ms').toLowerCase()\n switch (type) {\n case 'years':\n case 'year':\n case 'yrs':\n case 'yr':\n case 'y':\n return n * y\n case 'days':\n case 'day':\n case 'd':\n return n * d\n case 'hours':\n case 'hour':\n case 'hrs':\n case 'hr':\n case 'h':\n return n * h\n case 'minutes':\n case 'minute':\n case 'mins':\n case 'min':\n case 'm':\n return n * m\n case 'seconds':\n case 'second':\n case 'secs':\n case 'sec':\n case 's':\n return n * s\n case 'milliseconds':\n case 'millisecond':\n case 'msecs':\n case 'msec':\n case 'ms':\n return n\n default:\n return undefined\n }\n}\n\n/**\n * Short format for `ms`.\n *\n * @param {Number} ms\n * @return {String}\n * @api private\n */\n\nfunction fmtShort(ms) {\n if (ms >= d) {\n return Math.round(ms / d) + 'd'\n }\n if (ms >= h) {\n return Math.round(ms / h) + 'h'\n }\n if (ms >= m) {\n return Math.round(ms / m) + 'm'\n }\n if (ms >= s) {\n return Math.round(ms / s) + 's'\n }\n return ms + 'ms'\n}\n\n/**\n * Long format for `ms`.\n *\n * @param {Number} ms\n * @return {String}\n * @api private\n */\n\nfunction fmtLong(ms) {\n return plural(ms, d, 'day') ||\n plural(ms, h, 'hour') ||\n plural(ms, m, 'minute') ||\n plural(ms, s, 'second') ||\n ms + ' ms'\n}\n\n/**\n * Pluralization helper.\n */\n\nfunction plural(ms, n, name) {\n if (ms < n) {\n return\n }\n if (ms < n * 1.5) {\n return Math.floor(ms / n) + ' ' + name\n }\n return Math.ceil(ms / n) + ' ' + name + 's'\n}\n","// shim for using process in browser\nvar process = module.exports = {};\n\n// cached from whatever global is present so that test runners that stub it\n// don't break things. But we need to wrap it in a try catch in case it is\n// wrapped in strict mode code which doesn't define any globals. It's inside a\n// function because try/catches deoptimize in certain engines.\n\nvar cachedSetTimeout;\nvar cachedClearTimeout;\n\nfunction defaultSetTimout() {\n throw new Error('setTimeout has not been defined');\n}\nfunction defaultClearTimeout () {\n throw new Error('clearTimeout has not been defined');\n}\n(function () {\n try {\n if (typeof setTimeout === 'function') {\n cachedSetTimeout = setTimeout;\n } else {\n cachedSetTimeout = defaultSetTimout;\n }\n } catch (e) {\n cachedSetTimeout = defaultSetTimout;\n }\n try {\n if (typeof clearTimeout === 'function') {\n cachedClearTimeout = clearTimeout;\n } else {\n cachedClearTimeout = defaultClearTimeout;\n }\n } catch (e) {\n cachedClearTimeout = defaultClearTimeout;\n }\n} ())\nfunction runTimeout(fun) {\n if (cachedSetTimeout === setTimeout) {\n //normal enviroments in sane situations\n return setTimeout(fun, 0);\n }\n // if setTimeout wasn't available but was latter defined\n if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {\n cachedSetTimeout = setTimeout;\n return setTimeout(fun, 0);\n }\n try {\n // when when somebody has screwed with setTimeout but no I.E. maddness\n return cachedSetTimeout(fun, 0);\n } catch(e){\n try {\n // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally\n return cachedSetTimeout.call(null, fun, 0);\n } catch(e){\n // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error\n return cachedSetTimeout.call(this, fun, 0);\n }\n }\n\n\n}\nfunction runClearTimeout(marker) {\n if (cachedClearTimeout === clearTimeout) {\n //normal enviroments in sane situations\n return clearTimeout(marker);\n }\n // if clearTimeout wasn't available but was latter defined\n if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {\n cachedClearTimeout = clearTimeout;\n return clearTimeout(marker);\n }\n try {\n // when when somebody has screwed with setTimeout but no I.E. maddness\n return cachedClearTimeout(marker);\n } catch (e){\n try {\n // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally\n return cachedClearTimeout.call(null, marker);\n } catch (e){\n // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error.\n // Some versions of I.E. have different rules for clearTimeout vs setTimeout\n return cachedClearTimeout.call(this, marker);\n }\n }\n\n\n\n}\nvar queue = [];\nvar draining = false;\nvar currentQueue;\nvar queueIndex = -1;\n\nfunction cleanUpNextTick() {\n if (!draining || !currentQueue) {\n return;\n }\n draining = false;\n if (currentQueue.length) {\n queue = currentQueue.concat(queue);\n } else {\n queueIndex = -1;\n }\n if (queue.length) {\n drainQueue();\n }\n}\n\nfunction drainQueue() {\n if (draining) {\n return;\n }\n var timeout = runTimeout(cleanUpNextTick);\n draining = true;\n\n var len = queue.length;\n while(len) {\n currentQueue = queue;\n queue = [];\n while (++queueIndex < len) {\n if (currentQueue) {\n currentQueue[queueIndex].run();\n }\n }\n queueIndex = -1;\n len = queue.length;\n }\n currentQueue = null;\n draining = false;\n runClearTimeout(timeout);\n}\n\nprocess.nextTick = function (fun) {\n var args = new Array(arguments.length - 1);\n if (arguments.length > 1) {\n for (var i = 1; i < arguments.length; i++) {\n args[i - 1] = arguments[i];\n }\n }\n queue.push(new Item(fun, args));\n if (queue.length === 1 && !draining) {\n runTimeout(drainQueue);\n }\n};\n\n// v8 likes predictible objects\nfunction Item(fun, array) {\n this.fun = fun;\n this.array = array;\n}\nItem.prototype.run = function () {\n this.fun.apply(null, this.array);\n};\nprocess.title = 'browser';\nprocess.browser = true;\nprocess.env = {};\nprocess.argv = [];\nprocess.version = ''; // empty string to avoid regexp issues\nprocess.versions = {};\n\nfunction noop() {}\n\nprocess.on = noop;\nprocess.addListener = noop;\nprocess.once = noop;\nprocess.off = noop;\nprocess.removeListener = noop;\nprocess.removeAllListeners = noop;\nprocess.emit = noop;\n\nprocess.binding = function (name) {\n throw new Error('process.binding is not supported');\n};\n\nprocess.cwd = function () { return '/' };\nprocess.chdir = function (dir) {\n throw new Error('process.chdir is not supported');\n};\nprocess.umask = function() { return 0; };\n","/*! https://mths.be/utf8js v2.1.2 by @mathias */\n;(function(root) {\n\n\t// Detect free variables `exports`\n\tvar freeExports = typeof exports == 'object' && exports;\n\n\t// Detect free variable `module`\n\tvar freeModule = typeof module == 'object' && module &&\n\t\tmodule.exports == freeExports && module;\n\n\t// Detect free variable `global`, from Node.js or Browserified code,\n\t// and use it as `root`\n\tvar freeGlobal = typeof global == 'object' && global;\n\tif (freeGlobal.global === freeGlobal || freeGlobal.window === freeGlobal) {\n\t\troot = freeGlobal;\n\t}\n\n\t/*--------------------------------------------------------------------------*/\n\n\tvar stringFromCharCode = String.fromCharCode;\n\n\t// Taken from https://mths.be/punycode\n\tfunction ucs2decode(string) {\n\t\tvar output = [];\n\t\tvar counter = 0;\n\t\tvar length = string.length;\n\t\tvar value;\n\t\tvar extra;\n\t\twhile (counter < length) {\n\t\t\tvalue = string.charCodeAt(counter++);\n\t\t\tif (value >= 0xD800 && value <= 0xDBFF && counter < length) {\n\t\t\t\t// high surrogate, and there is a next character\n\t\t\t\textra = string.charCodeAt(counter++);\n\t\t\t\tif ((extra & 0xFC00) == 0xDC00) { // low surrogate\n\t\t\t\t\toutput.push(((value & 0x3FF) << 10) + (extra & 0x3FF) + 0x10000);\n\t\t\t\t} else {\n\t\t\t\t\t// unmatched surrogate; only append this code unit, in case the next\n\t\t\t\t\t// code unit is the high surrogate of a surrogate pair\n\t\t\t\t\toutput.push(value);\n\t\t\t\t\tcounter--;\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\toutput.push(value);\n\t\t\t}\n\t\t}\n\t\treturn output;\n\t}\n\n\t// Taken from https://mths.be/punycode\n\tfunction ucs2encode(array) {\n\t\tvar length = array.length;\n\t\tvar index = -1;\n\t\tvar value;\n\t\tvar output = '';\n\t\twhile (++index < length) {\n\t\t\tvalue = array[index];\n\t\t\tif (value > 0xFFFF) {\n\t\t\t\tvalue -= 0x10000;\n\t\t\t\toutput += stringFromCharCode(value >>> 10 & 0x3FF | 0xD800);\n\t\t\t\tvalue = 0xDC00 | value & 0x3FF;\n\t\t\t}\n\t\t\toutput += stringFromCharCode(value);\n\t\t}\n\t\treturn output;\n\t}\n\n\tfunction checkScalarValue(codePoint) {\n\t\tif (codePoint >= 0xD800 && codePoint <= 0xDFFF) {\n\t\t\tthrow Error(\n\t\t\t\t'Lone surrogate U+' + codePoint.toString(16).toUpperCase() +\n\t\t\t\t' is not a scalar value'\n\t\t\t);\n\t\t}\n\t}\n\t/*--------------------------------------------------------------------------*/\n\n\tfunction createByte(codePoint, shift) {\n\t\treturn stringFromCharCode(((codePoint >> shift) & 0x3F) | 0x80);\n\t}\n\n\tfunction encodeCodePoint(codePoint) {\n\t\tif ((codePoint & 0xFFFFFF80) == 0) { // 1-byte sequence\n\t\t\treturn stringFromCharCode(codePoint);\n\t\t}\n\t\tvar symbol = '';\n\t\tif ((codePoint & 0xFFFFF800) == 0) { // 2-byte sequence\n\t\t\tsymbol = stringFromCharCode(((codePoint >> 6) & 0x1F) | 0xC0);\n\t\t}\n\t\telse if ((codePoint & 0xFFFF0000) == 0) { // 3-byte sequence\n\t\t\tcheckScalarValue(codePoint);\n\t\t\tsymbol = stringFromCharCode(((codePoint >> 12) & 0x0F) | 0xE0);\n\t\t\tsymbol += createByte(codePoint, 6);\n\t\t}\n\t\telse if ((codePoint & 0xFFE00000) == 0) { // 4-byte sequence\n\t\t\tsymbol = stringFromCharCode(((codePoint >> 18) & 0x07) | 0xF0);\n\t\t\tsymbol += createByte(codePoint, 12);\n\t\t\tsymbol += createByte(codePoint, 6);\n\t\t}\n\t\tsymbol += stringFromCharCode((codePoint & 0x3F) | 0x80);\n\t\treturn symbol;\n\t}\n\n\tfunction utf8encode(string) {\n\t\tvar codePoints = ucs2decode(string);\n\t\tvar length = codePoints.length;\n\t\tvar index = -1;\n\t\tvar codePoint;\n\t\tvar byteString = '';\n\t\twhile (++index < length) {\n\t\t\tcodePoint = codePoints[index];\n\t\t\tbyteString += encodeCodePoint(codePoint);\n\t\t}\n\t\treturn byteString;\n\t}\n\n\t/*--------------------------------------------------------------------------*/\n\n\tfunction readContinuationByte() {\n\t\tif (byteIndex >= byteCount) {\n\t\t\tthrow Error('Invalid byte index');\n\t\t}\n\n\t\tvar continuationByte = byteArray[byteIndex] & 0xFF;\n\t\tbyteIndex++;\n\n\t\tif ((continuationByte & 0xC0) == 0x80) {\n\t\t\treturn continuationByte & 0x3F;\n\t\t}\n\n\t\t// If we end up here, it’s not a continuation byte\n\t\tthrow Error('Invalid continuation byte');\n\t}\n\n\tfunction decodeSymbol() {\n\t\tvar byte1;\n\t\tvar byte2;\n\t\tvar byte3;\n\t\tvar byte4;\n\t\tvar codePoint;\n\n\t\tif (byteIndex > byteCount) {\n\t\t\tthrow Error('Invalid byte index');\n\t\t}\n\n\t\tif (byteIndex == byteCount) {\n\t\t\treturn false;\n\t\t}\n\n\t\t// Read first byte\n\t\tbyte1 = byteArray[byteIndex] & 0xFF;\n\t\tbyteIndex++;\n\n\t\t// 1-byte sequence (no continuation bytes)\n\t\tif ((byte1 & 0x80) == 0) {\n\t\t\treturn byte1;\n\t\t}\n\n\t\t// 2-byte sequence\n\t\tif ((byte1 & 0xE0) == 0xC0) {\n\t\t\tbyte2 = readContinuationByte();\n\t\t\tcodePoint = ((byte1 & 0x1F) << 6) | byte2;\n\t\t\tif (codePoint >= 0x80) {\n\t\t\t\treturn codePoint;\n\t\t\t} else {\n\t\t\t\tthrow Error('Invalid continuation byte');\n\t\t\t}\n\t\t}\n\n\t\t// 3-byte sequence (may include unpaired surrogates)\n\t\tif ((byte1 & 0xF0) == 0xE0) {\n\t\t\tbyte2 = readContinuationByte();\n\t\t\tbyte3 = readContinuationByte();\n\t\t\tcodePoint = ((byte1 & 0x0F) << 12) | (byte2 << 6) | byte3;\n\t\t\tif (codePoint >= 0x0800) {\n\t\t\t\tcheckScalarValue(codePoint);\n\t\t\t\treturn codePoint;\n\t\t\t} else {\n\t\t\t\tthrow Error('Invalid continuation byte');\n\t\t\t}\n\t\t}\n\n\t\t// 4-byte sequence\n\t\tif ((byte1 & 0xF8) == 0xF0) {\n\t\t\tbyte2 = readContinuationByte();\n\t\t\tbyte3 = readContinuationByte();\n\t\t\tbyte4 = readContinuationByte();\n\t\t\tcodePoint = ((byte1 & 0x07) << 0x12) | (byte2 << 0x0C) |\n\t\t\t\t(byte3 << 0x06) | byte4;\n\t\t\tif (codePoint >= 0x010000 && codePoint <= 0x10FFFF) {\n\t\t\t\treturn codePoint;\n\t\t\t}\n\t\t}\n\n\t\tthrow Error('Invalid UTF-8 detected');\n\t}\n\n\tvar byteArray;\n\tvar byteCount;\n\tvar byteIndex;\n\tfunction utf8decode(byteString) {\n\t\tbyteArray = ucs2decode(byteString);\n\t\tbyteCount = byteArray.length;\n\t\tbyteIndex = 0;\n\t\tvar codePoints = [];\n\t\tvar tmp;\n\t\twhile ((tmp = decodeSymbol()) !== false) {\n\t\t\tcodePoints.push(tmp);\n\t\t}\n\t\treturn ucs2encode(codePoints);\n\t}\n\n\t/*--------------------------------------------------------------------------*/\n\n\tvar utf8 = {\n\t\t'version': '2.1.2',\n\t\t'encode': utf8encode,\n\t\t'decode': utf8decode\n\t};\n\n\t// Some AMD build optimizers, like r.js, check for specific condition patterns\n\t// like the following:\n\tif (\n\t\ttypeof define == 'function' &&\n\t\ttypeof define.amd == 'object' &&\n\t\tdefine.amd\n\t) {\n\t\tdefine(function() {\n\t\t\treturn utf8;\n\t\t});\n\t}\telse if (freeExports && !freeExports.nodeType) {\n\t\tif (freeModule) { // in Node.js or RingoJS v0.8.0+\n\t\t\tfreeModule.exports = utf8;\n\t\t} else { // in Narwhal or RingoJS v0.7.0-\n\t\t\tvar object = {};\n\t\t\tvar hasOwnProperty = object.hasOwnProperty;\n\t\t\tfor (var key in utf8) {\n\t\t\t\thasOwnProperty.call(utf8, key) && (freeExports[key] = utf8[key]);\n\t\t\t}\n\t\t}\n\t} else { // in Rhino or a web browser\n\t\troot.utf8 = utf8;\n\t}\n\n}(this));\n"],"preExistingComment":"//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["node_modules/browser-pack/_prelude.js","lib/Gist.js","lib/GitHub.js","lib/Issue.js","lib/Markdown.js","lib/Organization.js","lib/Project.js","lib/RateLimit.js","lib/Repository.js","lib/Requestable.js","lib/Search.js","lib/Team.js","lib/User.js","node_modules/axios/index.js","node_modules/axios/lib/adapters/xhr.js","node_modules/axios/lib/axios.js","node_modules/axios/lib/cancel/Cancel.js","node_modules/axios/lib/cancel/CancelToken.js","node_modules/axios/lib/cancel/isCancel.js","node_modules/axios/lib/core/Axios.js","node_modules/axios/lib/core/InterceptorManager.js","node_modules/axios/lib/core/createError.js","node_modules/axios/lib/core/dispatchRequest.js","node_modules/axios/lib/core/enhanceError.js","node_modules/axios/lib/core/settle.js","node_modules/axios/lib/core/transformData.js","node_modules/axios/lib/defaults.js","node_modules/axios/lib/helpers/bind.js","node_modules/axios/lib/helpers/btoa.js","node_modules/axios/lib/helpers/buildURL.js","node_modules/axios/lib/helpers/combineURLs.js","node_modules/axios/lib/helpers/cookies.js","node_modules/axios/lib/helpers/isAbsoluteURL.js","node_modules/axios/lib/helpers/isURLSameOrigin.js","node_modules/axios/lib/helpers/normalizeHeaderName.js","node_modules/axios/lib/helpers/parseHeaders.js","node_modules/axios/lib/helpers/spread.js","node_modules/axios/lib/utils.js","node_modules/base64-js/index.js","node_modules/buffer/index.js","node_modules/debug/src/browser.js","node_modules/debug/src/debug.js","node_modules/ieee754/index.js","node_modules/isarray/index.js","node_modules/js-base64/base64.js","node_modules/ms/index.js","node_modules/process/browser.js","node_modules/utf8/utf8.js"],"names":[],"mappings":"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ACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;ACjLA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACpDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACnBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACzDA;AACA;AACA;AACA;AACA;AACA;;ACLA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACrFA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACpDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC/EA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACnBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACzBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;ACpBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;AC7FA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACXA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACpCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACpEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACZA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACrDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACdA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACpEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACZA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACr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lHA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;AC7vDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;ACtLA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACvMA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACpFA;AACA;AACA;AACA;AACA;AACA;;ACLA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AClMA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACrJA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;ACpLA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA","file":"generated.js","sourceRoot":"","sourcesContent":["(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require==\"function\"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error(\"Cannot find module '\"+o+\"'\");throw f.code=\"MODULE_NOT_FOUND\",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require==\"function\"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})","/**\n * @file\n * @copyright  2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license    Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n *             Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\n\n/**\n * A Gist can retrieve and modify gists.\n */\nclass Gist extends Requestable {\n   /**\n    * Create a Gist.\n    * @param {string} id - the id of the gist (not required when creating a gist)\n    * @param {Requestable.auth} [auth] - information required to authenticate to Github\n    * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n    */\n   constructor(id, auth, apiBase) {\n      super(auth, apiBase);\n      this.__id = id;\n   }\n\n   /**\n    * Fetch a gist.\n    * @see https://developer.github.com/v3/gists/#get-a-single-gist\n    * @param {Requestable.callback} [cb] - will receive the gist\n    * @return {Promise} - the Promise for the http request\n    */\n   read(cb) {\n      return this._request('GET', `/gists/${this.__id}`, null, cb);\n   }\n\n   /**\n    * Create a new gist.\n    * @see https://developer.github.com/v3/gists/#create-a-gist\n    * @param {Object} gist - the data for the new gist\n    * @param {Requestable.callback} [cb] - will receive the new gist upon creation\n    * @return {Promise} - the Promise for the http request\n    */\n   create(gist, cb) {\n      return this._request('POST', '/gists', gist, cb)\n         .then((response) => {\n            this.__id = response.data.id;\n            return response;\n         });\n   }\n\n   /**\n    * Delete a gist.\n    * @see https://developer.github.com/v3/gists/#delete-a-gist\n    * @param {Requestable.callback} [cb] - will receive true if the request succeeds\n    * @return {Promise} - the Promise for the http request\n    */\n   delete(cb) {\n      return this._request('DELETE', `/gists/${this.__id}`, null, cb);\n   }\n\n   /**\n    * Fork a gist.\n    * @see https://developer.github.com/v3/gists/#fork-a-gist\n    * @param {Requestable.callback} [cb] - the function that will receive the gist\n    * @return {Promise} - the Promise for the http request\n    */\n   fork(cb) {\n      return this._request('POST', `/gists/${this.__id}/forks`, null, cb);\n   }\n\n   /**\n    * Update a gist.\n    * @see https://developer.github.com/v3/gists/#edit-a-gist\n    * @param {Object} gist - the new data for the gist\n    * @param {Requestable.callback} [cb] - the function that receives the API result\n    * @return {Promise} - the Promise for the http request\n    */\n   update(gist, cb) {\n      return this._request('PATCH', `/gists/${this.__id}`, gist, cb);\n   }\n\n   /**\n    * Star a gist.\n    * @see https://developer.github.com/v3/gists/#star-a-gist\n    * @param {Requestable.callback} [cb] - will receive true if the request is successful\n    * @return {Promise} - the Promise for the http request\n    */\n   star(cb) {\n      return this._request('PUT', `/gists/${this.__id}/star`, null, cb);\n   }\n\n   /**\n    * Unstar a gist.\n    * @see https://developer.github.com/v3/gists/#unstar-a-gist\n    * @param {Requestable.callback} [cb] - will receive true if the request is successful\n    * @return {Promise} - the Promise for the http request\n    */\n   unstar(cb) {\n      return this._request('DELETE', `/gists/${this.__id}/star`, null, cb);\n   }\n\n   /**\n    * Check if a gist is starred by the user.\n    * @see https://developer.github.com/v3/gists/#check-if-a-gist-is-starred\n    * @param {Requestable.callback} [cb] - will receive true if the gist is starred and false if the gist is not starred\n    * @return {Promise} - the Promise for the http request\n    */\n   isStarred(cb) {\n      return this._request204or404(`/gists/${this.__id}/star`, null, cb);\n   }\n\n   /**\n    * List the gist's commits\n    * @see https://developer.github.com/v3/gists/#list-gist-commits\n    * @param {Requestable.callback} [cb] - will receive the array of commits\n    * @return {Promise} - the Promise for the http request\n    */\n   listCommits(cb) {\n      return this._requestAllPages(`/gists/${this.__id}/commits`, null, cb);\n   }\n\n   /**\n    * Fetch one of the gist's revision.\n    * @see https://developer.github.com/v3/gists/#get-a-specific-revision-of-a-gist\n    * @param {string} revision - the id of the revision\n    * @param {Requestable.callback} [cb] - will receive the revision\n    * @return {Promise} - the Promise for the http request\n    */\n   getRevision(revision, cb) {\n      return this._request('GET', `/gists/${this.__id}/${revision}`, null, cb);\n   }\n\n   /**\n    * List the gist's comments\n    * @see https://developer.github.com/v3/gists/comments/#list-comments-on-a-gist\n    * @param {Requestable.callback} [cb] - will receive the array of comments\n    * @return {Promise} - the promise for the http request\n    */\n   listComments(cb) {\n      return this._requestAllPages(`/gists/${this.__id}/comments`, null, cb);\n   }\n\n   /**\n    * Fetch one of the gist's comments\n    * @see https://developer.github.com/v3/gists/comments/#get-a-single-comment\n    * @param {number} comment - the id of the comment\n    * @param {Requestable.callback} [cb] - will receive the comment\n    * @return {Promise} - the Promise for the http request\n    */\n   getComment(comment, cb) {\n      return this._request('GET', `/gists/${this.__id}/comments/${comment}`, null, cb);\n   }\n\n   /**\n    * Comment on a gist\n    * @see https://developer.github.com/v3/gists/comments/#create-a-comment\n    * @param {string} comment - the comment to add\n    * @param {Requestable.callback} [cb] - the function that receives the API result\n    * @return {Promise} - the Promise for the http request\n    */\n   createComment(comment, cb) {\n      return this._request('POST', `/gists/${this.__id}/comments`, {body: comment}, cb);\n   }\n\n   /**\n    * Edit a comment on the gist\n    * @see https://developer.github.com/v3/gists/comments/#edit-a-comment\n    * @param {number} comment - the id of the comment\n    * @param {string} body - the new comment\n    * @param {Requestable.callback} [cb] - will receive the modified comment\n    * @return {Promise} - the promise for the http request\n    */\n   editComment(comment, body, cb) {\n      return this._request('PATCH', `/gists/${this.__id}/comments/${comment}`, {body: body}, cb);\n   }\n\n   /**\n    * Delete a comment on the gist.\n    * @see https://developer.github.com/v3/gists/comments/#delete-a-comment\n    * @param {number} comment - the id of the comment\n    * @param {Requestable.callback} [cb] - will receive true if the request succeeds\n    * @return {Promise} - the Promise for the http request\n    */\n   deleteComment(comment, cb) {\n      return this._request('DELETE', `/gists/${this.__id}/comments/${comment}`, null, cb);\n   }\n}\n\nmodule.exports = Gist;\n","/**\n * @file\n * @copyright  2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license    Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n *             Github.js is freely distributable.\n */\n/* eslint valid-jsdoc: [\"error\", {\"requireReturnDescription\": false}] */\n\nimport Gist from './Gist';\nimport User from './User';\nimport Issue from './Issue';\nimport Search from './Search';\nimport RateLimit from './RateLimit';\nimport Repository from './Repository';\nimport Organization from './Organization';\nimport Team from './Team';\nimport Markdown from './Markdown';\nimport Project from './Project';\n\n/**\n * GitHub encapsulates the functionality to create various API wrapper objects.\n */\nclass GitHub {\n   /**\n    * Create a new GitHub.\n    * @param {Requestable.auth} [auth] - the credentials to authenticate to Github. If auth is\n    *                                  not provided requests will be made unauthenticated\n    * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n    */\n   constructor(auth, apiBase = 'https://api.github.com') {\n      this.__apiBase = apiBase;\n      this.__auth = auth || {};\n   }\n\n   /**\n    * Create a new Gist wrapper\n    * @param {number} [id] - the id for the gist, leave undefined when creating a new gist\n    * @return {Gist}\n    */\n   getGist(id) {\n      return new Gist(id, this.__auth, this.__apiBase);\n   }\n\n   /**\n    * Create a new User wrapper\n    * @param {string} [user] - the name of the user to get information about\n    *                        leave undefined for the authenticated user\n    * @return {User}\n    */\n   getUser(user) {\n      return new User(user, this.__auth, this.__apiBase);\n   }\n\n   /**\n    * Create a new Organization wrapper\n    * @param {string} organization - the name of the organization\n    * @return {Organization}\n    */\n   getOrganization(organization) {\n      return new Organization(organization, this.__auth, this.__apiBase);\n   }\n\n   /**\n    * create a new Team wrapper\n    * @param {string} teamId - the name of the team\n    * @return {team}\n    */\n   getTeam(teamId) {\n      return new Team(teamId, this.__auth, this.__apiBase);\n   }\n\n   /**\n    * Create a new Repository wrapper\n    * @param {string} user - the user who owns the respository\n    * @param {string} repo - the name of the repository\n    * @return {Repository}\n    */\n   getRepo(user, repo) {\n      return new Repository(this._getFullName(user, repo), this.__auth, this.__apiBase);\n   }\n\n   /**\n    * Create a new Issue wrapper\n    * @param {string} user - the user who owns the respository\n    * @param {string} repo - the name of the repository\n    * @return {Issue}\n    */\n   getIssues(user, repo) {\n      return new Issue(this._getFullName(user, repo), this.__auth, this.__apiBase);\n   }\n\n   /**\n    * Create a new Search wrapper\n    * @param {string} query - the query to search for\n    * @return {Search}\n    */\n   search(query) {\n      return new Search(query, this.__auth, this.__apiBase);\n   }\n\n   /**\n    * Create a new RateLimit wrapper\n    * @return {RateLimit}\n    */\n   getRateLimit() {\n      return new RateLimit(this.__auth, this.__apiBase);\n   }\n\n   /**\n    * Create a new Markdown wrapper\n    * @return {Markdown}\n    */\n   getMarkdown() {\n      return new Markdown(this.__auth, this.__apiBase);\n   }\n\n   /**\n    * Create a new Project wrapper\n    * @param {string} id - the id of the project\n    * @return {Markdown}\n    */\n   getProject(id) {\n      return new Project(id, this.__auth, this.__apiBase);\n   }\n\n   /**\n    * Computes the full repository name\n    * @param {string} user - the username (or the full name)\n    * @param {string} repo - the repository name, must not be passed if `user` is the full name\n    * @return {string} the repository's full name\n    */\n   _getFullName(user, repo) {\n      let fullname = user;\n\n      if (repo) {\n         fullname = `${user}/${repo}`;\n      }\n\n      return fullname;\n   }\n}\n\nmodule.exports = GitHub;\n","/**\n * @file\n * @copyright  2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license    Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n *             Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\n\n/**\n * Issue wraps the functionality to get issues for repositories\n */\nclass Issue extends Requestable {\n   /**\n    * Create a new Issue\n    * @param {string} repository - the full name of the repository (`:user/:repo`) to get issues for\n    * @param {Requestable.auth} [auth] - information required to authenticate to Github\n    * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n    */\n   constructor(repository, auth, apiBase) {\n      super(auth, apiBase);\n      this.__repository = repository;\n   }\n\n   /**\n    * Create a new issue\n    * @see https://developer.github.com/v3/issues/#create-an-issue\n    * @param {Object} issueData - the issue to create\n    * @param {Requestable.callback} [cb] - will receive the created issue\n    * @return {Promise} - the promise for the http request\n    */\n   createIssue(issueData, cb) {\n      return this._request('POST', `/repos/${this.__repository}/issues`, issueData, cb);\n   }\n\n   /**\n    * List the issues for the repository\n    * @see https://developer.github.com/v3/issues/#list-issues-for-a-repository\n    * @param {Object} options - filtering options\n    * @param {Requestable.callback} [cb] - will receive the array of issues\n    * @return {Promise} - the promise for the http request\n    */\n   listIssues(options, cb) {\n      return this._requestAllPages(`/repos/${this.__repository}/issues`, options, cb);\n   }\n\n   /**\n    * List the events for an issue\n    * @see https://developer.github.com/v3/issues/events/#list-events-for-an-issue\n    * @param {number} issue - the issue to get events for\n    * @param {Requestable.callback} [cb] - will receive the list of events\n    * @return {Promise} - the promise for the http request\n    */\n   listIssueEvents(issue, cb) {\n      return this._request('GET', `/repos/${this.__repository}/issues/${issue}/events`, null, cb);\n   }\n\n   /**\n    * List comments on an issue\n    * @see https://developer.github.com/v3/issues/comments/#list-comments-on-an-issue\n    * @param {number} issue - the id of the issue to get comments from\n    * @param {Requestable.callback} [cb] - will receive the comments\n    * @return {Promise} - the promise for the http request\n    */\n   listIssueComments(issue, cb) {\n      return this._request('GET', `/repos/${this.__repository}/issues/${issue}/comments`, null, cb);\n   }\n\n   /**\n    * Get a single comment on an issue\n    * @see https://developer.github.com/v3/issues/comments/#get-a-single-comment\n    * @param {number} id - the comment id to get\n    * @param {Requestable.callback} [cb] - will receive the comment\n    * @return {Promise} - the promise for the http request\n    */\n   getIssueComment(id, cb) {\n      return this._request('GET', `/repos/${this.__repository}/issues/comments/${id}`, null, cb);\n   }\n\n   /**\n    * Comment on an issue\n    * @see https://developer.github.com/v3/issues/comments/#create-a-comment\n    * @param {number} issue - the id of the issue to comment on\n    * @param {string} comment - the comment to add\n    * @param {Requestable.callback} [cb] - will receive the created comment\n    * @return {Promise} - the promise for the http request\n    */\n   createIssueComment(issue, comment, cb) {\n      return this._request('POST', `/repos/${this.__repository}/issues/${issue}/comments`, {body: comment}, cb);\n   }\n\n   /**\n    * Edit a comment on an issue\n    * @see https://developer.github.com/v3/issues/comments/#edit-a-comment\n    * @param {number} id - the comment id to edit\n    * @param {string} comment - the comment to edit\n    * @param {Requestable.callback} [cb] - will receive the edited comment\n    * @return {Promise} - the promise for the http request\n    */\n   editIssueComment(id, comment, cb) {\n      return this._request('PATCH', `/repos/${this.__repository}/issues/comments/${id}`, {body: comment}, cb);\n   }\n\n   /**\n    * Delete a comment on an issue\n    * @see https://developer.github.com/v3/issues/comments/#delete-a-comment\n    * @param {number} id - the comment id to delete\n    * @param {Requestable.callback} [cb] - will receive true if the request is successful\n    * @return {Promise} - the promise for the http request\n    */\n   deleteIssueComment(id, cb) {\n      return this._request('DELETE', `/repos/${this.__repository}/issues/comments/${id}`, null, cb);\n   }\n\n   /**\n    * Edit an issue\n    * @see https://developer.github.com/v3/issues/#edit-an-issue\n    * @param {number} issue - the issue number to edit\n    * @param {Object} issueData - the new issue data\n    * @param {Requestable.callback} [cb] - will receive the modified issue\n    * @return {Promise} - the promise for the http request\n    */\n   editIssue(issue, issueData, cb) {\n      return this._request('PATCH', `/repos/${this.__repository}/issues/${issue}`, issueData, cb);\n   }\n\n   /**\n    * Get a particular issue\n    * @see https://developer.github.com/v3/issues/#get-a-single-issue\n    * @param {number} issue - the issue number to fetch\n    * @param {Requestable.callback} [cb] - will receive the issue\n    * @return {Promise} - the promise for the http request\n    */\n   getIssue(issue, cb) {\n      return this._request('GET', `/repos/${this.__repository}/issues/${issue}`, null, cb);\n   }\n\n   /**\n    * List the milestones for the repository\n    * @see https://developer.github.com/v3/issues/milestones/#list-milestones-for-a-repository\n    * @param {Object} options - filtering options\n    * @param {Requestable.callback} [cb] - will receive the array of milestones\n    * @return {Promise} - the promise for the http request\n    */\n   listMilestones(options, cb) {\n      return this._request('GET', `/repos/${this.__repository}/milestones`, options, cb);\n   }\n\n   /**\n    * Get a milestone\n    * @see https://developer.github.com/v3/issues/milestones/#get-a-single-milestone\n    * @param {string} milestone - the id of the milestone to fetch\n    * @param {Requestable.callback} [cb] - will receive the milestone\n    * @return {Promise} - the promise for the http request\n    */\n   getMilestone(milestone, cb) {\n      return this._request('GET', `/repos/${this.__repository}/milestones/${milestone}`, null, cb);\n   }\n\n   /**\n    * Create a new milestone\n    * @see https://developer.github.com/v3/issues/milestones/#create-a-milestone\n    * @param {Object} milestoneData - the milestone definition\n    * @param {Requestable.callback} [cb] - will receive the milestone\n    * @return {Promise} - the promise for the http request\n    */\n   createMilestone(milestoneData, cb) {\n      return this._request('POST', `/repos/${this.__repository}/milestones`, milestoneData, cb);\n   }\n\n   /**\n    * Edit a milestone\n    * @see https://developer.github.com/v3/issues/milestones/#update-a-milestone\n    * @param {string} milestone - the id of the milestone to edit\n    * @param {Object} milestoneData - the updates to make to the milestone\n    * @param {Requestable.callback} [cb] - will receive the updated milestone\n    * @return {Promise} - the promise for the http request\n    */\n   editMilestone(milestone, milestoneData, cb) {\n      return this._request('PATCH', `/repos/${this.__repository}/milestones/${milestone}`, milestoneData, cb);\n   }\n\n   /**\n    * Delete a milestone (this is distinct from closing a milestone)\n    * @see https://developer.github.com/v3/issues/milestones/#delete-a-milestone\n    * @param {string} milestone - the id of the milestone to delete\n    * @param {Requestable.callback} [cb] - will receive the status\n    * @return {Promise} - the promise for the http request\n    */\n   deleteMilestone(milestone, cb) {\n      return this._request('DELETE', `/repos/${this.__repository}/milestones/${milestone}`, null, cb);\n   }\n\n   /**\n    * Create a new label\n    * @see https://developer.github.com/v3/issues/labels/#create-a-label\n    * @param {Object} labelData - the label definition\n    * @param {Requestable.callback} [cb] - will receive the object representing the label\n    * @return {Promise} - the promise for the http request\n    */\n   createLabel(labelData, cb) {\n      return this._request('POST', `/repos/${this.__repository}/labels`, labelData, cb);\n   }\n\n  /**\n   * List the labels for the repository\n   * @see https://developer.github.com/v3/issues/labels/#list-all-labels-for-this-repository\n   * @param {Object} options - filtering options\n   * @param {Requestable.callback} [cb] - will receive the array of labels\n   * @return {Promise} - the promise for the http request\n   */\n   listLabels(options, cb) {\n      return this._request('GET', `/repos/${this.__repository}/labels`, options, cb);\n   }\n\n  /**\n   * Get a label\n   * @see https://developer.github.com/v3/issues/labels/#get-a-single-label\n   * @param {string} label - the name of the label to fetch\n   * @param {Requestable.callback} [cb] - will receive the label\n   * @return {Promise} - the promise for the http request\n   */\n   getLabel(label, cb) {\n      return this._request('GET', `/repos/${this.__repository}/labels/${label}`, null, cb);\n   }\n\n  /**\n   * Edit a label\n   * @see https://developer.github.com/v3/issues/labels/#update-a-label\n   * @param {string} label - the name of the label to edit\n   * @param {Object} labelData - the updates to make to the label\n   * @param {Requestable.callback} [cb] - will receive the updated label\n   * @return {Promise} - the promise for the http request\n   */\n   editLabel(label, labelData, cb) {\n      return this._request('PATCH', `/repos/${this.__repository}/labels/${label}`, labelData, cb);\n   }\n\n  /**\n   * Delete a label\n   * @see https://developer.github.com/v3/issues/labels/#delete-a-label\n   * @param {string} label - the name of the label to delete\n   * @param {Requestable.callback} [cb] - will receive the status\n   * @return {Promise} - the promise for the http request\n   */\n   deleteLabel(label, cb) {\n      return this._request('DELETE', `/repos/${this.__repository}/labels/${label}`, null, cb);\n   }\n}\n\nmodule.exports = Issue;\n","/**\n * @file\n * @copyright  2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license    Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n *             Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\n\n/**\n * Renders html from Markdown text\n */\nclass Markdown extends Requestable {\n   /**\n    * construct a Markdown\n    * @param {Requestable.auth} auth - the credentials to authenticate to GitHub\n    * @param {string} [apiBase] - the base Github API URL\n    * @return {Promise} - the promise for the http request\n    */\n   constructor(auth, apiBase) {\n      super(auth, apiBase);\n   }\n\n   /**\n    * Render html from Markdown text.\n    * @see https://developer.github.com/v3/markdown/#render-an-arbitrary-markdown-document\n    * @param {Object} options - conversion options\n    * @param {string} [options.text] - the markdown text to convert\n    * @param {string} [options.mode=markdown] - can be either `markdown` or `gfm`\n    * @param {string} [options.context] - repository name if mode is gfm\n    * @param {Requestable.callback} [cb] - will receive the converted html\n    * @return {Promise} - the promise for the http request\n    */\n   render(options, cb) {\n      return this._request('POST', '/markdown', options, cb);\n   }\n}\n\nmodule.exports = Markdown;\n","/**\n * @file\n * @copyright  2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license    Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n *             Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\n\n/**\n * Organization encapsulates the functionality to create repositories in organizations\n */\nclass Organization extends Requestable {\n   /**\n    * Create a new Organization\n    * @param {string} organization - the name of the organization\n    * @param {Requestable.auth} [auth] - information required to authenticate to Github\n    * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n    */\n   constructor(organization, auth, apiBase) {\n      super(auth, apiBase);\n      this.__name = organization;\n   }\n\n   /**\n    * Create a repository in an organization\n    * @see https://developer.github.com/v3/repos/#create\n    * @param {Object} options - the repository definition\n    * @param {Requestable.callback} [cb] - will receive the created repository\n    * @return {Promise} - the promise for the http request\n    */\n   createRepo(options, cb) {\n      return this._request('POST', `/orgs/${this.__name}/repos`, options, cb);\n   }\n\n   /**\n    * List the repositories in an organization\n    * @see https://developer.github.com/v3/repos/#list-organization-repositories\n    * @param {Requestable.callback} [cb] - will receive the list of repositories\n    * @return {Promise} - the promise for the http request\n    */\n   getRepos(cb) {\n      let requestOptions = this._getOptionsWithDefaults({direction: 'desc'});\n\n      return this._requestAllPages(`/orgs/${this.__name}/repos`, requestOptions, cb);\n   }\n\n   /**\n    * Query if the user is a member or not\n    * @param {string} username - the user in question\n    * @param {Requestable.callback} [cb] - will receive true if the user is a member\n    * @return {Promise} - the promise for the http request\n    */\n   isMember(username, cb) {\n      return this._request204or404(`/orgs/${this.__name}/members/${username}`, null, cb);\n   }\n\n   /**\n    * List the users who are members of the company\n    * @see https://developer.github.com/v3/orgs/members/#members-list\n    * @param {object} options - filtering options\n    * @param {string} [options.filter=all] - can be either `2fa_disabled` or `all`\n    * @param {string} [options.role=all] - can be one of: `all`, `admin`, or `member`\n    * @param {Requestable.callback} [cb] - will receive the list of users\n    * @return {Promise} - the promise for the http request\n    */\n   listMembers(options, cb) {\n      return this._request('GET', `/orgs/${this.__name}/members`, options, cb);\n   }\n\n   /**\n    * List the Teams in the Organization\n    * @see https://developer.github.com/v3/orgs/teams/#list-teams\n    * @param {Requestable.callback} [cb] - will receive the list of teams\n    * @return {Promise} - the promise for the http request\n    */\n   getTeams(cb) {\n      return this._requestAllPages(`/orgs/${this.__name}/teams`, undefined, cb);\n   }\n\n   /**\n    * Create a team\n    * @see https://developer.github.com/v3/orgs/teams/#create-team\n    * @param {object} options - Team creation parameters\n    * @param {string} options.name - The name of the team\n    * @param {string} [options.description] - Team description\n    * @param {string} [options.repo_names] - Repos to add the team to\n    * @param {string} [options.privacy=secret] - The level of privacy the team should have. Can be either one\n    * of: `secret`, or `closed`\n    * @param {Requestable.callback} [cb] - will receive the created team\n    * @return {Promise} - the promise for the http request\n    */\n   createTeam(options, cb) {\n      return this._request('POST', `/orgs/${this.__name}/teams`, options, cb);\n   }\n\n   /**\n    * Get information about all projects\n    * @see https://developer.github.com/v3/projects/#list-organization-projects\n    * @param {Requestable.callback} [cb] - will receive the list of projects\n    * @return {Promise} - the promise for the http request\n    */\n   listProjects(cb) {\n      return this._requestAllPages(`/orgs/${this.__name}/projects`, {AcceptHeader: 'inertia-preview'}, cb);\n   }\n\n   /**\n    * Create a new project\n    * @see https://developer.github.com/v3/repos/projects/#create-a-project\n    * @param {Object} options - the description of the project\n    * @param {Requestable.callback} cb - will receive the newly created project\n    * @return {Promise} - the promise for the http request\n    */\n   createProject(options, cb) {\n      options = options || {};\n      options.AcceptHeader = 'inertia-preview';\n      return this._request('POST', `/orgs/${this.__name}/projects`, options, cb);\n   }\n}\n\nmodule.exports = Organization;\n","/**\n * @file\n * @copyright  2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license    Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n *             Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\n\n/**\n * Project encapsulates the functionality to create, query, and modify cards and columns.\n */\nclass Project extends Requestable {\n   /**\n    * Create a Project.\n    * @param {string} id - the id of the project\n    * @param {Requestable.auth} [auth] - information required to authenticate to Github\n    * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n    */\n   constructor(id, auth, apiBase) {\n      super(auth, apiBase, 'inertia-preview');\n      this.__id = id;\n   }\n\n   /**\n    * Get information about a project\n    * @see https://developer.github.com/v3/projects/#get-a-project\n    * @param {Requestable.callback} cb - will receive the project information\n    * @return {Promise} - the promise for the http request\n    */\n   getProject(cb) {\n      return this._request('GET', `/projects/${this.__id}`, null, cb);\n   }\n\n   /**\n    * Edit a project\n    * @see https://developer.github.com/v3/projects/#update-a-project\n    * @param {Object} options - the description of the project\n    * @param {Requestable.callback} cb - will receive the modified project\n    * @return {Promise} - the promise for the http request\n    */\n   updateProject(options, cb) {\n      return this._request('PATCH', `/projects/${this.__id}`, options, cb);\n   }\n\n   /**\n    * Delete a project\n    * @see https://developer.github.com/v3/projects/#delete-a-project\n    * @param {Requestable.callback} cb - will receive true if the operation is successful\n    * @return {Promise} - the promise for the http request\n    */\n   deleteProject(cb) {\n      return this._request('DELETE', `/projects/${this.__id}`, null, cb);\n   }\n\n   /**\n    * Get information about all columns of a project\n    * @see https://developer.github.com/v3/projects/columns/#list-project-columns\n    * @param {Requestable.callback} [cb] - will receive the list of columns\n    * @return {Promise} - the promise for the http request\n    */\n   listProjectColumns(cb) {\n      return this._requestAllPages(`/projects/${this.__id}/columns`, null, cb);\n   }\n\n   /**\n    * Get information about a column\n    * @see https://developer.github.com/v3/projects/columns/#get-a-project-column\n    * @param {string} colId - the id of the column\n    * @param {Requestable.callback} cb - will receive the column information\n    * @return {Promise} - the promise for the http request\n    */\n   getProjectColumn(colId, cb) {\n      return this._request('GET', `/projects/columns/${colId}`, null, cb);\n   }\n\n   /**\n    * Create a new column\n    * @see https://developer.github.com/v3/projects/columns/#create-a-project-column\n    * @param {Object} options - the description of the column\n    * @param {Requestable.callback} cb - will receive the newly created column\n    * @return {Promise} - the promise for the http request\n    */\n   createProjectColumn(options, cb) {\n      return this._request('POST', `/projects/${this.__id}/columns`, options, cb);\n   }\n\n   /**\n    * Edit a column\n    * @see https://developer.github.com/v3/projects/columns/#update-a-project-column\n    * @param {string} colId - the column id\n    * @param {Object} options - the description of the column\n    * @param {Requestable.callback} cb - will receive the modified column\n    * @return {Promise} - the promise for the http request\n    */\n   updateProjectColumn(colId, options, cb) {\n      return this._request('PATCH', `/projects/columns/${colId}`, options, cb);\n   }\n\n   /**\n    * Delete a column\n    * @see https://developer.github.com/v3/projects/columns/#delete-a-project-column\n    * @param {string} colId - the column to be deleted\n    * @param {Requestable.callback} cb - will receive true if the operation is successful\n    * @return {Promise} - the promise for the http request\n    */\n   deleteProjectColumn(colId, cb) {\n      return this._request('DELETE', `/projects/columns/${colId}`, null, cb);\n   }\n\n   /**\n    * Move a column\n    * @see https://developer.github.com/v3/projects/columns/#move-a-project-column\n    * @param {string} colId - the column to be moved\n    * @param {string} position - can be one of first, last, or after:<column-id>,\n    * where <column-id> is the id value of a column in the same project.\n    * @param {Requestable.callback} cb - will receive true if the operation is successful\n    * @return {Promise} - the promise for the http request\n    */\n   moveProjectColumn(colId, position, cb) {\n      return this._request(\n         'POST',\n         `/projects/columns/${colId}/moves`,\n         {position: position},\n         cb\n      );\n   }\n\n  /**\n   * Get information about all cards of a project\n   * @see https://developer.github.com/v3/projects/cards/#list-project-cards\n   * @param {Requestable.callback} [cb] - will receive the list of cards\n   * @return {Promise} - the promise for the http request\n   */\n   listProjectCards(cb) {\n      return this.listProjectColumns()\n        .then(({data}) => {\n           return Promise.all(data.map((column) => {\n              return this._requestAllPages(`/projects/columns/${column.id}/cards`, null);\n           }));\n        }).then((cardsInColumns) => {\n           const cards = cardsInColumns.reduce((prev, {data}) => {\n              prev.push(...data);\n              return prev;\n           }, []);\n           if (cb) {\n              cb(null, cards);\n           }\n           return cards;\n        }).catch((err) => {\n           if (cb) {\n              cb(err);\n              return;\n           }\n           throw err;\n        });\n   }\n\n   /**\n   * Get information about all cards of a column\n   * @see https://developer.github.com/v3/projects/cards/#list-project-cards\n   * @param {string} colId - the id of the column\n   * @param {Requestable.callback} [cb] - will receive the list of cards\n   * @return {Promise} - the promise for the http request\n   */\n   listColumnCards(colId, cb) {\n      return this._requestAllPages(`/projects/columns/${colId}/cards`, null, cb);\n   }\n\n   /**\n   * Get information about a card\n   * @see https://developer.github.com/v3/projects/cards/#get-a-project-card\n   * @param {string} cardId - the id of the card\n   * @param {Requestable.callback} cb - will receive the card information\n   * @return {Promise} - the promise for the http request\n   */\n   getProjectCard(cardId, cb) {\n      return this._request('GET', `/projects/columns/cards/${cardId}`, null, cb);\n   }\n\n   /**\n   * Create a new card\n   * @see https://developer.github.com/v3/projects/cards/#create-a-project-card\n   * @param {string} colId - the column id\n   * @param {Object} options - the description of the card\n   * @param {Requestable.callback} cb - will receive the newly created card\n   * @return {Promise} - the promise for the http request\n   */\n   createProjectCard(colId, options, cb) {\n      return this._request('POST', `/projects/columns/${colId}/cards`, options, cb);\n   }\n\n   /**\n   * Edit a card\n   * @see https://developer.github.com/v3/projects/cards/#update-a-project-card\n   * @param {string} cardId - the card id\n   * @param {Object} options - the description of the card\n   * @param {Requestable.callback} cb - will receive the modified card\n   * @return {Promise} - the promise for the http request\n   */\n   updateProjectCard(cardId, options, cb) {\n      return this._request('PATCH', `/projects/columns/cards/${cardId}`, options, cb);\n   }\n\n   /**\n   * Delete a card\n   * @see https://developer.github.com/v3/projects/cards/#delete-a-project-card\n   * @param {string} cardId - the card to be deleted\n   * @param {Requestable.callback} cb - will receive true if the operation is successful\n   * @return {Promise} - the promise for the http request\n   */\n   deleteProjectCard(cardId, cb) {\n      return this._request('DELETE', `/projects/columns/cards/${cardId}`, null, cb);\n   }\n\n   /**\n   * Move a card\n   * @see https://developer.github.com/v3/projects/cards/#move-a-project-card\n   * @param {string} cardId - the card to be moved\n   * @param {string} position - can be one of top, bottom, or after:<card-id>,\n   * where <card-id> is the id value of a card in the same project.\n   * @param {string} colId - the id value of a column in the same project.\n   * @param {Requestable.callback} cb - will receive true if the operation is successful\n   * @return {Promise} - the promise for the http request\n   */\n   moveProjectCard(cardId, position, colId, cb) {\n      return this._request(\n         'POST',\n         `/projects/columns/cards/${cardId}/moves`,\n         {position: position, column_id: colId}, // eslint-disable-line camelcase\n         cb\n      );\n   }\n}\n\nmodule.exports = Project;\n","/**\n * @file\n * @copyright  2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license    Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n *             Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\n\n/**\n * RateLimit allows users to query their rate-limit status\n */\nclass RateLimit extends Requestable {\n   /**\n    * construct a RateLimit\n    * @param {Requestable.auth} auth - the credentials to authenticate to GitHub\n    * @param {string} [apiBase] - the base Github API URL\n    * @return {Promise} - the promise for the http request\n    */\n   constructor(auth, apiBase) {\n      super(auth, apiBase);\n   }\n\n   /**\n    * Query the current rate limit\n    * @see https://developer.github.com/v3/rate_limit/\n    * @param {Requestable.callback} [cb] - will receive the rate-limit data\n    * @return {Promise} - the promise for the http request\n    */\n   getRateLimit(cb) {\n      return this._request('GET', '/rate_limit', null, cb);\n   }\n}\n\nmodule.exports = RateLimit;\n","/**\n * @file\n * @copyright  2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license    Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n *             Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\nimport Utf8 from 'utf8';\nimport {\n   Base64,\n} from 'js-base64';\nimport debug from 'debug';\nconst log = debug('github:repository');\n\n/**\n * Respository encapsulates the functionality to create, query, and modify files.\n */\nclass Repository extends Requestable {\n   /**\n    * Create a Repository.\n    * @param {string} fullname - the full name of the repository\n    * @param {Requestable.auth} [auth] - information required to authenticate to Github\n    * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n    */\n   constructor(fullname, auth, apiBase) {\n      super(auth, apiBase);\n      this.__fullname = fullname;\n      this.__currentTree = {\n         branch: null,\n         sha: null,\n      };\n   }\n\n   /**\n    * Get a reference\n    * @see https://developer.github.com/v3/git/refs/#get-a-reference\n    * @param {string} ref - the reference to get\n    * @param {Requestable.callback} [cb] - will receive the reference's refSpec or a list of refSpecs that match `ref`\n    * @return {Promise} - the promise for the http request\n    */\n   getRef(ref, cb) {\n      return this._request('GET', `/repos/${this.__fullname}/git/refs/${ref}`, null, cb);\n   }\n\n   /**\n    * Create a reference\n    * @see https://developer.github.com/v3/git/refs/#create-a-reference\n    * @param {Object} options - the object describing the ref\n    * @param {Requestable.callback} [cb] - will receive the ref\n    * @return {Promise} - the promise for the http request\n    */\n   createRef(options, cb) {\n      return this._request('POST', `/repos/${this.__fullname}/git/refs`, options, cb);\n   }\n\n   /**\n    * Delete a reference\n    * @see https://developer.github.com/v3/git/refs/#delete-a-reference\n    * @param {string} ref - the name of the ref to delte\n    * @param {Requestable.callback} [cb] - will receive true if the request is successful\n    * @return {Promise} - the promise for the http request\n    */\n   deleteRef(ref, cb) {\n      return this._request('DELETE', `/repos/${this.__fullname}/git/refs/${ref}`, null, cb);\n   }\n\n   /**\n    * Delete a repository\n    * @see https://developer.github.com/v3/repos/#delete-a-repository\n    * @param {Requestable.callback} [cb] - will receive true if the request is successful\n    * @return {Promise} - the promise for the http request\n    */\n   deleteRepo(cb) {\n      return this._request('DELETE', `/repos/${this.__fullname}`, null, cb);\n   }\n\n   /**\n    * List the tags on a repository\n    * @see https://developer.github.com/v3/repos/#list-tags\n    * @param {Requestable.callback} [cb] - will receive the tag data\n    * @return {Promise} - the promise for the http request\n    */\n   listTags(cb) {\n      return this._request('GET', `/repos/${this.__fullname}/tags`, null, cb);\n   }\n\n   /**\n    * List the open pull requests on the repository\n    * @see https://developer.github.com/v3/pulls/#list-pull-requests\n    * @param {Object} options - options to filter the search\n    * @param {Requestable.callback} [cb] - will receive the list of PRs\n    * @return {Promise} - the promise for the http request\n    */\n   listPullRequests(options, cb) {\n      options = options || {};\n      return this._request('GET', `/repos/${this.__fullname}/pulls`, options, cb);\n   }\n\n   /**\n    * Get information about a specific pull request\n    * @see https://developer.github.com/v3/pulls/#get-a-single-pull-request\n    * @param {number} number - the PR you wish to fetch\n    * @param {Requestable.callback} [cb] - will receive the PR from the API\n    * @return {Promise} - the promise for the http request\n    */\n   getPullRequest(number, cb) {\n      return this._request('GET', `/repos/${this.__fullname}/pulls/${number}`, null, cb);\n   }\n\n   /**\n    * List the files of a specific pull request\n    * @see https://developer.github.com/v3/pulls/#list-pull-requests-files\n    * @param {number|string} number - the PR you wish to fetch\n    * @param {Requestable.callback} [cb] - will receive the list of files from the API\n    * @return {Promise} - the promise for the http request\n    */\n   listPullRequestFiles(number, cb) {\n      return this._request('GET', `/repos/${this.__fullname}/pulls/${number}/files`, null, cb);\n   }\n\n   /**\n    * Compare two branches/commits/repositories\n    * @see https://developer.github.com/v3/repos/commits/#compare-two-commits\n    * @param {string} base - the base commit\n    * @param {string} head - the head commit\n    * @param {Requestable.callback} cb - will receive the comparison\n    * @return {Promise} - the promise for the http request\n    */\n   compareBranches(base, head, cb) {\n      return this._request('GET', `/repos/${this.__fullname}/compare/${base}...${head}`, null, cb);\n   }\n\n   /**\n    * List all the branches for the repository\n    * @see https://developer.github.com/v3/repos/#list-branches\n    * @param {Requestable.callback} cb - will receive the list of branches\n    * @return {Promise} - the promise for the http request\n    */\n   listBranches(cb) {\n      return this._request('GET', `/repos/${this.__fullname}/branches`, null, cb);\n   }\n\n   /**\n    * Get a raw blob from the repository\n    * @see https://developer.github.com/v3/git/blobs/#get-a-blob\n    * @param {string} sha - the sha of the blob to fetch\n    * @param {Requestable.callback} cb - will receive the blob from the API\n    * @return {Promise} - the promise for the http request\n    */\n   getBlob(sha, cb) {\n      return this._request('GET', `/repos/${this.__fullname}/git/blobs/${sha}`, null, cb, 'raw');\n   }\n\n   /**\n    * Get a single branch\n    * @see https://developer.github.com/v3/repos/branches/#get-branch\n    * @param {string} branch - the name of the branch to fetch\n    * @param {Requestable.callback} cb - will receive the branch from the API\n    * @returns {Promise} - the promise for the http request\n    */\n   getBranch(branch, cb) {\n      return this._request('GET', `/repos/${this.__fullname}/branches/${branch}`, null, cb);\n   }\n\n   /**\n    * Get a commit from the repository\n    * @see https://developer.github.com/v3/repos/commits/#get-a-single-commit\n    * @param {string} sha - the sha for the commit to fetch\n    * @param {Requestable.callback} cb - will receive the commit data\n    * @return {Promise} - the promise for the http request\n    */\n   getCommit(sha, cb) {\n      return this._request('GET', `/repos/${this.__fullname}/git/commits/${sha}`, null, cb);\n   }\n\n   /**\n    * List the commits on a repository, optionally filtering by path, author or time range\n    * @see https://developer.github.com/v3/repos/commits/#list-commits-on-a-repository\n    * @param {Object} [options] - the filtering options for commits\n    * @param {string} [options.sha] - the SHA or branch to start from\n    * @param {string} [options.path] - the path to search on\n    * @param {string} [options.author] - the commit author\n    * @param {(Date|string)} [options.since] - only commits after this date will be returned\n    * @param {(Date|string)} [options.until] - only commits before this date will be returned\n    * @param {Requestable.callback} cb - will receive the list of commits found matching the criteria\n    * @return {Promise} - the promise for the http request\n    */\n   listCommits(options, cb) {\n      options = options || {};\n\n      options.since = this._dateToISO(options.since);\n      options.until = this._dateToISO(options.until);\n\n      return this._request('GET', `/repos/${this.__fullname}/commits`, options, cb);\n   }\n\n    /**\n     * Gets a single commit information for a repository\n     * @see https://developer.github.com/v3/repos/commits/#get-a-single-commit\n     * @param {string} ref - the reference for the commit-ish\n     * @param {Requestable.callback} cb - will receive the commit information\n     * @return {Promise} - the promise for the http request\n     */\n   getSingleCommit(ref, cb) {\n      ref = ref || '';\n      return this._request('GET', `/repos/${this.__fullname}/commits/${ref}`, null, cb);\n   }\n\n   /**\n    * Get tha sha for a particular object in the repository. This is a convenience function\n    * @see https://developer.github.com/v3/repos/contents/#get-contents\n    * @param {string} [branch] - the branch to look in, or the repository's default branch if omitted\n    * @param {string} path - the path of the file or directory\n    * @param {Requestable.callback} cb - will receive a description of the requested object, including a `SHA` property\n    * @return {Promise} - the promise for the http request\n    */\n   getSha(branch, path, cb) {\n      branch = branch ? `?ref=${branch}` : '';\n      return this._request('GET', `/repos/${this.__fullname}/contents/${path}${branch}`, null, cb);\n   }\n\n   /**\n    * List the commit statuses for a particular sha, branch, or tag\n    * @see https://developer.github.com/v3/repos/statuses/#list-statuses-for-a-specific-ref\n    * @param {string} sha - the sha, branch, or tag to get statuses for\n    * @param {Requestable.callback} cb - will receive the list of statuses\n    * @return {Promise} - the promise for the http request\n    */\n   listStatuses(sha, cb) {\n      return this._request('GET', `/repos/${this.__fullname}/commits/${sha}/statuses`, null, cb);\n   }\n\n   /**\n    * Get a description of a git tree\n    * @see https://developer.github.com/v3/git/trees/#get-a-tree\n    * @param {string} treeSHA - the SHA of the tree to fetch\n    * @param {Requestable.callback} cb - will receive the callback data\n    * @return {Promise} - the promise for the http request\n    */\n   getTree(treeSHA, cb) {\n      return this._request('GET', `/repos/${this.__fullname}/git/trees/${treeSHA}`, null, cb);\n   }\n\n   /**\n    * Create a blob\n    * @see https://developer.github.com/v3/git/blobs/#create-a-blob\n    * @param {(string|Buffer|Blob)} content - the content to add to the repository\n    * @param {Requestable.callback} cb - will receive the details of the created blob\n    * @return {Promise} - the promise for the http request\n    */\n   createBlob(content, cb) {\n      let postBody = this._getContentObject(content);\n\n      log('sending content', postBody);\n      return this._request('POST', `/repos/${this.__fullname}/git/blobs`, postBody, cb);\n   }\n\n   /**\n    * Get the object that represents the provided content\n    * @param {string|Buffer|Blob} content - the content to send to the server\n    * @return {Object} the representation of `content` for the GitHub API\n    */\n   _getContentObject(content) {\n      if (typeof content === 'string') {\n         log('contet is a string');\n         return {\n            content: Utf8.encode(content),\n            encoding: 'utf-8',\n         };\n\n      } else if (typeof Buffer !== 'undefined' && content instanceof Buffer) {\n         log('We appear to be in Node');\n         return {\n            content: content.toString('base64'),\n            encoding: 'base64',\n         };\n\n      } else if (typeof Blob !== 'undefined' && content instanceof Blob) {\n         log('We appear to be in the browser');\n         return {\n            content: Base64.encode(content),\n            encoding: 'base64',\n         };\n\n      } else { // eslint-disable-line\n         log(`Not sure what this content is: ${typeof content}, ${JSON.stringify(content)}`);\n         throw new Error('Unknown content passed to postBlob. Must be string or Buffer (node) or Blob (web)');\n      }\n   }\n\n   /**\n    * Update a tree in Git\n    * @see https://developer.github.com/v3/git/trees/#create-a-tree\n    * @param {string} baseTreeSHA - the SHA of the tree to update\n    * @param {string} path - the path for the new file\n    * @param {string} blobSHA - the SHA for the blob to put at `path`\n    * @param {Requestable.callback} cb - will receive the new tree that is created\n    * @return {Promise} - the promise for the http request\n    * @deprecated use {@link Repository#createTree} instead\n    */\n   updateTree(baseTreeSHA, path, blobSHA, cb) {\n      let newTree = {\n         base_tree: baseTreeSHA, // eslint-disable-line\n         tree: [{\n            path: path,\n            sha: blobSHA,\n            mode: '100644',\n            type: 'blob',\n         }],\n      };\n\n      return this._request('POST', `/repos/${this.__fullname}/git/trees`, newTree, cb);\n   }\n\n   /**\n    * Create a new tree in git\n    * @see https://developer.github.com/v3/git/trees/#create-a-tree\n    * @param {Object} tree - the tree to create\n    * @param {string} baseSHA - the root sha of the tree\n    * @param {Requestable.callback} cb - will receive the new tree that is created\n    * @return {Promise} - the promise for the http request\n    */\n   createTree(tree, baseSHA, cb) {\n      return this._request('POST', `/repos/${this.__fullname}/git/trees`, {\n         tree,\n         base_tree: baseSHA, // eslint-disable-line camelcase\n      }, cb);\n   }\n\n   /**\n    * Add a commit to the repository\n    * @see https://developer.github.com/v3/git/commits/#create-a-commit\n    * @param {string} parent - the SHA of the parent commit\n    * @param {string} tree - the SHA of the tree for this commit\n    * @param {string} message - the commit message\n    * @param {Requestable.callback} cb - will receive the commit that is created\n    * @return {Promise} - the promise for the http request\n    */\n   commit(parent, tree, message, cb) {\n      let data = {\n         message,\n         tree,\n         parents: [parent],\n      };\n\n      return this._request('POST', `/repos/${this.__fullname}/git/commits`, data, cb)\n         .then((response) => {\n            this.__currentTree.sha = response.data.sha; // Update latest commit\n            return response;\n         });\n   }\n\n   /**\n    * Update a ref\n    * @see https://developer.github.com/v3/git/refs/#update-a-reference\n    * @param {string} ref - the ref to update\n    * @param {string} commitSHA - the SHA to point the reference to\n    * @param {boolean} force - indicates whether to force or ensure a fast-forward update\n    * @param {Requestable.callback} cb - will receive the updated ref back\n    * @return {Promise} - the promise for the http request\n    */\n   updateHead(ref, commitSHA, force, cb) {\n      return this._request('PATCH', `/repos/${this.__fullname}/git/refs/${ref}`, {\n         sha: commitSHA,\n         force: force,\n      }, cb);\n   }\n\n   /**\n    * Update commit status\n    * @see https://developer.github.com/v3/repos/statuses/\n    * @param {string} commitSHA - the SHA of the commit that should be updated\n    * @param {object} options - Commit status parameters\n    * @param {string} options.state - The state of the status. Can be one of: pending, success, error, or failure.\n    * @param {string} [options.target_url] - The target URL to associate with this status.\n    * @param {string} [options.description] - A short description of the status.\n    * @param {string} [options.context] - A string label to differentiate this status among CI systems.\n    * @param {Requestable.callback} cb - will receive the updated commit back\n    * @return {Promise} - the promise for the http request\n    */\n   updateStatus(commitSHA, options, cb) {\n      return this._request('POST', `/repos/${this.__fullname}/statuses/${commitSHA}`, options, cb);\n   }\n\n   /**\n    * Update repository information\n    * @see https://developer.github.com/v3/repos/#edit\n    * @param {object} options - New parameters that will be set to the repository\n    * @param {string} options.name - Name of the repository\n    * @param {string} [options.description] - A short description of the repository\n    * @param {string} [options.homepage] - A URL with more information about the repository\n    * @param {boolean} [options.private] - Either true to make the repository private, or false to make it public.\n    * @param {boolean} [options.has_issues] - Either true to enable issues for this repository, false to disable them.\n    * @param {boolean} [options.has_wiki] - Either true to enable the wiki for this repository, false to disable it.\n    * @param {boolean} [options.has_downloads] - Either true to enable downloads, false to disable them.\n    * @param {string} [options.default_branch] - Updates the default branch for this repository.\n    * @param {Requestable.callback} cb - will receive the updated repository back\n    * @return {Promise} - the promise for the http request\n    */\n   updateRepository(options, cb) {\n      return this._request('PATCH', `/repos/${this.__fullname}`, options, cb);\n   }\n\n  /**\n    * Get information about the repository\n    * @see https://developer.github.com/v3/repos/#get\n    * @param {Requestable.callback} cb - will receive the information about the repository\n    * @return {Promise} - the promise for the http request\n    */\n   getDetails(cb) {\n      return this._request('GET', `/repos/${this.__fullname}`, null, cb);\n   }\n\n   /**\n    * List the contributors to the repository\n    * @see https://developer.github.com/v3/repos/#list-contributors\n    * @param {Requestable.callback} cb - will receive the list of contributors\n    * @return {Promise} - the promise for the http request\n    */\n   getContributors(cb) {\n      return this._request('GET', `/repos/${this.__fullname}/contributors`, null, cb);\n   }\n\n   /**\n    * List the contributor stats to the repository\n    * @see https://developer.github.com/v3/repos/#list-contributors\n    * @param {Requestable.callback} cb - will receive the list of contributors\n    * @return {Promise} - the promise for the http request\n    */\n   getContributorStats(cb) {\n      return this._request('GET', `/repos/${this.__fullname}/stats/contributors`, null, cb);\n   }\n\n   /**\n    * List the users who are collaborators on the repository. The currently authenticated user must have\n    * push access to use this method\n    * @see https://developer.github.com/v3/repos/collaborators/#list-collaborators\n    * @param {Requestable.callback} cb - will receive the list of collaborators\n    * @return {Promise} - the promise for the http request\n    */\n   getCollaborators(cb) {\n      return this._request('GET', `/repos/${this.__fullname}/collaborators`, null, cb);\n   }\n\n   /**\n    * Check if a user is a collaborator on the repository\n    * @see https://developer.github.com/v3/repos/collaborators/#check-if-a-user-is-a-collaborator\n    * @param {string} username - the user to check\n    * @param {Requestable.callback} cb - will receive true if the user is a collaborator and false if they are not\n    * @return {Promise} - the promise for the http request {Boolean} [description]\n    */\n   isCollaborator(username, cb) {\n      return this._request('GET', `/repos/${this.__fullname}/collaborators/${username}`, null, cb);\n   }\n\n   /**\n    * Get the contents of a repository\n    * @see https://developer.github.com/v3/repos/contents/#get-contents\n    * @param {string} ref - the ref to check\n    * @param {string} path - the path containing the content to fetch\n    * @param {boolean} raw - `true` if the results should be returned raw instead of GitHub's normalized format\n    * @param {Requestable.callback} cb - will receive the fetched data\n    * @return {Promise} - the promise for the http request\n    */\n   getContents(ref, path, raw, cb) {\n      path = path ? `${encodeURI(path)}` : '';\n      return this._request('GET', `/repos/${this.__fullname}/contents/${path}`, {\n         ref,\n      }, cb, raw);\n   }\n\n   /**\n    * Get the README of a repository\n    * @see https://developer.github.com/v3/repos/contents/#get-the-readme\n    * @param {string} ref - the ref to check\n    * @param {boolean} raw - `true` if the results should be returned raw instead of GitHub's normalized format\n    * @param {Requestable.callback} cb - will receive the fetched data\n    * @return {Promise} - the promise for the http request\n    */\n   getReadme(ref, raw, cb) {\n      return this._request('GET', `/repos/${this.__fullname}/readme`, {\n         ref,\n      }, cb, raw);\n   }\n\n   /**\n    * Fork a repository\n    * @see https://developer.github.com/v3/repos/forks/#create-a-fork\n    * @param {Requestable.callback} cb - will receive the information about the newly created fork\n    * @return {Promise} - the promise for the http request\n    */\n   fork(cb) {\n      return this._request('POST', `/repos/${this.__fullname}/forks`, null, cb);\n   }\n\n   /**\n    * List a repository's forks\n    * @see https://developer.github.com/v3/repos/forks/#list-forks\n    * @param {Requestable.callback} cb - will receive the list of repositories forked from this one\n    * @return {Promise} - the promise for the http request\n    */\n   listForks(cb) {\n      return this._request('GET', `/repos/${this.__fullname}/forks`, null, cb);\n   }\n\n   /**\n    * Create a new branch from an existing branch.\n    * @param {string} [oldBranch=master] - the name of the existing branch\n    * @param {string} newBranch - the name of the new branch\n    * @param {Requestable.callback} cb - will receive the commit data for the head of the new branch\n    * @return {Promise} - the promise for the http request\n    */\n   createBranch(oldBranch, newBranch, cb) {\n      if (typeof newBranch === 'function') {\n         cb = newBranch;\n         newBranch = oldBranch;\n         oldBranch = 'master';\n      }\n\n      return this.getRef(`heads/${oldBranch}`)\n         .then((response) => {\n            let sha = response.data.object.sha;\n            return this.createRef({\n               sha,\n               ref: `refs/heads/${newBranch}`,\n            }, cb);\n         });\n   }\n\n   /**\n    * Create a new pull request\n    * @see https://developer.github.com/v3/pulls/#create-a-pull-request\n    * @param {Object} options - the pull request description\n    * @param {Requestable.callback} cb - will receive the new pull request\n    * @return {Promise} - the promise for the http request\n    */\n   createPullRequest(options, cb) {\n      return this._request('POST', `/repos/${this.__fullname}/pulls`, options, cb);\n   }\n\n   /**\n    * Update a pull request\n    * @see https://developer.github.com/v3/pulls/#update-a-pull-request\n    * @param {number|string} number - the number of the pull request to update\n    * @param {Object} options - the pull request description\n    * @param {Requestable.callback} [cb] - will receive the pull request information\n    * @return {Promise} - the promise for the http request\n    */\n   updatePullRequest(number, options, cb) {\n      return this._request('PATCH', `/repos/${this.__fullname}/pulls/${number}`, options, cb);\n   }\n\n   /**\n    * List the hooks for the repository\n    * @see https://developer.github.com/v3/repos/hooks/#list-hooks\n    * @param {Requestable.callback} cb - will receive the list of hooks\n    * @return {Promise} - the promise for the http request\n    */\n   listHooks(cb) {\n      return this._request('GET', `/repos/${this.__fullname}/hooks`, null, cb);\n   }\n\n   /**\n    * Get a hook for the repository\n    * @see https://developer.github.com/v3/repos/hooks/#get-single-hook\n    * @param {number} id - the id of the webook\n    * @param {Requestable.callback} cb - will receive the details of the webook\n    * @return {Promise} - the promise for the http request\n    */\n   getHook(id, cb) {\n      return this._request('GET', `/repos/${this.__fullname}/hooks/${id}`, null, cb);\n   }\n\n   /**\n    * Add a new hook to the repository\n    * @see https://developer.github.com/v3/repos/hooks/#create-a-hook\n    * @param {Object} options - the configuration describing the new hook\n    * @param {Requestable.callback} cb - will receive the new webhook\n    * @return {Promise} - the promise for the http request\n    */\n   createHook(options, cb) {\n      return this._request('POST', `/repos/${this.__fullname}/hooks`, options, cb);\n   }\n\n   /**\n    * Edit an existing webhook\n    * @see https://developer.github.com/v3/repos/hooks/#edit-a-hook\n    * @param {number} id - the id of the webhook\n    * @param {Object} options - the new description of the webhook\n    * @param {Requestable.callback} cb - will receive the updated webhook\n    * @return {Promise} - the promise for the http request\n    */\n   updateHook(id, options, cb) {\n      return this._request('PATCH', `/repos/${this.__fullname}/hooks/${id}`, options, cb);\n   }\n\n   /**\n    * Delete a webhook\n    * @see https://developer.github.com/v3/repos/hooks/#delete-a-hook\n    * @param {number} id - the id of the webhook to be deleted\n    * @param {Requestable.callback} cb - will receive true if the call is successful\n    * @return {Promise} - the promise for the http request\n    */\n   deleteHook(id, cb) {\n      return this._request('DELETE', `/repos/${this.__fullname}/hooks/${id}`, null, cb);\n   }\n\n   /**\n    * List the deploy keys for the repository\n    * @see https://developer.github.com/v3/repos/keys/#list-deploy-keys\n    * @param {Requestable.callback} cb - will receive the list of deploy keys\n    * @return {Promise} - the promise for the http request\n    */\n   listKeys(cb) {\n      return this._request('GET', `/repos/${this.__fullname}/keys`, null, cb);\n   }\n\n   /**\n    * Get a deploy key for the repository\n    * @see https://developer.github.com/v3/repos/keys/#get-a-deploy-key\n    * @param {number} id - the id of the deploy key\n    * @param {Requestable.callback} cb - will receive the details of the deploy key\n    * @return {Promise} - the promise for the http request\n    */\n   getKey(id, cb) {\n      return this._request('GET', `/repos/${this.__fullname}/keys/${id}`, null, cb);\n   }\n\n   /**\n    * Add a new deploy key to the repository\n    * @see https://developer.github.com/v3/repos/keys/#add-a-new-deploy-key\n    * @param {Object} options - the configuration describing the new deploy key\n    * @param {Requestable.callback} cb - will receive the new deploy key\n    * @return {Promise} - the promise for the http request\n    */\n   createKey(options, cb) {\n      return this._request('POST', `/repos/${this.__fullname}/keys`, options, cb);\n   }\n\n   /**\n    * Delete a deploy key\n    * @see https://developer.github.com/v3/repos/keys/#remove-a-deploy-key\n    * @param {number} id - the id of the deploy key to be deleted\n    * @param {Requestable.callback} cb - will receive true if the call is successful\n    * @return {Promise} - the promise for the http request\n    */\n   deleteKey(id, cb) {\n      return this._request('DELETE', `/repos/${this.__fullname}/keys/${id}`, null, cb);\n   }\n\n   /**\n    * Delete a file from a branch\n    * @see https://developer.github.com/v3/repos/contents/#delete-a-file\n    * @param {string} branch - the branch to delete from, or the default branch if not specified\n    * @param {string} path - the path of the file to remove\n    * @param {Requestable.callback} cb - will receive the commit in which the delete occurred\n    * @return {Promise} - the promise for the http request\n    */\n   deleteFile(branch, path, cb) {\n      return this.getSha(branch, path)\n         .then((response) => {\n            const deleteCommit = {\n               message: `Delete the file at '${path}'`,\n               sha: response.data.sha,\n               branch,\n            };\n            return this._request('DELETE', `/repos/${this.__fullname}/contents/${path}`, deleteCommit, cb);\n         });\n   }\n\n   /**\n    * Change all references in a repo from oldPath to new_path\n    * @param {string} branch - the branch to carry out the reference change, or the default branch if not specified\n    * @param {string} oldPath - original path\n    * @param {string} newPath - new reference path\n    * @param {Requestable.callback} cb - will receive the commit in which the move occurred\n    * @return {Promise} - the promise for the http request\n    */\n   move(branch, oldPath, newPath, cb) {\n      let oldSha;\n      return this.getRef(`heads/${branch}`)\n         .then(({data: {object}}) => this.getTree(`${object.sha}?recursive=true`))\n         .then(({data: {tree, sha}}) => {\n            oldSha = sha;\n            let newTree = tree.map((ref) => {\n               if (ref.path === oldPath) {\n                  ref.path = newPath;\n               }\n               if (ref.type === 'tree') {\n                  delete ref.sha;\n               }\n               return ref;\n            });\n            return this.createTree(newTree);\n         })\n         .then(({data: tree}) => this.commit(oldSha, tree.sha, `Renamed '${oldPath}' to '${newPath}'`))\n         .then(({data: commit}) => this.updateHead(`heads/${branch}`, commit.sha, true, cb));\n   }\n\n   /**\n    * Write a file to the repository\n    * @see https://developer.github.com/v3/repos/contents/#update-a-file\n    * @param {string} branch - the name of the branch\n    * @param {string} path - the path for the file\n    * @param {string} content - the contents of the file\n    * @param {string} message - the commit message\n    * @param {Object} [options] - commit options\n    * @param {Object} [options.author] - the author of the commit\n    * @param {Object} [options.commiter] - the committer\n    * @param {boolean} [options.encode] - true if the content should be base64 encoded\n    * @param {Requestable.callback} cb - will receive the new commit\n    * @return {Promise} - the promise for the http request\n    */\n   writeFile(branch, path, content, message, options, cb) {\n      if (typeof options === 'function') {\n         cb = options;\n         options = {};\n      }\n      let filePath = path ? encodeURI(path) : '';\n      let shouldEncode = options.encode !== false;\n      let commit = {\n         branch,\n         message,\n         author: options.author,\n         committer: options.committer,\n         content: shouldEncode ? Base64.encode(content) : content,\n      };\n\n      return this.getSha(branch, filePath)\n         .then((response) => {\n            commit.sha = response.data.sha;\n            return this._request('PUT', `/repos/${this.__fullname}/contents/${filePath}`, commit, cb);\n         }, () => {\n            return this._request('PUT', `/repos/${this.__fullname}/contents/${filePath}`, commit, cb);\n         });\n   }\n\n   /**\n    * Check if a repository is starred by you\n    * @see https://developer.github.com/v3/activity/starring/#check-if-you-are-starring-a-repository\n    * @param {Requestable.callback} cb - will receive true if the repository is starred and false if the repository\n    *                                  is not starred\n    * @return {Promise} - the promise for the http request {Boolean} [description]\n    */\n   isStarred(cb) {\n      return this._request204or404(`/user/starred/${this.__fullname}`, null, cb);\n   }\n\n   /**\n    * Star a repository\n    * @see https://developer.github.com/v3/activity/starring/#star-a-repository\n    * @param {Requestable.callback} cb - will receive true if the repository is starred\n    * @return {Promise} - the promise for the http request\n    */\n   star(cb) {\n      return this._request('PUT', `/user/starred/${this.__fullname}`, null, cb);\n   }\n\n   /**\n    * Unstar a repository\n    * @see https://developer.github.com/v3/activity/starring/#unstar-a-repository\n    * @param {Requestable.callback} cb - will receive true if the repository is unstarred\n    * @return {Promise} - the promise for the http request\n    */\n   unstar(cb) {\n      return this._request('DELETE', `/user/starred/${this.__fullname}`, null, cb);\n   }\n\n   /**\n    * Create a new release\n    * @see https://developer.github.com/v3/repos/releases/#create-a-release\n    * @param {Object} options - the description of the release\n    * @param {Requestable.callback} cb - will receive the newly created release\n    * @return {Promise} - the promise for the http request\n    */\n   createRelease(options, cb) {\n      return this._request('POST', `/repos/${this.__fullname}/releases`, options, cb);\n   }\n\n   /**\n    * Edit a release\n    * @see https://developer.github.com/v3/repos/releases/#edit-a-release\n    * @param {string} id - the id of the release\n    * @param {Object} options - the description of the release\n    * @param {Requestable.callback} cb - will receive the modified release\n    * @return {Promise} - the promise for the http request\n    */\n   updateRelease(id, options, cb) {\n      return this._request('PATCH', `/repos/${this.__fullname}/releases/${id}`, options, cb);\n   }\n\n   /**\n    * Get information about all releases\n    * @see https://developer.github.com/v3/repos/releases/#list-releases-for-a-repository\n    * @param {Requestable.callback} cb - will receive the release information\n    * @return {Promise} - the promise for the http request\n    */\n   listReleases(cb) {\n      return this._request('GET', `/repos/${this.__fullname}/releases`, null, cb);\n   }\n\n   /**\n    * Get information about a release\n    * @see https://developer.github.com/v3/repos/releases/#get-a-single-release\n    * @param {string} id - the id of the release\n    * @param {Requestable.callback} cb - will receive the release information\n    * @return {Promise} - the promise for the http request\n    */\n   getRelease(id, cb) {\n      return this._request('GET', `/repos/${this.__fullname}/releases/${id}`, null, cb);\n   }\n\n   /**\n    * Delete a release\n    * @see https://developer.github.com/v3/repos/releases/#delete-a-release\n    * @param {string} id - the release to be deleted\n    * @param {Requestable.callback} cb - will receive true if the operation is successful\n    * @return {Promise} - the promise for the http request\n    */\n   deleteRelease(id, cb) {\n      return this._request('DELETE', `/repos/${this.__fullname}/releases/${id}`, null, cb);\n   }\n\n   /**\n    * Merge a pull request\n    * @see https://developer.github.com/v3/pulls/#merge-a-pull-request-merge-button\n    * @param {number|string} number - the number of the pull request to merge\n    * @param {Object} options - the merge options for the pull request\n    * @param {Requestable.callback} [cb] - will receive the merge information if the operation is successful\n    * @return {Promise} - the promise for the http request\n    */\n   mergePullRequest(number, options, cb) {\n      return this._request('PUT', `/repos/${this.__fullname}/pulls/${number}/merge`, options, cb);\n   }\n\n   /**\n    * Get information about all projects\n    * @see https://developer.github.com/v3/projects/#list-repository-projects\n    * @param {Requestable.callback} [cb] - will receive the list of projects\n    * @return {Promise} - the promise for the http request\n    */\n   listProjects(cb) {\n      return this._requestAllPages(`/repos/${this.__fullname}/projects`, {AcceptHeader: 'inertia-preview'}, cb);\n   }\n\n   /**\n    * Create a new project\n    * @see https://developer.github.com/v3/projects/#create-a-repository-project\n    * @param {Object} options - the description of the project\n    * @param {Requestable.callback} cb - will receive the newly created project\n    * @return {Promise} - the promise for the http request\n    */\n   createProject(options, cb) {\n      options = options || {};\n      options.AcceptHeader = 'inertia-preview';\n      return this._request('POST', `/repos/${this.__fullname}/projects`, options, cb);\n   }\n\n}\n\nmodule.exports = Repository;\n","/**\n * @file\n * @copyright  2016 Yahoo Inc.\n * @license    Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n *             Github.js is freely distributable.\n */\n\nimport axios from 'axios';\nimport debug from 'debug';\nimport {Base64} from 'js-base64';\n\nconst log = debug('github:request');\n\n/**\n * The error structure returned when a network call fails\n */\nclass ResponseError extends Error {\n   /**\n    * Construct a new ResponseError\n    * @param {string} message - an message to return instead of the the default error message\n    * @param {string} path - the requested path\n    * @param {Object} response - the object returned by Axios\n    */\n   constructor(message, path, response) {\n      super(message);\n      this.path = path;\n      this.request = response.config;\n      this.response = (response || {}).response || response;\n      this.status = response.status;\n   }\n}\n\n/**\n * Requestable wraps the logic for making http requests to the API\n */\nclass Requestable {\n   /**\n    * Either a username and password or an oauth token for Github\n    * @typedef {Object} Requestable.auth\n    * @prop {string} [username] - the Github username\n    * @prop {string} [password] - the user's password\n    * @prop {token} [token] - an OAuth token\n    */\n   /**\n    * Initialize the http internals.\n    * @param {Requestable.auth} [auth] - the credentials to authenticate to Github. If auth is\n    *                                  not provided request will be made unauthenticated\n    * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n    * @param {string} [AcceptHeader=v3] - the accept header for the requests\n    */\n   constructor(auth, apiBase, AcceptHeader) {\n      this.__apiBase = apiBase || 'https://api.github.com';\n      this.__auth = {\n         token: auth.token,\n         username: auth.username,\n         password: auth.password,\n      };\n      this.__AcceptHeader = AcceptHeader || 'v3';\n\n      if (auth.token) {\n         this.__authorizationHeader = 'token ' + auth.token;\n      } else if (auth.username && auth.password) {\n         this.__authorizationHeader = 'Basic ' + Base64.encode(auth.username + ':' + auth.password);\n      }\n   }\n\n   /**\n    * Compute the URL to use to make a request.\n    * @private\n    * @param {string} path - either a URL relative to the API base or an absolute URL\n    * @return {string} - the URL to use\n    */\n   __getURL(path) {\n      let url = path;\n\n      if (path.indexOf('//') === -1) {\n         url = this.__apiBase + path;\n      }\n\n      let newCacheBuster = 'timestamp=' + new Date().getTime();\n      return url.replace(/(timestamp=\\d+)/, newCacheBuster);\n   }\n\n   /**\n    * Compute the headers required for an API request.\n    * @private\n    * @param {boolean} raw - if the request should be treated as JSON or as a raw request\n    * @param {string} AcceptHeader - the accept header for the request\n    * @return {Object} - the headers to use in the request\n    */\n   __getRequestHeaders(raw, AcceptHeader) {\n      let headers = {\n         'Content-Type': 'application/json;charset=UTF-8',\n         'Accept': 'application/vnd.github.' + (AcceptHeader || this.__AcceptHeader),\n      };\n\n      if (raw) {\n         headers.Accept += '.raw';\n      }\n      headers.Accept += '+json';\n\n      if (this.__authorizationHeader) {\n         headers.Authorization = this.__authorizationHeader;\n      }\n\n      return headers;\n   }\n\n   /**\n    * Sets the default options for API requests\n    * @protected\n    * @param {Object} [requestOptions={}] - the current options for the request\n    * @return {Object} - the options to pass to the request\n    */\n   _getOptionsWithDefaults(requestOptions = {}) {\n      if (!(requestOptions.visibility || requestOptions.affiliation)) {\n         requestOptions.type = requestOptions.type || 'all';\n      }\n      requestOptions.sort = requestOptions.sort || 'updated';\n      requestOptions.per_page = requestOptions.per_page || '100'; // eslint-disable-line\n\n      return requestOptions;\n   }\n\n   /**\n    * if a `Date` is passed to this function it will be converted to an ISO string\n    * @param {*} date - the object to attempt to cooerce into an ISO date string\n    * @return {string} - the ISO representation of `date` or whatever was passed in if it was not a date\n    */\n   _dateToISO(date) {\n      if (date && (date instanceof Date)) {\n         date = date.toISOString();\n      }\n\n      return date;\n   }\n\n   /**\n    * A function that receives the result of the API request.\n    * @callback Requestable.callback\n    * @param {Requestable.Error} error - the error returned by the API or `null`\n    * @param {(Object|true)} result - the data returned by the API or `true` if the API returns `204 No Content`\n    * @param {Object} request - the raw {@linkcode https://github.com/mzabriskie/axios#response-schema Response}\n    */\n   /**\n    * Make a request.\n    * @param {string} method - the method for the request (GET, PUT, POST, DELETE)\n    * @param {string} path - the path for the request\n    * @param {*} [data] - the data to send to the server. For HTTP methods that don't have a body the data\n    *                   will be sent as query parameters\n    * @param {Requestable.callback} [cb] - the callback for the request\n    * @param {boolean} [raw=false] - if the request should be sent as raw. If this is a falsy value then the\n    *                              request will be made as JSON\n    * @return {Promise} - the Promise for the http request\n    */\n   _request(method, path, data, cb, raw) {\n      const url = this.__getURL(path);\n\n      const AcceptHeader = (data || {}).AcceptHeader;\n      if (AcceptHeader) {\n         delete data.AcceptHeader;\n      }\n      const headers = this.__getRequestHeaders(raw, AcceptHeader);\n\n      let queryParams = {};\n\n      const shouldUseDataAsParams = data && (typeof data === 'object') && methodHasNoBody(method);\n      if (shouldUseDataAsParams) {\n         queryParams = data;\n         data = undefined;\n      }\n\n      const config = {\n         url: url,\n         method: method,\n         headers: headers,\n         params: queryParams,\n         data: data,\n         responseType: raw ? 'text' : 'json',\n      };\n\n      log(`${config.method} to ${config.url}`);\n      const requestPromise = axios(config).catch(callbackErrorOrThrow(cb, path));\n\n      if (cb) {\n         requestPromise.then((response) => {\n            if (response.data && Object.keys(response.data).length > 0) {\n               // When data has results\n               cb(null, response.data, response);\n            } else if (config.method !== 'GET' && Object.keys(response.data).length < 1) {\n               // True when successful submit a request and receive a empty object\n               cb(null, (response.status < 300), response);\n            } else {\n               cb(null, response.data, response);\n            }\n         });\n      }\n\n      return requestPromise;\n   }\n\n   /**\n    * Make a request to an endpoint the returns 204 when true and 404 when false\n    * @param {string} path - the path to request\n    * @param {Object} data - any query parameters for the request\n    * @param {Requestable.callback} cb - the callback that will receive `true` or `false`\n    * @param {method} [method=GET] - HTTP Method to use\n    * @return {Promise} - the promise for the http request\n    */\n   _request204or404(path, data, cb, method = 'GET') {\n      return this._request(method, path, data)\n         .then(function success(response) {\n            if (cb) {\n               cb(null, true, response);\n            }\n            return true;\n         }, function failure(response) {\n            if (response.response.status === 404) {\n               if (cb) {\n                  cb(null, false, response);\n               }\n               return false;\n            }\n\n            if (cb) {\n               cb(response);\n            }\n            throw response;\n         });\n   }\n\n   /**\n    * Make a request and fetch all the available data. Github will paginate responses so for queries\n    * that might span multiple pages this method is preferred to {@link Requestable#request}\n    * @param {string} path - the path to request\n    * @param {Object} options - the query parameters to include\n    * @param {Requestable.callback} [cb] - the function to receive the data. The returned data will always be an array.\n    * @param {Object[]} results - the partial results. This argument is intended for interal use only.\n    * @return {Promise} - a promise which will resolve when all pages have been fetched\n    * @deprecated This will be folded into {@link Requestable#_request} in the 2.0 release.\n    */\n   _requestAllPages(path, options, cb, results) {\n      results = results || [];\n\n      return this._request('GET', path, options)\n         .then((response) => {\n            let thisGroup;\n            if (response.data instanceof Array) {\n               thisGroup = response.data;\n            } else if (response.data.items instanceof Array) {\n               thisGroup = response.data.items;\n            } else {\n               let message = `cannot figure out how to append ${response.data} to the result set`;\n               throw new ResponseError(message, path, response);\n            }\n            results.push(...thisGroup);\n\n            const nextUrl = getNextPage(response.headers.link);\n            if (nextUrl && typeof options.page !== 'number') {\n               log(`getting next page: ${nextUrl}`);\n               return this._requestAllPages(nextUrl, options, cb, results);\n            }\n\n            if (cb) {\n               cb(null, results, response);\n            }\n\n            response.data = results;\n            return response;\n         }).catch(callbackErrorOrThrow(cb, path));\n   }\n}\n\nmodule.exports = Requestable;\n\n// ////////////////////////// //\n//  Private helper functions  //\n// ////////////////////////// //\nconst METHODS_WITH_NO_BODY = ['GET', 'HEAD', 'DELETE'];\nfunction methodHasNoBody(method) {\n   return METHODS_WITH_NO_BODY.indexOf(method) !== -1;\n}\n\nfunction getNextPage(linksHeader = '') {\n   const links = linksHeader.split(/\\s*,\\s*/); // splits and strips the urls\n   return links.reduce(function(nextUrl, link) {\n      if (link.search(/rel=\"next\"/) !== -1) {\n         return (link.match(/<(.*)>/) || [])[1];\n      }\n\n      return nextUrl;\n   }, undefined);\n}\n\nfunction callbackErrorOrThrow(cb, path) {\n   return function handler(object) {\n      let error;\n      if (object.hasOwnProperty('config')) {\n         const {response: {status, statusText}, config: {method, url}} = object;\n         let message = (`${status} error making request ${method} ${url}: \"${statusText}\"`);\n         error = new ResponseError(message, path, object);\n         log(`${message} ${JSON.stringify(object.data)}`);\n      } else {\n         error = object;\n      }\n      if (cb) {\n         log('going to error callback');\n         cb(error);\n      } else {\n         log('throwing error');\n         throw error;\n      }\n   };\n}\n","/**\n * @file\n * @copyright  2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license    Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n *             Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\nimport debug from 'debug';\nconst log = debug('github:search');\n\n/**\n * Wrap the Search API\n */\nclass Search extends Requestable {\n   /**\n    * Create a Search\n    * @param {Object} defaults - defaults for the search\n    * @param {Requestable.auth} [auth] - information required to authenticate to Github\n    * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n    */\n   constructor(defaults, auth, apiBase) {\n      super(auth, apiBase);\n      this.__defaults = this._getOptionsWithDefaults(defaults);\n   }\n\n   /**\n    * Available search options\n    * @see https://developer.github.com/v3/search/#parameters\n    * @typedef {Object} Search.Params\n    * @param {string} q - the query to make\n    * @param {string} sort - the sort field, one of `stars`, `forks`, or `updated`.\n    *                      Default is [best match](https://developer.github.com/v3/search/#ranking-search-results)\n    * @param {string} order - the ordering, either `asc` or `desc`\n    */\n   /**\n    * Perform a search on the GitHub API\n    * @private\n    * @param {string} path - the scope of the search\n    * @param {Search.Params} [withOptions] - additional parameters for the search\n    * @param {Requestable.callback} [cb] - will receive the results of the search\n    * @return {Promise} - the promise for the http request\n    */\n   _search(path, withOptions = {}, cb = undefined) {\n      let requestOptions = {};\n      Object.keys(this.__defaults).forEach((prop) => {\n         requestOptions[prop] = this.__defaults[prop];\n      });\n      Object.keys(withOptions).forEach((prop) => {\n         requestOptions[prop] = withOptions[prop];\n      });\n\n      log(`searching ${path} with options:`, requestOptions);\n      return this._requestAllPages(`/search/${path}`, requestOptions, cb);\n   }\n\n   /**\n    * Search for repositories\n    * @see https://developer.github.com/v3/search/#search-repositories\n    * @param {Search.Params} [options] - additional parameters for the search\n    * @param {Requestable.callback} [cb] - will receive the results of the search\n    * @return {Promise} - the promise for the http request\n    */\n   forRepositories(options, cb) {\n      return this._search('repositories', options, cb);\n   }\n\n   /**\n    * Search for code\n    * @see https://developer.github.com/v3/search/#search-code\n    * @param {Search.Params} [options] - additional parameters for the search\n    * @param {Requestable.callback} [cb] - will receive the results of the search\n    * @return {Promise} - the promise for the http request\n    */\n   forCode(options, cb) {\n      return this._search('code', options, cb);\n   }\n\n   /**\n    * Search for issues\n    * @see https://developer.github.com/v3/search/#search-issues\n    * @param {Search.Params} [options] - additional parameters for the search\n    * @param {Requestable.callback} [cb] - will receive the results of the search\n    * @return {Promise} - the promise for the http request\n    */\n   forIssues(options, cb) {\n      return this._search('issues', options, cb);\n   }\n\n   /**\n    * Search for users\n    * @see https://developer.github.com/v3/search/#search-users\n    * @param {Search.Params} [options] - additional parameters for the search\n    * @param {Requestable.callback} [cb] - will receive the results of the search\n    * @return {Promise} - the promise for the http request\n    */\n   forUsers(options, cb) {\n      return this._search('users', options, cb);\n   }\n}\n\nmodule.exports = Search;\n","/**\n * @file\n * @copyright  2016 Matt Smith (Development Seed)\n * @license    Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n *             Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\nimport debug from 'debug';\nconst log = debug('github:team');\n\n/**\n * A Team allows scoping of API requests to a particular Github Organization Team.\n */\nclass Team extends Requestable {\n   /**\n    * Create a Team.\n    * @param {string} [teamId] - the id for the team\n    * @param {Requestable.auth} [auth] - information required to authenticate to Github\n    * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n    */\n   constructor(teamId, auth, apiBase) {\n      super(auth, apiBase);\n      this.__teamId = teamId;\n   }\n\n   /**\n    * Get Team information\n    * @see https://developer.github.com/v3/orgs/teams/#get-team\n    * @param {Requestable.callback} [cb] - will receive the team\n    * @return {Promise} - the promise for the http request\n    */\n   getTeam(cb) {\n      log(`Fetching Team ${this.__teamId}`);\n      return this._request('Get', `/teams/${this.__teamId}`, undefined, cb);\n   }\n\n   /**\n    * List the Team's repositories\n    * @see https://developer.github.com/v3/orgs/teams/#list-team-repos\n    * @param {Requestable.callback} [cb] - will receive the list of repositories\n    * @return {Promise} - the promise for the http request\n    */\n   listRepos(cb) {\n      log(`Fetching repositories for Team ${this.__teamId}`);\n      return this._requestAllPages(`/teams/${this.__teamId}/repos`, undefined, cb);\n   }\n\n   /**\n    * Edit Team information\n    * @see https://developer.github.com/v3/orgs/teams/#edit-team\n    * @param {object} options - Parameters for team edit\n    * @param {string} options.name - The name of the team\n    * @param {string} [options.description] - Team description\n    * @param {string} [options.repo_names] - Repos to add the team to\n    * @param {string} [options.privacy=secret] - The level of privacy the team should have. Can be either one\n    * of: `secret`, or `closed`\n    * @param {Requestable.callback} [cb] - will receive the updated team\n    * @return {Promise} - the promise for the http request\n    */\n   editTeam(options, cb) {\n      log(`Editing Team ${this.__teamId}`);\n      return this._request('PATCH', `/teams/${this.__teamId}`, options, cb);\n   }\n\n   /**\n    * List the users who are members of the Team\n    * @see https://developer.github.com/v3/orgs/teams/#list-team-members\n    * @param {object} options - Parameters for listing team users\n    * @param {string} [options.role=all] - can be one of: `all`, `maintainer`, or `member`\n    * @param {Requestable.callback} [cb] - will receive the list of users\n    * @return {Promise} - the promise for the http request\n    */\n   listMembers(options, cb) {\n      log(`Getting members of Team ${this.__teamId}`);\n      return this._requestAllPages(`/teams/${this.__teamId}/members`, options, cb);\n   }\n\n   /**\n    * Get Team membership status for a user\n    * @see https://developer.github.com/v3/orgs/teams/#get-team-membership\n    * @param {string} username - can be one of: `all`, `maintainer`, or `member`\n    * @param {Requestable.callback} [cb] - will receive the membership status of a user\n    * @return {Promise} - the promise for the http request\n    */\n   getMembership(username, cb) {\n      log(`Getting membership of user ${username} in Team ${this.__teamId}`);\n      return this._request('GET', `/teams/${this.__teamId}/memberships/${username}`, undefined, cb);\n   }\n\n   /**\n    * Add a member to the Team\n    * @see https://developer.github.com/v3/orgs/teams/#add-team-membership\n    * @param {string} username - can be one of: `all`, `maintainer`, or `member`\n    * @param {object} options - Parameters for adding a team member\n    * @param {string} [options.role=member] - The role that this user should have in the team. Can be one\n    * of: `member`, or `maintainer`\n    * @param {Requestable.callback} [cb] - will receive the membership status of added user\n    * @return {Promise} - the promise for the http request\n    */\n   addMembership(username, options, cb) {\n      log(`Adding user ${username} to Team ${this.__teamId}`);\n      return this._request('PUT', `/teams/${this.__teamId}/memberships/${username}`, options, cb);\n   }\n\n   /**\n    * Get repo management status for team\n    * @see https://developer.github.com/v3/orgs/teams/#remove-team-membership\n    * @param {string} owner - Organization name\n    * @param {string} repo - Repo name\n    * @param {Requestable.callback} [cb] - will receive the membership status of added user\n    * @return {Promise} - the promise for the http request\n    */\n   isManagedRepo(owner, repo, cb) {\n      log(`Getting repo management by Team ${this.__teamId} for repo ${owner}/${repo}`);\n      return this._request204or404(`/teams/${this.__teamId}/repos/${owner}/${repo}`, undefined, cb);\n   }\n\n   /**\n    * Add or Update repo management status for team\n    * @see https://developer.github.com/v3/orgs/teams/#add-or-update-team-repository\n    * @param {string} owner - Organization name\n    * @param {string} repo - Repo name\n    * @param {object} options - Parameters for adding or updating repo management for the team\n    * @param {string} [options.permission] - The permission to grant the team on this repository. Can be one\n    * of: `pull`, `push`, or `admin`\n    * @param {Requestable.callback} [cb] - will receive the membership status of added user\n    * @return {Promise} - the promise for the http request\n    */\n   manageRepo(owner, repo, options, cb) {\n      log(`Adding or Updating repo management by Team ${this.__teamId} for repo ${owner}/${repo}`);\n      return this._request204or404(`/teams/${this.__teamId}/repos/${owner}/${repo}`, options, cb, 'PUT');\n   }\n\n   /**\n    * Remove repo management status for team\n    * @see https://developer.github.com/v3/orgs/teams/#remove-team-repository\n    * @param {string} owner - Organization name\n    * @param {string} repo - Repo name\n    * @param {Requestable.callback} [cb] - will receive the membership status of added user\n    * @return {Promise} - the promise for the http request\n    */\n   unmanageRepo(owner, repo, cb) {\n      log(`Remove repo management by Team ${this.__teamId} for repo ${owner}/${repo}`);\n      return this._request204or404(`/teams/${this.__teamId}/repos/${owner}/${repo}`, undefined, cb, 'DELETE');\n   }\n\n   /**\n    * Delete Team\n    * @see https://developer.github.com/v3/orgs/teams/#delete-team\n    * @param {Requestable.callback} [cb] - will receive the list of repositories\n    * @return {Promise} - the promise for the http request\n    */\n   deleteTeam(cb) {\n      log(`Deleting Team ${this.__teamId}`);\n      return this._request204or404(`/teams/${this.__teamId}`, undefined, cb, 'DELETE');\n   }\n}\n\nmodule.exports = Team;\n","/**\n * @file\n * @copyright  2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license    Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n *             Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\nimport debug from 'debug';\nconst log = debug('github:user');\n\n/**\n * A User allows scoping of API requests to a particular Github user.\n */\nclass User extends Requestable {\n   /**\n    * Create a User.\n    * @param {string} [username] - the user to use for user-scoped queries\n    * @param {Requestable.auth} [auth] - information required to authenticate to Github\n    * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n    */\n   constructor(username, auth, apiBase) {\n      super(auth, apiBase);\n      this.__user = username;\n   }\n\n   /**\n    * Get the url for the request. (dependent on if we're requesting for the authenticated user or not)\n    * @private\n    * @param {string} endpoint - the endpoint being requested\n    * @return {string} - the resolved endpoint\n    */\n   __getScopedUrl(endpoint) {\n      if (this.__user) {\n         return endpoint ?\n            `/users/${this.__user}/${endpoint}` :\n            `/users/${this.__user}`\n            ;\n\n      } else { // eslint-disable-line\n         switch (endpoint) {\n            case '':\n               return '/user';\n\n            case 'notifications':\n            case 'gists':\n               return `/${endpoint}`;\n\n            default:\n               return `/user/${endpoint}`;\n         }\n      }\n   }\n\n   /**\n    * List the user's repositories\n    * @see https://developer.github.com/v3/repos/#list-user-repositories\n    * @param {Object} [options={}] - any options to refine the search\n    * @param {Requestable.callback} [cb] - will receive the list of repositories\n    * @return {Promise} - the promise for the http request\n    */\n   listRepos(options, cb) {\n      if (typeof options === 'function') {\n         cb = options;\n         options = {};\n      }\n\n      options = this._getOptionsWithDefaults(options);\n\n      log(`Fetching repositories with options: ${JSON.stringify(options)}`);\n      return this._requestAllPages(this.__getScopedUrl('repos'), options, cb);\n   }\n\n   /**\n    * List the orgs that the user belongs to\n    * @see https://developer.github.com/v3/orgs/#list-user-organizations\n    * @param {Requestable.callback} [cb] - will receive the list of organizations\n    * @return {Promise} - the promise for the http request\n    */\n   listOrgs(cb) {\n      return this._request('GET', this.__getScopedUrl('orgs'), null, cb);\n   }\n\n   /**\n    * List the user's gists\n    * @see https://developer.github.com/v3/gists/#list-a-users-gists\n    * @param {Requestable.callback} [cb] - will receive the list of gists\n    * @return {Promise} - the promise for the http request\n    */\n   listGists(cb) {\n      return this._request('GET', this.__getScopedUrl('gists'), null, cb);\n   }\n\n   /**\n    * List the user's starred gists\n    * @see https://developer.github.com/v3/gists/#list-starred-gists\n    * @param {Requestable.callback} [cb] - will receive the list of gists\n    * @return {Promise} - the promise for the http request\n    */\n   listStarredGists(cb) {\n      return this._request('GET', this.__getScopedUrl('gists/starred'), null, cb);\n   }\n\n   /**\n    * List the user's notifications\n    * @see https://developer.github.com/v3/activity/notifications/#list-your-notifications\n    * @param {Object} [options={}] - any options to refine the search\n    * @param {Requestable.callback} [cb] - will receive the list of repositories\n    * @return {Promise} - the promise for the http request\n    */\n   listNotifications(options, cb) {\n      options = options || {};\n      if (typeof options === 'function') {\n         cb = options;\n         options = {};\n      }\n\n      options.since = this._dateToISO(options.since);\n      options.before = this._dateToISO(options.before);\n\n      return this._request('GET', this.__getScopedUrl('notifications'), options, cb);\n   }\n\n   /**\n    * Show the user's profile\n    * @see https://developer.github.com/v3/users/#get-a-single-user\n    * @param {Requestable.callback} [cb] - will receive the user's information\n    * @return {Promise} - the promise for the http request\n    */\n   getProfile(cb) {\n      return this._request('GET', this.__getScopedUrl(''), null, cb);\n   }\n\n   /**\n    * Gets the list of starred repositories for the user\n    * @see https://developer.github.com/v3/activity/starring/#list-repositories-being-starred\n    * @param {Requestable.callback} [cb] - will receive the list of starred repositories\n    * @return {Promise} - the promise for the http request\n    */\n   listStarredRepos(cb) {\n      let requestOptions = this._getOptionsWithDefaults();\n      return this._requestAllPages(this.__getScopedUrl('starred'), requestOptions, cb);\n   }\n\n   /**\n    * List email addresses for a user\n    * @see https://developer.github.com/v3/users/emails/#list-email-addresses-for-a-user\n    * @param {Requestable.callback} [cb] - will receive the list of emails\n    * @return {Promise} - the promise for the http request\n    */\n   getEmails(cb) {\n      return this._request('GET', '/user/emails', null, cb);\n   }\n\n   /**\n    * Have the authenticated user follow this user\n    * @see https://developer.github.com/v3/users/followers/#follow-a-user\n    * @param {string} username - the user to follow\n    * @param {Requestable.callback} [cb] - will receive true if the request succeeds\n    * @return {Promise} - the promise for the http request\n    */\n   follow(username, cb) {\n      return this._request('PUT', `/user/following/${this.__user}`, null, cb);\n   }\n\n   /**\n    * Have the currently authenticated user unfollow this user\n    * @see https://developer.github.com/v3/users/followers/#follow-a-user\n    * @param {string} username - the user to unfollow\n    * @param {Requestable.callback} [cb] - receives true if the request succeeds\n    * @return {Promise} - the promise for the http request\n    */\n   unfollow(username, cb) {\n      return this._request('DELETE', `/user/following/${this.__user}`, null, cb);\n   }\n\n   /**\n    * Create a new repository for the currently authenticated user\n    * @see https://developer.github.com/v3/repos/#create\n    * @param {object} options - the repository definition\n    * @param {Requestable.callback} [cb] - will receive the API response\n    * @return {Promise} - the promise for the http request\n    */\n   createRepo(options, cb) {\n      return this._request('POST', '/user/repos', options, cb);\n   }\n}\n\nmodule.exports = User;\n","module.exports = require('./lib/axios');","'use strict';\n\nvar utils = require('./../utils');\nvar settle = require('./../core/settle');\nvar buildURL = require('./../helpers/buildURL');\nvar parseHeaders = require('./../helpers/parseHeaders');\nvar isURLSameOrigin = require('./../helpers/isURLSameOrigin');\nvar createError = require('../core/createError');\nvar btoa = (typeof window !== 'undefined' && window.btoa && window.btoa.bind(window)) || require('./../helpers/btoa');\n\nmodule.exports = function xhrAdapter(config) {\n  return new Promise(function dispatchXhrRequest(resolve, reject) {\n    var requestData = config.data;\n    var requestHeaders = config.headers;\n\n    if (utils.isFormData(requestData)) {\n      delete requestHeaders['Content-Type']; // Let the browser set it\n    }\n\n    var request = new XMLHttpRequest();\n    var loadEvent = 'onreadystatechange';\n    var xDomain = false;\n\n    // For IE 8/9 CORS support\n    // Only supports POST and GET calls and doesn't returns the response headers.\n    // DON'T do this for testing b/c XMLHttpRequest is mocked, not XDomainRequest.\n    if (process.env.NODE_ENV !== 'test' &&\n        typeof window !== 'undefined' &&\n        window.XDomainRequest && !('withCredentials' in request) &&\n        !isURLSameOrigin(config.url)) {\n      request = new window.XDomainRequest();\n      loadEvent = 'onload';\n      xDomain = true;\n      request.onprogress = function handleProgress() {};\n      request.ontimeout = function handleTimeout() {};\n    }\n\n    // HTTP basic authentication\n    if (config.auth) {\n      var username = config.auth.username || '';\n      var password = config.auth.password || '';\n      requestHeaders.Authorization = 'Basic ' + btoa(username + ':' + password);\n    }\n\n    request.open(config.method.toUpperCase(), buildURL(config.url, config.params, config.paramsSerializer), true);\n\n    // Set the request timeout in MS\n    request.timeout = config.timeout;\n\n    // Listen for ready state\n    request[loadEvent] = function handleLoad() {\n      if (!request || (request.readyState !== 4 && !xDomain)) {\n        return;\n      }\n\n      // The request errored out and we didn't get a response, this will be\n      // handled by onerror instead\n      // With one exception: request that using file: protocol, most browsers\n      // will return status as 0 even though it's a successful request\n      if (request.status === 0 && !(request.responseURL && request.responseURL.indexOf('file:') === 0)) {\n        return;\n      }\n\n      // Prepare the response\n      var responseHeaders = 'getAllResponseHeaders' in request ? parseHeaders(request.getAllResponseHeaders()) : null;\n      var responseData = !config.responseType || config.responseType === 'text' ? request.responseText : request.response;\n      var response = {\n        data: responseData,\n        // IE sends 1223 instead of 204 (https://github.com/mzabriskie/axios/issues/201)\n        status: request.status === 1223 ? 204 : request.status,\n        statusText: request.status === 1223 ? 'No Content' : request.statusText,\n        headers: responseHeaders,\n        config: config,\n        request: request\n      };\n\n      settle(resolve, reject, response);\n\n      // Clean up request\n      request = null;\n    };\n\n    // Handle low level network errors\n    request.onerror = function handleError() {\n      // Real errors are hidden from us by the browser\n      // onerror should only fire if it's a network error\n      reject(createError('Network Error', config));\n\n      // Clean up request\n      request = null;\n    };\n\n    // Handle timeout\n    request.ontimeout = function handleTimeout() {\n      reject(createError('timeout of ' + config.timeout + 'ms exceeded', config, 'ECONNABORTED'));\n\n      // Clean up request\n      request = null;\n    };\n\n    // Add xsrf header\n    // This is only done if running in a standard browser environment.\n    // Specifically not if we're in a web worker, or react-native.\n    if (utils.isStandardBrowserEnv()) {\n      var cookies = require('./../helpers/cookies');\n\n      // Add xsrf header\n      var xsrfValue = (config.withCredentials || isURLSameOrigin(config.url)) && config.xsrfCookieName ?\n          cookies.read(config.xsrfCookieName) :\n          undefined;\n\n      if (xsrfValue) {\n        requestHeaders[config.xsrfHeaderName] = xsrfValue;\n      }\n    }\n\n    // Add headers to the request\n    if ('setRequestHeader' in request) {\n      utils.forEach(requestHeaders, function setRequestHeader(val, key) {\n        if (typeof requestData === 'undefined' && key.toLowerCase() === 'content-type') {\n          // Remove Content-Type if data is undefined\n          delete requestHeaders[key];\n        } else {\n          // Otherwise add header to the request\n          request.setRequestHeader(key, val);\n        }\n      });\n    }\n\n    // Add withCredentials to request if needed\n    if (config.withCredentials) {\n      request.withCredentials = true;\n    }\n\n    // Add responseType to request if needed\n    if (config.responseType) {\n      try {\n        request.responseType = config.responseType;\n      } catch (e) {\n        if (request.responseType !== 'json') {\n          throw e;\n        }\n      }\n    }\n\n    // Handle progress if needed\n    if (typeof config.onDownloadProgress === 'function') {\n      request.addEventListener('progress', config.onDownloadProgress);\n    }\n\n    // Not all browsers support upload events\n    if (typeof config.onUploadProgress === 'function' && request.upload) {\n      request.upload.addEventListener('progress', config.onUploadProgress);\n    }\n\n    if (config.cancelToken) {\n      // Handle cancellation\n      config.cancelToken.promise.then(function onCanceled(cancel) {\n        if (!request) {\n          return;\n        }\n\n        request.abort();\n        reject(cancel);\n        // Clean up request\n        request = null;\n      });\n    }\n\n    if (requestData === undefined) {\n      requestData = null;\n    }\n\n    // Send the request\n    request.send(requestData);\n  });\n};\n","'use strict';\n\nvar utils = require('./utils');\nvar bind = require('./helpers/bind');\nvar Axios = require('./core/Axios');\nvar defaults = require('./defaults');\n\n/**\n * Create an instance of Axios\n *\n * @param {Object} defaultConfig The default config for the instance\n * @return {Axios} A new instance of Axios\n */\nfunction createInstance(defaultConfig) {\n  var context = new Axios(defaultConfig);\n  var instance = bind(Axios.prototype.request, context);\n\n  // Copy axios.prototype to instance\n  utils.extend(instance, Axios.prototype, context);\n\n  // Copy context to instance\n  utils.extend(instance, context);\n\n  return instance;\n}\n\n// Create the default instance to be exported\nvar axios = createInstance(defaults);\n\n// Expose Axios class to allow class inheritance\naxios.Axios = Axios;\n\n// Factory for creating new instances\naxios.create = function create(instanceConfig) {\n  return createInstance(utils.merge(defaults, instanceConfig));\n};\n\n// Expose Cancel & CancelToken\naxios.Cancel = require('./cancel/Cancel');\naxios.CancelToken = require('./cancel/CancelToken');\naxios.isCancel = require('./cancel/isCancel');\n\n// Expose all/spread\naxios.all = function all(promises) {\n  return Promise.all(promises);\n};\naxios.spread = require('./helpers/spread');\n\nmodule.exports = axios;\n\n// Allow use of default import syntax in TypeScript\nmodule.exports.default = axios;\n","'use strict';\n\n/**\n * A `Cancel` is an object that is thrown when an operation is canceled.\n *\n * @class\n * @param {string=} message The message.\n */\nfunction Cancel(message) {\n  this.message = message;\n}\n\nCancel.prototype.toString = function toString() {\n  return 'Cancel' + (this.message ? ': ' + this.message : '');\n};\n\nCancel.prototype.__CANCEL__ = true;\n\nmodule.exports = Cancel;\n","'use strict';\n\nvar Cancel = require('./Cancel');\n\n/**\n * A `CancelToken` is an object that can be used to request cancellation of an operation.\n *\n * @class\n * @param {Function} executor The executor function.\n */\nfunction CancelToken(executor) {\n  if (typeof executor !== 'function') {\n    throw new TypeError('executor must be a function.');\n  }\n\n  var resolvePromise;\n  this.promise = new Promise(function promiseExecutor(resolve) {\n    resolvePromise = resolve;\n  });\n\n  var token = this;\n  executor(function cancel(message) {\n    if (token.reason) {\n      // Cancellation has already been requested\n      return;\n    }\n\n    token.reason = new Cancel(message);\n    resolvePromise(token.reason);\n  });\n}\n\n/**\n * Throws a `Cancel` if cancellation has been requested.\n */\nCancelToken.prototype.throwIfRequested = function throwIfRequested() {\n  if (this.reason) {\n    throw this.reason;\n  }\n};\n\n/**\n * Returns an object that contains a new `CancelToken` and a function that, when called,\n * cancels the `CancelToken`.\n */\nCancelToken.source = function source() {\n  var cancel;\n  var token = new CancelToken(function executor(c) {\n    cancel = c;\n  });\n  return {\n    token: token,\n    cancel: cancel\n  };\n};\n\nmodule.exports = CancelToken;\n","'use strict';\n\nmodule.exports = function isCancel(value) {\n  return !!(value && value.__CANCEL__);\n};\n","'use strict';\n\nvar defaults = require('./../defaults');\nvar utils = require('./../utils');\nvar InterceptorManager = require('./InterceptorManager');\nvar dispatchRequest = require('./dispatchRequest');\nvar isAbsoluteURL = require('./../helpers/isAbsoluteURL');\nvar combineURLs = require('./../helpers/combineURLs');\n\n/**\n * Create a new instance of Axios\n *\n * @param {Object} instanceConfig The default config for the instance\n */\nfunction Axios(instanceConfig) {\n  this.defaults = instanceConfig;\n  this.interceptors = {\n    request: new InterceptorManager(),\n    response: new InterceptorManager()\n  };\n}\n\n/**\n * Dispatch a request\n *\n * @param {Object} config The config specific for this request (merged with this.defaults)\n */\nAxios.prototype.request = function request(config) {\n  /*eslint no-param-reassign:0*/\n  // Allow for axios('example/url'[, config]) a la fetch API\n  if (typeof config === 'string') {\n    config = utils.merge({\n      url: arguments[0]\n    }, arguments[1]);\n  }\n\n  config = utils.merge(defaults, this.defaults, { method: 'get' }, config);\n\n  // Support baseURL config\n  if (config.baseURL && !isAbsoluteURL(config.url)) {\n    config.url = combineURLs(config.baseURL, config.url);\n  }\n\n  // Hook up interceptors middleware\n  var chain = [dispatchRequest, undefined];\n  var promise = Promise.resolve(config);\n\n  this.interceptors.request.forEach(function unshiftRequestInterceptors(interceptor) {\n    chain.unshift(interceptor.fulfilled, interceptor.rejected);\n  });\n\n  this.interceptors.response.forEach(function pushResponseInterceptors(interceptor) {\n    chain.push(interceptor.fulfilled, interceptor.rejected);\n  });\n\n  while (chain.length) {\n    promise = promise.then(chain.shift(), chain.shift());\n  }\n\n  return promise;\n};\n\n// Provide aliases for supported request methods\nutils.forEach(['delete', 'get', 'head'], function forEachMethodNoData(method) {\n  /*eslint func-names:0*/\n  Axios.prototype[method] = function(url, config) {\n    return this.request(utils.merge(config || {}, {\n      method: method,\n      url: url\n    }));\n  };\n});\n\nutils.forEach(['post', 'put', 'patch'], function forEachMethodWithData(method) {\n  /*eslint func-names:0*/\n  Axios.prototype[method] = function(url, data, config) {\n    return this.request(utils.merge(config || {}, {\n      method: method,\n      url: url,\n      data: data\n    }));\n  };\n});\n\nmodule.exports = Axios;\n","'use strict';\n\nvar utils = require('./../utils');\n\nfunction InterceptorManager() {\n  this.handlers = [];\n}\n\n/**\n * Add a new interceptor to the stack\n *\n * @param {Function} fulfilled The function to handle `then` for a `Promise`\n * @param {Function} rejected The function to handle `reject` for a `Promise`\n *\n * @return {Number} An ID used to remove interceptor later\n */\nInterceptorManager.prototype.use = function use(fulfilled, rejected) {\n  this.handlers.push({\n    fulfilled: fulfilled,\n    rejected: rejected\n  });\n  return this.handlers.length - 1;\n};\n\n/**\n * Remove an interceptor from the stack\n *\n * @param {Number} id The ID that was returned by `use`\n */\nInterceptorManager.prototype.eject = function eject(id) {\n  if (this.handlers[id]) {\n    this.handlers[id] = null;\n  }\n};\n\n/**\n * Iterate over all the registered interceptors\n *\n * This method is particularly useful for skipping over any\n * interceptors that may have become `null` calling `eject`.\n *\n * @param {Function} fn The function to call for each interceptor\n */\nInterceptorManager.prototype.forEach = function forEach(fn) {\n  utils.forEach(this.handlers, function forEachHandler(h) {\n    if (h !== null) {\n      fn(h);\n    }\n  });\n};\n\nmodule.exports = InterceptorManager;\n","'use strict';\n\nvar enhanceError = require('./enhanceError');\n\n/**\n * Create an Error with the specified message, config, error code, and response.\n *\n * @param {string} message The error message.\n * @param {Object} config The config.\n * @param {string} [code] The error code (for example, 'ECONNABORTED').\n @ @param {Object} [response] The response.\n * @returns {Error} The created error.\n */\nmodule.exports = function createError(message, config, code, response) {\n  var error = new Error(message);\n  return enhanceError(error, config, code, response);\n};\n","'use strict';\n\nvar utils = require('./../utils');\nvar transformData = require('./transformData');\nvar isCancel = require('../cancel/isCancel');\nvar defaults = require('../defaults');\n\n/**\n * Throws a `Cancel` if cancellation has been requested.\n */\nfunction throwIfCancellationRequested(config) {\n  if (config.cancelToken) {\n    config.cancelToken.throwIfRequested();\n  }\n}\n\n/**\n * Dispatch a request to the server using the configured adapter.\n *\n * @param {object} config The config that is to be used for the request\n * @returns {Promise} The Promise to be fulfilled\n */\nmodule.exports = function dispatchRequest(config) {\n  throwIfCancellationRequested(config);\n\n  // Ensure headers exist\n  config.headers = config.headers || {};\n\n  // Transform request data\n  config.data = transformData(\n    config.data,\n    config.headers,\n    config.transformRequest\n  );\n\n  // Flatten headers\n  config.headers = utils.merge(\n    config.headers.common || {},\n    config.headers[config.method] || {},\n    config.headers || {}\n  );\n\n  utils.forEach(\n    ['delete', 'get', 'head', 'post', 'put', 'patch', 'common'],\n    function cleanHeaderConfig(method) {\n      delete config.headers[method];\n    }\n  );\n\n  var adapter = config.adapter || defaults.adapter;\n\n  return adapter(config).then(function onAdapterResolution(response) {\n    throwIfCancellationRequested(config);\n\n    // Transform response data\n    response.data = transformData(\n      response.data,\n      response.headers,\n      config.transformResponse\n    );\n\n    return response;\n  }, function onAdapterRejection(reason) {\n    if (!isCancel(reason)) {\n      throwIfCancellationRequested(config);\n\n      // Transform response data\n      if (reason && reason.response) {\n        reason.response.data = transformData(\n          reason.response.data,\n          reason.response.headers,\n          config.transformResponse\n        );\n      }\n    }\n\n    return Promise.reject(reason);\n  });\n};\n","'use strict';\n\n/**\n * Update an Error with the specified config, error code, and response.\n *\n * @param {Error} error The error to update.\n * @param {Object} config The config.\n * @param {string} [code] The error code (for example, 'ECONNABORTED').\n @ @param {Object} [response] The response.\n * @returns {Error} The error.\n */\nmodule.exports = function enhanceError(error, config, code, response) {\n  error.config = config;\n  if (code) {\n    error.code = code;\n  }\n  error.response = response;\n  return error;\n};\n","'use strict';\n\nvar createError = require('./createError');\n\n/**\n * Resolve or reject a Promise based on response status.\n *\n * @param {Function} resolve A function that resolves the promise.\n * @param {Function} reject A function that rejects the promise.\n * @param {object} response The response.\n */\nmodule.exports = function settle(resolve, reject, response) {\n  var validateStatus = response.config.validateStatus;\n  // Note: status is not exposed by XDomainRequest\n  if (!response.status || !validateStatus || validateStatus(response.status)) {\n    resolve(response);\n  } else {\n    reject(createError(\n      'Request failed with status code ' + response.status,\n      response.config,\n      null,\n      response\n    ));\n  }\n};\n","'use strict';\n\nvar utils = require('./../utils');\n\n/**\n * Transform the data for a request or a response\n *\n * @param {Object|String} data The data to be transformed\n * @param {Array} headers The headers for the request or response\n * @param {Array|Function} fns A single function or Array of functions\n * @returns {*} The resulting transformed data\n */\nmodule.exports = function transformData(data, headers, fns) {\n  /*eslint no-param-reassign:0*/\n  utils.forEach(fns, function transform(fn) {\n    data = fn(data, headers);\n  });\n\n  return data;\n};\n","'use strict';\n\nvar utils = require('./utils');\nvar normalizeHeaderName = require('./helpers/normalizeHeaderName');\n\nvar PROTECTION_PREFIX = /^\\)\\]\\}',?\\n/;\nvar DEFAULT_CONTENT_TYPE = {\n  'Content-Type': 'application/x-www-form-urlencoded'\n};\n\nfunction setContentTypeIfUnset(headers, value) {\n  if (!utils.isUndefined(headers) && utils.isUndefined(headers['Content-Type'])) {\n    headers['Content-Type'] = value;\n  }\n}\n\nfunction getDefaultAdapter() {\n  var adapter;\n  if (typeof XMLHttpRequest !== 'undefined') {\n    // For browsers use XHR adapter\n    adapter = require('./adapters/xhr');\n  } else if (typeof process !== 'undefined') {\n    // For node use HTTP adapter\n    adapter = require('./adapters/http');\n  }\n  return adapter;\n}\n\nvar defaults = {\n  adapter: getDefaultAdapter(),\n\n  transformRequest: [function transformRequest(data, headers) {\n    normalizeHeaderName(headers, 'Content-Type');\n    if (utils.isFormData(data) ||\n      utils.isArrayBuffer(data) ||\n      utils.isStream(data) ||\n      utils.isFile(data) ||\n      utils.isBlob(data)\n    ) {\n      return data;\n    }\n    if (utils.isArrayBufferView(data)) {\n      return data.buffer;\n    }\n    if (utils.isURLSearchParams(data)) {\n      setContentTypeIfUnset(headers, 'application/x-www-form-urlencoded;charset=utf-8');\n      return data.toString();\n    }\n    if (utils.isObject(data)) {\n      setContentTypeIfUnset(headers, 'application/json;charset=utf-8');\n      return JSON.stringify(data);\n    }\n    return data;\n  }],\n\n  transformResponse: [function transformResponse(data) {\n    /*eslint no-param-reassign:0*/\n    if (typeof data === 'string') {\n      data = data.replace(PROTECTION_PREFIX, '');\n      try {\n        data = JSON.parse(data);\n      } catch (e) { /* Ignore */ }\n    }\n    return data;\n  }],\n\n  timeout: 0,\n\n  xsrfCookieName: 'XSRF-TOKEN',\n  xsrfHeaderName: 'X-XSRF-TOKEN',\n\n  maxContentLength: -1,\n\n  validateStatus: function validateStatus(status) {\n    return status >= 200 && status < 300;\n  }\n};\n\ndefaults.headers = {\n  common: {\n    'Accept': 'application/json, text/plain, */*'\n  }\n};\n\nutils.forEach(['delete', 'get', 'head'], function forEachMehtodNoData(method) {\n  defaults.headers[method] = {};\n});\n\nutils.forEach(['post', 'put', 'patch'], function forEachMethodWithData(method) {\n  defaults.headers[method] = utils.merge(DEFAULT_CONTENT_TYPE);\n});\n\nmodule.exports = defaults;\n","'use strict';\n\nmodule.exports = function bind(fn, thisArg) {\n  return function wrap() {\n    var args = new Array(arguments.length);\n    for (var i = 0; i < args.length; i++) {\n      args[i] = arguments[i];\n    }\n    return fn.apply(thisArg, args);\n  };\n};\n","'use strict';\n\n// btoa polyfill for IE<10 courtesy https://github.com/davidchambers/Base64.js\n\nvar chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=';\n\nfunction E() {\n  this.message = 'String contains an invalid character';\n}\nE.prototype = new Error;\nE.prototype.code = 5;\nE.prototype.name = 'InvalidCharacterError';\n\nfunction btoa(input) {\n  var str = String(input);\n  var output = '';\n  for (\n    // initialize result and counter\n    var block, charCode, idx = 0, map = chars;\n    // if the next str index does not exist:\n    //   change the mapping table to \"=\"\n    //   check if d has no fractional digits\n    str.charAt(idx | 0) || (map = '=', idx % 1);\n    // \"8 - idx % 1 * 8\" generates the sequence 2, 4, 6, 8\n    output += map.charAt(63 & block >> 8 - idx % 1 * 8)\n  ) {\n    charCode = str.charCodeAt(idx += 3 / 4);\n    if (charCode > 0xFF) {\n      throw new E();\n    }\n    block = block << 8 | charCode;\n  }\n  return output;\n}\n\nmodule.exports = btoa;\n","'use strict';\n\nvar utils = require('./../utils');\n\nfunction encode(val) {\n  return encodeURIComponent(val).\n    replace(/%40/gi, '@').\n    replace(/%3A/gi, ':').\n    replace(/%24/g, '$').\n    replace(/%2C/gi, ',').\n    replace(/%20/g, '+').\n    replace(/%5B/gi, '[').\n    replace(/%5D/gi, ']');\n}\n\n/**\n * Build a URL by appending params to the end\n *\n * @param {string} url The base of the url (e.g., http://www.google.com)\n * @param {object} [params] The params to be appended\n * @returns {string} The formatted url\n */\nmodule.exports = function buildURL(url, params, paramsSerializer) {\n  /*eslint no-param-reassign:0*/\n  if (!params) {\n    return url;\n  }\n\n  var serializedParams;\n  if (paramsSerializer) {\n    serializedParams = paramsSerializer(params);\n  } else if (utils.isURLSearchParams(params)) {\n    serializedParams = params.toString();\n  } else {\n    var parts = [];\n\n    utils.forEach(params, function serialize(val, key) {\n      if (val === null || typeof val === 'undefined') {\n        return;\n      }\n\n      if (utils.isArray(val)) {\n        key = key + '[]';\n      }\n\n      if (!utils.isArray(val)) {\n        val = [val];\n      }\n\n      utils.forEach(val, function parseValue(v) {\n        if (utils.isDate(v)) {\n          v = v.toISOString();\n        } else if (utils.isObject(v)) {\n          v = JSON.stringify(v);\n        }\n        parts.push(encode(key) + '=' + encode(v));\n      });\n    });\n\n    serializedParams = parts.join('&');\n  }\n\n  if (serializedParams) {\n    url += (url.indexOf('?') === -1 ? '?' : '&') + serializedParams;\n  }\n\n  return url;\n};\n","'use strict';\n\n/**\n * Creates a new URL by combining the specified URLs\n *\n * @param {string} baseURL The base URL\n * @param {string} relativeURL The relative URL\n * @returns {string} The combined URL\n */\nmodule.exports = function combineURLs(baseURL, relativeURL) {\n  return baseURL.replace(/\\/+$/, '') + '/' + relativeURL.replace(/^\\/+/, '');\n};\n","'use strict';\n\nvar utils = require('./../utils');\n\nmodule.exports = (\n  utils.isStandardBrowserEnv() ?\n\n  // Standard browser envs support document.cookie\n  (function standardBrowserEnv() {\n    return {\n      write: function write(name, value, expires, path, domain, secure) {\n        var cookie = [];\n        cookie.push(name + '=' + encodeURIComponent(value));\n\n        if (utils.isNumber(expires)) {\n          cookie.push('expires=' + new Date(expires).toGMTString());\n        }\n\n        if (utils.isString(path)) {\n          cookie.push('path=' + path);\n        }\n\n        if (utils.isString(domain)) {\n          cookie.push('domain=' + domain);\n        }\n\n        if (secure === true) {\n          cookie.push('secure');\n        }\n\n        document.cookie = cookie.join('; ');\n      },\n\n      read: function read(name) {\n        var match = document.cookie.match(new RegExp('(^|;\\\\s*)(' + name + ')=([^;]*)'));\n        return (match ? decodeURIComponent(match[3]) : null);\n      },\n\n      remove: function remove(name) {\n        this.write(name, '', Date.now() - 86400000);\n      }\n    };\n  })() :\n\n  // Non standard browser env (web workers, react-native) lack needed support.\n  (function nonStandardBrowserEnv() {\n    return {\n      write: function write() {},\n      read: function read() { return null; },\n      remove: function remove() {}\n    };\n  })()\n);\n","'use strict';\n\n/**\n * Determines whether the specified URL is absolute\n *\n * @param {string} url The URL to test\n * @returns {boolean} True if the specified URL is absolute, otherwise false\n */\nmodule.exports = function isAbsoluteURL(url) {\n  // A URL is considered absolute if it begins with \"<scheme>://\" or \"//\" (protocol-relative URL).\n  // RFC 3986 defines scheme name as a sequence of characters beginning with a letter and followed\n  // by any combination of letters, digits, plus, period, or hyphen.\n  return /^([a-z][a-z\\d\\+\\-\\.]*:)?\\/\\//i.test(url);\n};\n","'use strict';\n\nvar utils = require('./../utils');\n\nmodule.exports = (\n  utils.isStandardBrowserEnv() ?\n\n  // Standard browser envs have full support of the APIs needed to test\n  // whether the request URL is of the same origin as current location.\n  (function standardBrowserEnv() {\n    var msie = /(msie|trident)/i.test(navigator.userAgent);\n    var urlParsingNode = document.createElement('a');\n    var originURL;\n\n    /**\n    * Parse a URL to discover it's components\n    *\n    * @param {String} url The URL to be parsed\n    * @returns {Object}\n    */\n    function resolveURL(url) {\n      var href = url;\n\n      if (msie) {\n        // IE needs attribute set twice to normalize properties\n        urlParsingNode.setAttribute('href', href);\n        href = urlParsingNode.href;\n      }\n\n      urlParsingNode.setAttribute('href', href);\n\n      // urlParsingNode provides the UrlUtils interface - http://url.spec.whatwg.org/#urlutils\n      return {\n        href: urlParsingNode.href,\n        protocol: urlParsingNode.protocol ? urlParsingNode.protocol.replace(/:$/, '') : '',\n        host: urlParsingNode.host,\n        search: urlParsingNode.search ? urlParsingNode.search.replace(/^\\?/, '') : '',\n        hash: urlParsingNode.hash ? urlParsingNode.hash.replace(/^#/, '') : '',\n        hostname: urlParsingNode.hostname,\n        port: urlParsingNode.port,\n        pathname: (urlParsingNode.pathname.charAt(0) === '/') ?\n                  urlParsingNode.pathname :\n                  '/' + urlParsingNode.pathname\n      };\n    }\n\n    originURL = resolveURL(window.location.href);\n\n    /**\n    * Determine if a URL shares the same origin as the current location\n    *\n    * @param {String} requestURL The URL to test\n    * @returns {boolean} True if URL shares the same origin, otherwise false\n    */\n    return function isURLSameOrigin(requestURL) {\n      var parsed = (utils.isString(requestURL)) ? resolveURL(requestURL) : requestURL;\n      return (parsed.protocol === originURL.protocol &&\n            parsed.host === originURL.host);\n    };\n  })() :\n\n  // Non standard browser envs (web workers, react-native) lack needed support.\n  (function nonStandardBrowserEnv() {\n    return function isURLSameOrigin() {\n      return true;\n    };\n  })()\n);\n","'use strict';\n\nvar utils = require('../utils');\n\nmodule.exports = function normalizeHeaderName(headers, normalizedName) {\n  utils.forEach(headers, function processHeader(value, name) {\n    if (name !== normalizedName && name.toUpperCase() === normalizedName.toUpperCase()) {\n      headers[normalizedName] = value;\n      delete headers[name];\n    }\n  });\n};\n","'use strict';\n\nvar utils = require('./../utils');\n\n/**\n * Parse headers into an object\n *\n * ```\n * Date: Wed, 27 Aug 2014 08:58:49 GMT\n * Content-Type: application/json\n * Connection: keep-alive\n * Transfer-Encoding: chunked\n * ```\n *\n * @param {String} headers Headers needing to be parsed\n * @returns {Object} Headers parsed into an object\n */\nmodule.exports = function parseHeaders(headers) {\n  var parsed = {};\n  var key;\n  var val;\n  var i;\n\n  if (!headers) { return parsed; }\n\n  utils.forEach(headers.split('\\n'), function parser(line) {\n    i = line.indexOf(':');\n    key = utils.trim(line.substr(0, i)).toLowerCase();\n    val = utils.trim(line.substr(i + 1));\n\n    if (key) {\n      parsed[key] = parsed[key] ? parsed[key] + ', ' + val : val;\n    }\n  });\n\n  return parsed;\n};\n","'use strict';\n\n/**\n * Syntactic sugar for invoking a function and expanding an array for arguments.\n *\n * Common use case would be to use `Function.prototype.apply`.\n *\n *  ```js\n *  function f(x, y, z) {}\n *  var args = [1, 2, 3];\n *  f.apply(null, args);\n *  ```\n *\n * With `spread` this example can be re-written.\n *\n *  ```js\n *  spread(function(x, y, z) {})([1, 2, 3]);\n *  ```\n *\n * @param {Function} callback\n * @returns {Function}\n */\nmodule.exports = function spread(callback) {\n  return function wrap(arr) {\n    return callback.apply(null, arr);\n  };\n};\n","'use strict';\n\nvar bind = require('./helpers/bind');\n\n/*global toString:true*/\n\n// utils is a library of generic helper functions non-specific to axios\n\nvar toString = Object.prototype.toString;\n\n/**\n * Determine if a value is an Array\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if value is an Array, otherwise false\n */\nfunction isArray(val) {\n  return toString.call(val) === '[object Array]';\n}\n\n/**\n * Determine if a value is an ArrayBuffer\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if value is an ArrayBuffer, otherwise false\n */\nfunction isArrayBuffer(val) {\n  return toString.call(val) === '[object ArrayBuffer]';\n}\n\n/**\n * Determine if a value is a FormData\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if value is an FormData, otherwise false\n */\nfunction isFormData(val) {\n  return (typeof FormData !== 'undefined') && (val instanceof FormData);\n}\n\n/**\n * Determine if a value is a view on an ArrayBuffer\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if value is a view on an ArrayBuffer, otherwise false\n */\nfunction isArrayBufferView(val) {\n  var result;\n  if ((typeof ArrayBuffer !== 'undefined') && (ArrayBuffer.isView)) {\n    result = ArrayBuffer.isView(val);\n  } else {\n    result = (val) && (val.buffer) && (val.buffer instanceof ArrayBuffer);\n  }\n  return result;\n}\n\n/**\n * Determine if a value is a String\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if value is a String, otherwise false\n */\nfunction isString(val) {\n  return typeof val === 'string';\n}\n\n/**\n * Determine if a value is a Number\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if value is a Number, otherwise false\n */\nfunction isNumber(val) {\n  return typeof val === 'number';\n}\n\n/**\n * Determine if a value is undefined\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if the value is undefined, otherwise false\n */\nfunction isUndefined(val) {\n  return typeof val === 'undefined';\n}\n\n/**\n * Determine if a value is an Object\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if value is an Object, otherwise false\n */\nfunction isObject(val) {\n  return val !== null && typeof val === 'object';\n}\n\n/**\n * Determine if a value is a Date\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if value is a Date, otherwise false\n */\nfunction isDate(val) {\n  return toString.call(val) === '[object Date]';\n}\n\n/**\n * Determine if a value is a File\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if value is a File, otherwise false\n */\nfunction isFile(val) {\n  return toString.call(val) === '[object File]';\n}\n\n/**\n * Determine if a value is a Blob\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if value is a Blob, otherwise false\n */\nfunction isBlob(val) {\n  return toString.call(val) === '[object Blob]';\n}\n\n/**\n * Determine if a value is a Function\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if value is a Function, otherwise false\n */\nfunction isFunction(val) {\n  return toString.call(val) === '[object Function]';\n}\n\n/**\n * Determine if a value is a Stream\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if value is a Stream, otherwise false\n */\nfunction isStream(val) {\n  return isObject(val) && isFunction(val.pipe);\n}\n\n/**\n * Determine if a value is a URLSearchParams object\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if value is a URLSearchParams object, otherwise false\n */\nfunction isURLSearchParams(val) {\n  return typeof URLSearchParams !== 'undefined' && val instanceof URLSearchParams;\n}\n\n/**\n * Trim excess whitespace off the beginning and end of a string\n *\n * @param {String} str The String to trim\n * @returns {String} The String freed of excess whitespace\n */\nfunction trim(str) {\n  return str.replace(/^\\s*/, '').replace(/\\s*$/, '');\n}\n\n/**\n * Determine if we're running in a standard browser environment\n *\n * This allows axios to run in a web worker, and react-native.\n * Both environments support XMLHttpRequest, but not fully standard globals.\n *\n * web workers:\n *  typeof window -> undefined\n *  typeof document -> undefined\n *\n * react-native:\n *  typeof document.createElement -> undefined\n */\nfunction isStandardBrowserEnv() {\n  return (\n    typeof window !== 'undefined' &&\n    typeof document !== 'undefined' &&\n    typeof document.createElement === 'function'\n  );\n}\n\n/**\n * Iterate over an Array or an Object invoking a function for each item.\n *\n * If `obj` is an Array callback will be called passing\n * the value, index, and complete array for each item.\n *\n * If 'obj' is an Object callback will be called passing\n * the value, key, and complete object for each property.\n *\n * @param {Object|Array} obj The object to iterate\n * @param {Function} fn The callback to invoke for each item\n */\nfunction forEach(obj, fn) {\n  // Don't bother if no value provided\n  if (obj === null || typeof obj === 'undefined') {\n    return;\n  }\n\n  // Force an array if not already something iterable\n  if (typeof obj !== 'object' && !isArray(obj)) {\n    /*eslint no-param-reassign:0*/\n    obj = [obj];\n  }\n\n  if (isArray(obj)) {\n    // Iterate over array values\n    for (var i = 0, l = obj.length; i < l; i++) {\n      fn.call(null, obj[i], i, obj);\n    }\n  } else {\n    // Iterate over object keys\n    for (var key in obj) {\n      if (Object.prototype.hasOwnProperty.call(obj, key)) {\n        fn.call(null, obj[key], key, obj);\n      }\n    }\n  }\n}\n\n/**\n * Accepts varargs expecting each argument to be an object, then\n * immutably merges the properties of each object and returns result.\n *\n * When multiple objects contain the same key the later object in\n * the arguments list will take precedence.\n *\n * Example:\n *\n * ```js\n * var result = merge({foo: 123}, {foo: 456});\n * console.log(result.foo); // outputs 456\n * ```\n *\n * @param {Object} obj1 Object to merge\n * @returns {Object} Result of all merge properties\n */\nfunction merge(/* obj1, obj2, obj3, ... */) {\n  var result = {};\n  function assignValue(val, key) {\n    if (typeof result[key] === 'object' && typeof val === 'object') {\n      result[key] = merge(result[key], val);\n    } else {\n      result[key] = val;\n    }\n  }\n\n  for (var i = 0, l = arguments.length; i < l; i++) {\n    forEach(arguments[i], assignValue);\n  }\n  return result;\n}\n\n/**\n * Extends object a by mutably adding to it the properties of object b.\n *\n * @param {Object} a The object to be extended\n * @param {Object} b The object to copy properties from\n * @param {Object} thisArg The object to bind function to\n * @return {Object} The resulting value of object a\n */\nfunction extend(a, b, thisArg) {\n  forEach(b, function assignValue(val, key) {\n    if (thisArg && typeof val === 'function') {\n      a[key] = bind(val, thisArg);\n    } else {\n      a[key] = val;\n    }\n  });\n  return a;\n}\n\nmodule.exports = {\n  isArray: isArray,\n  isArrayBuffer: isArrayBuffer,\n  isFormData: isFormData,\n  isArrayBufferView: isArrayBufferView,\n  isString: isString,\n  isNumber: isNumber,\n  isObject: isObject,\n  isUndefined: isUndefined,\n  isDate: isDate,\n  isFile: isFile,\n  isBlob: isBlob,\n  isFunction: isFunction,\n  isStream: isStream,\n  isURLSearchParams: isURLSearchParams,\n  isStandardBrowserEnv: isStandardBrowserEnv,\n  forEach: forEach,\n  merge: merge,\n  extend: extend,\n  trim: trim\n};\n","'use strict'\n\nexports.byteLength = byteLength\nexports.toByteArray = toByteArray\nexports.fromByteArray = fromByteArray\n\nvar lookup = []\nvar revLookup = []\nvar Arr = typeof Uint8Array !== 'undefined' ? Uint8Array : Array\n\nvar code = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'\nfor (var i = 0, len = code.length; i < len; ++i) {\n  lookup[i] = code[i]\n  revLookup[code.charCodeAt(i)] = i\n}\n\nrevLookup['-'.charCodeAt(0)] = 62\nrevLookup['_'.charCodeAt(0)] = 63\n\nfunction placeHoldersCount (b64) {\n  var len = b64.length\n  if (len % 4 > 0) {\n    throw new Error('Invalid string. Length must be a multiple of 4')\n  }\n\n  // the number of equal signs (place holders)\n  // if there are two placeholders, than the two characters before it\n  // represent one byte\n  // if there is only one, then the three characters before it represent 2 bytes\n  // this is just a cheap hack to not do indexOf twice\n  return b64[len - 2] === '=' ? 2 : b64[len - 1] === '=' ? 1 : 0\n}\n\nfunction byteLength (b64) {\n  // base64 is 4/3 + up to two characters of the original data\n  return b64.length * 3 / 4 - placeHoldersCount(b64)\n}\n\nfunction toByteArray (b64) {\n  var i, j, l, tmp, placeHolders, arr\n  var len = b64.length\n  placeHolders = placeHoldersCount(b64)\n\n  arr = new Arr(len * 3 / 4 - placeHolders)\n\n  // if there are placeholders, only get up to the last complete 4 chars\n  l = placeHolders > 0 ? len - 4 : len\n\n  var L = 0\n\n  for (i = 0, j = 0; i < l; i += 4, j += 3) {\n    tmp = (revLookup[b64.charCodeAt(i)] << 18) | (revLookup[b64.charCodeAt(i + 1)] << 12) | (revLookup[b64.charCodeAt(i + 2)] << 6) | revLookup[b64.charCodeAt(i + 3)]\n    arr[L++] = (tmp >> 16) & 0xFF\n    arr[L++] = (tmp >> 8) & 0xFF\n    arr[L++] = tmp & 0xFF\n  }\n\n  if (placeHolders === 2) {\n    tmp = (revLookup[b64.charCodeAt(i)] << 2) | (revLookup[b64.charCodeAt(i + 1)] >> 4)\n    arr[L++] = tmp & 0xFF\n  } else if (placeHolders === 1) {\n    tmp = (revLookup[b64.charCodeAt(i)] << 10) | (revLookup[b64.charCodeAt(i + 1)] << 4) | (revLookup[b64.charCodeAt(i + 2)] >> 2)\n    arr[L++] = (tmp >> 8) & 0xFF\n    arr[L++] = tmp & 0xFF\n  }\n\n  return arr\n}\n\nfunction tripletToBase64 (num) {\n  return lookup[num >> 18 & 0x3F] + lookup[num >> 12 & 0x3F] + lookup[num >> 6 & 0x3F] + lookup[num & 0x3F]\n}\n\nfunction encodeChunk (uint8, start, end) {\n  var tmp\n  var output = []\n  for (var i = start; i < end; i += 3) {\n    tmp = (uint8[i] << 16) + (uint8[i + 1] << 8) + (uint8[i + 2])\n    output.push(tripletToBase64(tmp))\n  }\n  return output.join('')\n}\n\nfunction fromByteArray (uint8) {\n  var tmp\n  var len = uint8.length\n  var extraBytes = len % 3 // if we have 1 byte left, pad 2 bytes\n  var output = ''\n  var parts = []\n  var maxChunkLength = 16383 // must be multiple of 3\n\n  // go through the array every three bytes, we'll deal with trailing stuff later\n  for (var i = 0, len2 = len - extraBytes; i < len2; i += maxChunkLength) {\n    parts.push(encodeChunk(uint8, i, (i + maxChunkLength) > len2 ? len2 : (i + maxChunkLength)))\n  }\n\n  // pad the end with zeros, but make sure to not forget the extra bytes\n  if (extraBytes === 1) {\n    tmp = uint8[len - 1]\n    output += lookup[tmp >> 2]\n    output += lookup[(tmp << 4) & 0x3F]\n    output += '=='\n  } else if (extraBytes === 2) {\n    tmp = (uint8[len - 2] << 8) + (uint8[len - 1])\n    output += lookup[tmp >> 10]\n    output += lookup[(tmp >> 4) & 0x3F]\n    output += lookup[(tmp << 2) & 0x3F]\n    output += '='\n  }\n\n  parts.push(output)\n\n  return parts.join('')\n}\n","/*!\n * The buffer module from node.js, for the browser.\n *\n * @author   Feross Aboukhadijeh <feross@feross.org> <http://feross.org>\n * @license  MIT\n */\n/* eslint-disable no-proto */\n\n'use strict'\n\nvar base64 = require('base64-js')\nvar ieee754 = require('ieee754')\nvar isArray = require('isarray')\n\nexports.Buffer = Buffer\nexports.SlowBuffer = SlowBuffer\nexports.INSPECT_MAX_BYTES = 50\n\n/**\n * If `Buffer.TYPED_ARRAY_SUPPORT`:\n *   === true    Use Uint8Array implementation (fastest)\n *   === false   Use Object implementation (most compatible, even IE6)\n *\n * Browsers that support typed arrays are IE 10+, Firefox 4+, Chrome 7+, Safari 5.1+,\n * Opera 11.6+, iOS 4.2+.\n *\n * Due to various browser bugs, sometimes the Object implementation will be used even\n * when the browser supports typed arrays.\n *\n * Note:\n *\n *   - Firefox 4-29 lacks support for adding new properties to `Uint8Array` instances,\n *     See: https://bugzilla.mozilla.org/show_bug.cgi?id=695438.\n *\n *   - Chrome 9-10 is missing the `TypedArray.prototype.subarray` function.\n *\n *   - IE10 has a broken `TypedArray.prototype.subarray` function which returns arrays of\n *     incorrect length in some situations.\n\n * We detect these buggy browsers and set `Buffer.TYPED_ARRAY_SUPPORT` to `false` so they\n * get the Object implementation, which is slower but behaves correctly.\n */\nBuffer.TYPED_ARRAY_SUPPORT = global.TYPED_ARRAY_SUPPORT !== undefined\n  ? global.TYPED_ARRAY_SUPPORT\n  : typedArraySupport()\n\n/*\n * Export kMaxLength after typed array support is determined.\n */\nexports.kMaxLength = kMaxLength()\n\nfunction typedArraySupport () {\n  try {\n    var arr = new Uint8Array(1)\n    arr.__proto__ = {__proto__: Uint8Array.prototype, foo: function () { return 42 }}\n    return arr.foo() === 42 && // typed array instances can be augmented\n        typeof arr.subarray === 'function' && // chrome 9-10 lack `subarray`\n        arr.subarray(1, 1).byteLength === 0 // ie10 has broken `subarray`\n  } catch (e) {\n    return false\n  }\n}\n\nfunction kMaxLength () {\n  return Buffer.TYPED_ARRAY_SUPPORT\n    ? 0x7fffffff\n    : 0x3fffffff\n}\n\nfunction createBuffer (that, length) {\n  if (kMaxLength() < length) {\n    throw new RangeError('Invalid typed array length')\n  }\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    // Return an augmented `Uint8Array` instance, for best performance\n    that = new Uint8Array(length)\n    that.__proto__ = Buffer.prototype\n  } else {\n    // Fallback: Return an object instance of the Buffer class\n    if (that === null) {\n      that = new Buffer(length)\n    }\n    that.length = length\n  }\n\n  return that\n}\n\n/**\n * The Buffer constructor returns instances of `Uint8Array` that have their\n * prototype changed to `Buffer.prototype`. Furthermore, `Buffer` is a subclass of\n * `Uint8Array`, so the returned instances will have all the node `Buffer` methods\n * and the `Uint8Array` methods. Square bracket notation works as expected -- it\n * returns a single octet.\n *\n * The `Uint8Array` prototype remains unmodified.\n */\n\nfunction Buffer (arg, encodingOrOffset, length) {\n  if (!Buffer.TYPED_ARRAY_SUPPORT && !(this instanceof Buffer)) {\n    return new Buffer(arg, encodingOrOffset, length)\n  }\n\n  // Common case.\n  if (typeof arg === 'number') {\n    if (typeof encodingOrOffset === 'string') {\n      throw new Error(\n        'If encoding is specified then the first argument must be a string'\n      )\n    }\n    return allocUnsafe(this, arg)\n  }\n  return from(this, arg, encodingOrOffset, length)\n}\n\nBuffer.poolSize = 8192 // not used by this implementation\n\n// TODO: Legacy, not needed anymore. Remove in next major version.\nBuffer._augment = function (arr) {\n  arr.__proto__ = Buffer.prototype\n  return arr\n}\n\nfunction from (that, value, encodingOrOffset, length) {\n  if (typeof value === 'number') {\n    throw new TypeError('\"value\" argument must not be a number')\n  }\n\n  if (typeof ArrayBuffer !== 'undefined' && value instanceof ArrayBuffer) {\n    return fromArrayBuffer(that, value, encodingOrOffset, length)\n  }\n\n  if (typeof value === 'string') {\n    return fromString(that, value, encodingOrOffset)\n  }\n\n  return fromObject(that, value)\n}\n\n/**\n * Functionally equivalent to Buffer(arg, encoding) but throws a TypeError\n * if value is a number.\n * Buffer.from(str[, encoding])\n * Buffer.from(array)\n * Buffer.from(buffer)\n * Buffer.from(arrayBuffer[, byteOffset[, length]])\n **/\nBuffer.from = function (value, encodingOrOffset, length) {\n  return from(null, value, encodingOrOffset, length)\n}\n\nif (Buffer.TYPED_ARRAY_SUPPORT) {\n  Buffer.prototype.__proto__ = Uint8Array.prototype\n  Buffer.__proto__ = Uint8Array\n  if (typeof Symbol !== 'undefined' && Symbol.species &&\n      Buffer[Symbol.species] === Buffer) {\n    // Fix subarray() in ES2016. See: https://github.com/feross/buffer/pull/97\n    Object.defineProperty(Buffer, Symbol.species, {\n      value: null,\n      configurable: true\n    })\n  }\n}\n\nfunction assertSize (size) {\n  if (typeof size !== 'number') {\n    throw new TypeError('\"size\" argument must be a number')\n  } else if (size < 0) {\n    throw new RangeError('\"size\" argument must not be negative')\n  }\n}\n\nfunction alloc (that, size, fill, encoding) {\n  assertSize(size)\n  if (size <= 0) {\n    return createBuffer(that, size)\n  }\n  if (fill !== undefined) {\n    // Only pay attention to encoding if it's a string. This\n    // prevents accidentally sending in a number that would\n    // be interpretted as a start offset.\n    return typeof encoding === 'string'\n      ? createBuffer(that, size).fill(fill, encoding)\n      : createBuffer(that, size).fill(fill)\n  }\n  return createBuffer(that, size)\n}\n\n/**\n * Creates a new filled Buffer instance.\n * alloc(size[, fill[, encoding]])\n **/\nBuffer.alloc = function (size, fill, encoding) {\n  return alloc(null, size, fill, encoding)\n}\n\nfunction allocUnsafe (that, size) {\n  assertSize(size)\n  that = createBuffer(that, size < 0 ? 0 : checked(size) | 0)\n  if (!Buffer.TYPED_ARRAY_SUPPORT) {\n    for (var i = 0; i < size; ++i) {\n      that[i] = 0\n    }\n  }\n  return that\n}\n\n/**\n * Equivalent to Buffer(num), by default creates a non-zero-filled Buffer instance.\n * */\nBuffer.allocUnsafe = function (size) {\n  return allocUnsafe(null, size)\n}\n/**\n * Equivalent to SlowBuffer(num), by default creates a non-zero-filled Buffer instance.\n */\nBuffer.allocUnsafeSlow = function (size) {\n  return allocUnsafe(null, size)\n}\n\nfunction fromString (that, string, encoding) {\n  if (typeof encoding !== 'string' || encoding === '') {\n    encoding = 'utf8'\n  }\n\n  if (!Buffer.isEncoding(encoding)) {\n    throw new TypeError('\"encoding\" must be a valid string encoding')\n  }\n\n  var length = byteLength(string, encoding) | 0\n  that = createBuffer(that, length)\n\n  var actual = that.write(string, encoding)\n\n  if (actual !== length) {\n    // Writing a hex string, for example, that contains invalid characters will\n    // cause everything after the first invalid character to be ignored. (e.g.\n    // 'abxxcd' will be treated as 'ab')\n    that = that.slice(0, actual)\n  }\n\n  return that\n}\n\nfunction fromArrayLike (that, array) {\n  var length = array.length < 0 ? 0 : checked(array.length) | 0\n  that = createBuffer(that, length)\n  for (var i = 0; i < length; i += 1) {\n    that[i] = array[i] & 255\n  }\n  return that\n}\n\nfunction fromArrayBuffer (that, array, byteOffset, length) {\n  array.byteLength // this throws if `array` is not a valid ArrayBuffer\n\n  if (byteOffset < 0 || array.byteLength < byteOffset) {\n    throw new RangeError('\\'offset\\' is out of bounds')\n  }\n\n  if (array.byteLength < byteOffset + (length || 0)) {\n    throw new RangeError('\\'length\\' is out of bounds')\n  }\n\n  if (byteOffset === undefined && length === undefined) {\n    array = new Uint8Array(array)\n  } else if (length === undefined) {\n    array = new Uint8Array(array, byteOffset)\n  } else {\n    array = new Uint8Array(array, byteOffset, length)\n  }\n\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    // Return an augmented `Uint8Array` instance, for best performance\n    that = array\n    that.__proto__ = Buffer.prototype\n  } else {\n    // Fallback: Return an object instance of the Buffer class\n    that = fromArrayLike(that, array)\n  }\n  return that\n}\n\nfunction fromObject (that, obj) {\n  if (Buffer.isBuffer(obj)) {\n    var len = checked(obj.length) | 0\n    that = createBuffer(that, len)\n\n    if (that.length === 0) {\n      return that\n    }\n\n    obj.copy(that, 0, 0, len)\n    return that\n  }\n\n  if (obj) {\n    if ((typeof ArrayBuffer !== 'undefined' &&\n        obj.buffer instanceof ArrayBuffer) || 'length' in obj) {\n      if (typeof obj.length !== 'number' || isnan(obj.length)) {\n        return createBuffer(that, 0)\n      }\n      return fromArrayLike(that, obj)\n    }\n\n    if (obj.type === 'Buffer' && isArray(obj.data)) {\n      return fromArrayLike(that, obj.data)\n    }\n  }\n\n  throw new TypeError('First argument must be a string, Buffer, ArrayBuffer, Array, or array-like object.')\n}\n\nfunction checked (length) {\n  // Note: cannot use `length < kMaxLength()` here because that fails when\n  // length is NaN (which is otherwise coerced to zero.)\n  if (length >= kMaxLength()) {\n    throw new RangeError('Attempt to allocate Buffer larger than maximum ' +\n                         'size: 0x' + kMaxLength().toString(16) + ' bytes')\n  }\n  return length | 0\n}\n\nfunction SlowBuffer (length) {\n  if (+length != length) { // eslint-disable-line eqeqeq\n    length = 0\n  }\n  return Buffer.alloc(+length)\n}\n\nBuffer.isBuffer = function isBuffer (b) {\n  return !!(b != null && b._isBuffer)\n}\n\nBuffer.compare = function compare (a, b) {\n  if (!Buffer.isBuffer(a) || !Buffer.isBuffer(b)) {\n    throw new TypeError('Arguments must be Buffers')\n  }\n\n  if (a === b) return 0\n\n  var x = a.length\n  var y = b.length\n\n  for (var i = 0, len = Math.min(x, y); i < len; ++i) {\n    if (a[i] !== b[i]) {\n      x = a[i]\n      y = b[i]\n      break\n    }\n  }\n\n  if (x < y) return -1\n  if (y < x) return 1\n  return 0\n}\n\nBuffer.isEncoding = function isEncoding (encoding) {\n  switch (String(encoding).toLowerCase()) {\n    case 'hex':\n    case 'utf8':\n    case 'utf-8':\n    case 'ascii':\n    case 'latin1':\n    case 'binary':\n    case 'base64':\n    case 'ucs2':\n    case 'ucs-2':\n    case 'utf16le':\n    case 'utf-16le':\n      return true\n    default:\n      return false\n  }\n}\n\nBuffer.concat = function concat (list, length) {\n  if (!isArray(list)) {\n    throw new TypeError('\"list\" argument must be an Array of Buffers')\n  }\n\n  if (list.length === 0) {\n    return Buffer.alloc(0)\n  }\n\n  var i\n  if (length === undefined) {\n    length = 0\n    for (i = 0; i < list.length; ++i) {\n      length += list[i].length\n    }\n  }\n\n  var buffer = Buffer.allocUnsafe(length)\n  var pos = 0\n  for (i = 0; i < list.length; ++i) {\n    var buf = list[i]\n    if (!Buffer.isBuffer(buf)) {\n      throw new TypeError('\"list\" argument must be an Array of Buffers')\n    }\n    buf.copy(buffer, pos)\n    pos += buf.length\n  }\n  return buffer\n}\n\nfunction byteLength (string, encoding) {\n  if (Buffer.isBuffer(string)) {\n    return string.length\n  }\n  if (typeof ArrayBuffer !== 'undefined' && typeof ArrayBuffer.isView === 'function' &&\n      (ArrayBuffer.isView(string) || string instanceof ArrayBuffer)) {\n    return string.byteLength\n  }\n  if (typeof string !== 'string') {\n    string = '' + string\n  }\n\n  var len = string.length\n  if (len === 0) return 0\n\n  // Use a for loop to avoid recursion\n  var loweredCase = false\n  for (;;) {\n    switch (encoding) {\n      case 'ascii':\n      case 'latin1':\n      case 'binary':\n        return len\n      case 'utf8':\n      case 'utf-8':\n      case undefined:\n        return utf8ToBytes(string).length\n      case 'ucs2':\n      case 'ucs-2':\n      case 'utf16le':\n      case 'utf-16le':\n        return len * 2\n      case 'hex':\n        return len >>> 1\n      case 'base64':\n        return base64ToBytes(string).length\n      default:\n        if (loweredCase) return utf8ToBytes(string).length // assume utf8\n        encoding = ('' + encoding).toLowerCase()\n        loweredCase = true\n    }\n  }\n}\nBuffer.byteLength = byteLength\n\nfunction slowToString (encoding, start, end) {\n  var loweredCase = false\n\n  // No need to verify that \"this.length <= MAX_UINT32\" since it's a read-only\n  // property of a typed array.\n\n  // This behaves neither like String nor Uint8Array in that we set start/end\n  // to their upper/lower bounds if the value passed is out of range.\n  // undefined is handled specially as per ECMA-262 6th Edition,\n  // Section 13.3.3.7 Runtime Semantics: KeyedBindingInitialization.\n  if (start === undefined || start < 0) {\n    start = 0\n  }\n  // Return early if start > this.length. Done here to prevent potential uint32\n  // coercion fail below.\n  if (start > this.length) {\n    return ''\n  }\n\n  if (end === undefined || end > this.length) {\n    end = this.length\n  }\n\n  if (end <= 0) {\n    return ''\n  }\n\n  // Force coersion to uint32. This will also coerce falsey/NaN values to 0.\n  end >>>= 0\n  start >>>= 0\n\n  if (end <= start) {\n    return ''\n  }\n\n  if (!encoding) encoding = 'utf8'\n\n  while (true) {\n    switch (encoding) {\n      case 'hex':\n        return hexSlice(this, start, end)\n\n      case 'utf8':\n      case 'utf-8':\n        return utf8Slice(this, start, end)\n\n      case 'ascii':\n        return asciiSlice(this, start, end)\n\n      case 'latin1':\n      case 'binary':\n        return latin1Slice(this, start, end)\n\n      case 'base64':\n        return base64Slice(this, start, end)\n\n      case 'ucs2':\n      case 'ucs-2':\n      case 'utf16le':\n      case 'utf-16le':\n        return utf16leSlice(this, start, end)\n\n      default:\n        if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)\n        encoding = (encoding + '').toLowerCase()\n        loweredCase = true\n    }\n  }\n}\n\n// The property is used by `Buffer.isBuffer` and `is-buffer` (in Safari 5-7) to detect\n// Buffer instances.\nBuffer.prototype._isBuffer = true\n\nfunction swap (b, n, m) {\n  var i = b[n]\n  b[n] = b[m]\n  b[m] = i\n}\n\nBuffer.prototype.swap16 = function swap16 () {\n  var len = this.length\n  if (len % 2 !== 0) {\n    throw new RangeError('Buffer size must be a multiple of 16-bits')\n  }\n  for (var i = 0; i < len; i += 2) {\n    swap(this, i, i + 1)\n  }\n  return this\n}\n\nBuffer.prototype.swap32 = function swap32 () {\n  var len = this.length\n  if (len % 4 !== 0) {\n    throw new RangeError('Buffer size must be a multiple of 32-bits')\n  }\n  for (var i = 0; i < len; i += 4) {\n    swap(this, i, i + 3)\n    swap(this, i + 1, i + 2)\n  }\n  return this\n}\n\nBuffer.prototype.swap64 = function swap64 () {\n  var len = this.length\n  if (len % 8 !== 0) {\n    throw new RangeError('Buffer size must be a multiple of 64-bits')\n  }\n  for (var i = 0; i < len; i += 8) {\n    swap(this, i, i + 7)\n    swap(this, i + 1, i + 6)\n    swap(this, i + 2, i + 5)\n    swap(this, i + 3, i + 4)\n  }\n  return this\n}\n\nBuffer.prototype.toString = function toString () {\n  var length = this.length | 0\n  if (length === 0) return ''\n  if (arguments.length === 0) return utf8Slice(this, 0, length)\n  return slowToString.apply(this, arguments)\n}\n\nBuffer.prototype.equals = function equals (b) {\n  if (!Buffer.isBuffer(b)) throw new TypeError('Argument must be a Buffer')\n  if (this === b) return true\n  return Buffer.compare(this, b) === 0\n}\n\nBuffer.prototype.inspect = function inspect () {\n  var str = ''\n  var max = exports.INSPECT_MAX_BYTES\n  if (this.length > 0) {\n    str = this.toString('hex', 0, max).match(/.{2}/g).join(' ')\n    if (this.length > max) str += ' ... '\n  }\n  return '<Buffer ' + str + '>'\n}\n\nBuffer.prototype.compare = function compare (target, start, end, thisStart, thisEnd) {\n  if (!Buffer.isBuffer(target)) {\n    throw new TypeError('Argument must be a Buffer')\n  }\n\n  if (start === undefined) {\n    start = 0\n  }\n  if (end === undefined) {\n    end = target ? target.length : 0\n  }\n  if (thisStart === undefined) {\n    thisStart = 0\n  }\n  if (thisEnd === undefined) {\n    thisEnd = this.length\n  }\n\n  if (start < 0 || end > target.length || thisStart < 0 || thisEnd > this.length) {\n    throw new RangeError('out of range index')\n  }\n\n  if (thisStart >= thisEnd && start >= end) {\n    return 0\n  }\n  if (thisStart >= thisEnd) {\n    return -1\n  }\n  if (start >= end) {\n    return 1\n  }\n\n  start >>>= 0\n  end >>>= 0\n  thisStart >>>= 0\n  thisEnd >>>= 0\n\n  if (this === target) return 0\n\n  var x = thisEnd - thisStart\n  var y = end - start\n  var len = Math.min(x, y)\n\n  var thisCopy = this.slice(thisStart, thisEnd)\n  var targetCopy = target.slice(start, end)\n\n  for (var i = 0; i < len; ++i) {\n    if (thisCopy[i] !== targetCopy[i]) {\n      x = thisCopy[i]\n      y = targetCopy[i]\n      break\n    }\n  }\n\n  if (x < y) return -1\n  if (y < x) return 1\n  return 0\n}\n\n// Finds either the first index of `val` in `buffer` at offset >= `byteOffset`,\n// OR the last index of `val` in `buffer` at offset <= `byteOffset`.\n//\n// Arguments:\n// - buffer - a Buffer to search\n// - val - a string, Buffer, or number\n// - byteOffset - an index into `buffer`; will be clamped to an int32\n// - encoding - an optional encoding, relevant is val is a string\n// - dir - true for indexOf, false for lastIndexOf\nfunction bidirectionalIndexOf (buffer, val, byteOffset, encoding, dir) {\n  // Empty buffer means no match\n  if (buffer.length === 0) return -1\n\n  // Normalize byteOffset\n  if (typeof byteOffset === 'string') {\n    encoding = byteOffset\n    byteOffset = 0\n  } else if (byteOffset > 0x7fffffff) {\n    byteOffset = 0x7fffffff\n  } else if (byteOffset < -0x80000000) {\n    byteOffset = -0x80000000\n  }\n  byteOffset = +byteOffset  // Coerce to Number.\n  if (isNaN(byteOffset)) {\n    // byteOffset: it it's undefined, null, NaN, \"foo\", etc, search whole buffer\n    byteOffset = dir ? 0 : (buffer.length - 1)\n  }\n\n  // Normalize byteOffset: negative offsets start from the end of the buffer\n  if (byteOffset < 0) byteOffset = buffer.length + byteOffset\n  if (byteOffset >= buffer.length) {\n    if (dir) return -1\n    else byteOffset = buffer.length - 1\n  } else if (byteOffset < 0) {\n    if (dir) byteOffset = 0\n    else return -1\n  }\n\n  // Normalize val\n  if (typeof val === 'string') {\n    val = Buffer.from(val, encoding)\n  }\n\n  // Finally, search either indexOf (if dir is true) or lastIndexOf\n  if (Buffer.isBuffer(val)) {\n    // Special case: looking for empty string/buffer always fails\n    if (val.length === 0) {\n      return -1\n    }\n    return arrayIndexOf(buffer, val, byteOffset, encoding, dir)\n  } else if (typeof val === 'number') {\n    val = val & 0xFF // Search for a byte value [0-255]\n    if (Buffer.TYPED_ARRAY_SUPPORT &&\n        typeof Uint8Array.prototype.indexOf === 'function') {\n      if (dir) {\n        return Uint8Array.prototype.indexOf.call(buffer, val, byteOffset)\n      } else {\n        return Uint8Array.prototype.lastIndexOf.call(buffer, val, byteOffset)\n      }\n    }\n    return arrayIndexOf(buffer, [ val ], byteOffset, encoding, dir)\n  }\n\n  throw new TypeError('val must be string, number or Buffer')\n}\n\nfunction arrayIndexOf (arr, val, byteOffset, encoding, dir) {\n  var indexSize = 1\n  var arrLength = arr.length\n  var valLength = val.length\n\n  if (encoding !== undefined) {\n    encoding = String(encoding).toLowerCase()\n    if (encoding === 'ucs2' || encoding === 'ucs-2' ||\n        encoding === 'utf16le' || encoding === 'utf-16le') {\n      if (arr.length < 2 || val.length < 2) {\n        return -1\n      }\n      indexSize = 2\n      arrLength /= 2\n      valLength /= 2\n      byteOffset /= 2\n    }\n  }\n\n  function read (buf, i) {\n    if (indexSize === 1) {\n      return buf[i]\n    } else {\n      return buf.readUInt16BE(i * indexSize)\n    }\n  }\n\n  var i\n  if (dir) {\n    var foundIndex = -1\n    for (i = byteOffset; i < arrLength; i++) {\n      if (read(arr, i) === read(val, foundIndex === -1 ? 0 : i - foundIndex)) {\n        if (foundIndex === -1) foundIndex = i\n        if (i - foundIndex + 1 === valLength) return foundIndex * indexSize\n      } else {\n        if (foundIndex !== -1) i -= i - foundIndex\n        foundIndex = -1\n      }\n    }\n  } else {\n    if (byteOffset + valLength > arrLength) byteOffset = arrLength - valLength\n    for (i = byteOffset; i >= 0; i--) {\n      var found = true\n      for (var j = 0; j < valLength; j++) {\n        if (read(arr, i + j) !== read(val, j)) {\n          found = false\n          break\n        }\n      }\n      if (found) return i\n    }\n  }\n\n  return -1\n}\n\nBuffer.prototype.includes = function includes (val, byteOffset, encoding) {\n  return this.indexOf(val, byteOffset, encoding) !== -1\n}\n\nBuffer.prototype.indexOf = function indexOf (val, byteOffset, encoding) {\n  return bidirectionalIndexOf(this, val, byteOffset, encoding, true)\n}\n\nBuffer.prototype.lastIndexOf = function lastIndexOf (val, byteOffset, encoding) {\n  return bidirectionalIndexOf(this, val, byteOffset, encoding, false)\n}\n\nfunction hexWrite (buf, string, offset, length) {\n  offset = Number(offset) || 0\n  var remaining = buf.length - offset\n  if (!length) {\n    length = remaining\n  } else {\n    length = Number(length)\n    if (length > remaining) {\n      length = remaining\n    }\n  }\n\n  // must be an even number of digits\n  var strLen = string.length\n  if (strLen % 2 !== 0) throw new TypeError('Invalid hex string')\n\n  if (length > strLen / 2) {\n    length = strLen / 2\n  }\n  for (var i = 0; i < length; ++i) {\n    var parsed = parseInt(string.substr(i * 2, 2), 16)\n    if (isNaN(parsed)) return i\n    buf[offset + i] = parsed\n  }\n  return i\n}\n\nfunction utf8Write (buf, string, offset, length) {\n  return blitBuffer(utf8ToBytes(string, buf.length - offset), buf, offset, length)\n}\n\nfunction asciiWrite (buf, string, offset, length) {\n  return blitBuffer(asciiToBytes(string), buf, offset, length)\n}\n\nfunction latin1Write (buf, string, offset, length) {\n  return asciiWrite(buf, string, offset, length)\n}\n\nfunction base64Write (buf, string, offset, length) {\n  return blitBuffer(base64ToBytes(string), buf, offset, length)\n}\n\nfunction ucs2Write (buf, string, offset, length) {\n  return blitBuffer(utf16leToBytes(string, buf.length - offset), buf, offset, length)\n}\n\nBuffer.prototype.write = function write (string, offset, length, encoding) {\n  // Buffer#write(string)\n  if (offset === undefined) {\n    encoding = 'utf8'\n    length = this.length\n    offset = 0\n  // Buffer#write(string, encoding)\n  } else if (length === undefined && typeof offset === 'string') {\n    encoding = offset\n    length = this.length\n    offset = 0\n  // Buffer#write(string, offset[, length][, encoding])\n  } else if (isFinite(offset)) {\n    offset = offset | 0\n    if (isFinite(length)) {\n      length = length | 0\n      if (encoding === undefined) encoding = 'utf8'\n    } else {\n      encoding = length\n      length = undefined\n    }\n  // legacy write(string, encoding, offset, length) - remove in v0.13\n  } else {\n    throw new Error(\n      'Buffer.write(string, encoding, offset[, length]) is no longer supported'\n    )\n  }\n\n  var remaining = this.length - offset\n  if (length === undefined || length > remaining) length = remaining\n\n  if ((string.length > 0 && (length < 0 || offset < 0)) || offset > this.length) {\n    throw new RangeError('Attempt to write outside buffer bounds')\n  }\n\n  if (!encoding) encoding = 'utf8'\n\n  var loweredCase = false\n  for (;;) {\n    switch (encoding) {\n      case 'hex':\n        return hexWrite(this, string, offset, length)\n\n      case 'utf8':\n      case 'utf-8':\n        return utf8Write(this, string, offset, length)\n\n      case 'ascii':\n        return asciiWrite(this, string, offset, length)\n\n      case 'latin1':\n      case 'binary':\n        return latin1Write(this, string, offset, length)\n\n      case 'base64':\n        // Warning: maxLength not taken into account in base64Write\n        return base64Write(this, string, offset, length)\n\n      case 'ucs2':\n      case 'ucs-2':\n      case 'utf16le':\n      case 'utf-16le':\n        return ucs2Write(this, string, offset, length)\n\n      default:\n        if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)\n        encoding = ('' + encoding).toLowerCase()\n        loweredCase = true\n    }\n  }\n}\n\nBuffer.prototype.toJSON = function toJSON () {\n  return {\n    type: 'Buffer',\n    data: Array.prototype.slice.call(this._arr || this, 0)\n  }\n}\n\nfunction base64Slice (buf, start, end) {\n  if (start === 0 && end === buf.length) {\n    return base64.fromByteArray(buf)\n  } else {\n    return base64.fromByteArray(buf.slice(start, end))\n  }\n}\n\nfunction utf8Slice (buf, start, end) {\n  end = Math.min(buf.length, end)\n  var res = []\n\n  var i = start\n  while (i < end) {\n    var firstByte = buf[i]\n    var codePoint = null\n    var bytesPerSequence = (firstByte > 0xEF) ? 4\n      : (firstByte > 0xDF) ? 3\n      : (firstByte > 0xBF) ? 2\n      : 1\n\n    if (i + bytesPerSequence <= end) {\n      var secondByte, thirdByte, fourthByte, tempCodePoint\n\n      switch (bytesPerSequence) {\n        case 1:\n          if (firstByte < 0x80) {\n            codePoint = firstByte\n          }\n          break\n        case 2:\n          secondByte = buf[i + 1]\n          if ((secondByte & 0xC0) === 0x80) {\n            tempCodePoint = (firstByte & 0x1F) << 0x6 | (secondByte & 0x3F)\n            if (tempCodePoint > 0x7F) {\n              codePoint = tempCodePoint\n            }\n          }\n          break\n        case 3:\n          secondByte = buf[i + 1]\n          thirdByte = buf[i + 2]\n          if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80) {\n            tempCodePoint = (firstByte & 0xF) << 0xC | (secondByte & 0x3F) << 0x6 | (thirdByte & 0x3F)\n            if (tempCodePoint > 0x7FF && (tempCodePoint < 0xD800 || tempCodePoint > 0xDFFF)) {\n              codePoint = tempCodePoint\n            }\n          }\n          break\n        case 4:\n          secondByte = buf[i + 1]\n          thirdByte = buf[i + 2]\n          fourthByte = buf[i + 3]\n          if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80 && (fourthByte & 0xC0) === 0x80) {\n            tempCodePoint = (firstByte & 0xF) << 0x12 | (secondByte & 0x3F) << 0xC | (thirdByte & 0x3F) << 0x6 | (fourthByte & 0x3F)\n            if (tempCodePoint > 0xFFFF && tempCodePoint < 0x110000) {\n              codePoint = tempCodePoint\n            }\n          }\n      }\n    }\n\n    if (codePoint === null) {\n      // we did not generate a valid codePoint so insert a\n      // replacement char (U+FFFD) and advance only 1 byte\n      codePoint = 0xFFFD\n      bytesPerSequence = 1\n    } else if (codePoint > 0xFFFF) {\n      // encode to utf16 (surrogate pair dance)\n      codePoint -= 0x10000\n      res.push(codePoint >>> 10 & 0x3FF | 0xD800)\n      codePoint = 0xDC00 | codePoint & 0x3FF\n    }\n\n    res.push(codePoint)\n    i += bytesPerSequence\n  }\n\n  return decodeCodePointsArray(res)\n}\n\n// Based on http://stackoverflow.com/a/22747272/680742, the browser with\n// the lowest limit is Chrome, with 0x10000 args.\n// We go 1 magnitude less, for safety\nvar MAX_ARGUMENTS_LENGTH = 0x1000\n\nfunction decodeCodePointsArray (codePoints) {\n  var len = codePoints.length\n  if (len <= MAX_ARGUMENTS_LENGTH) {\n    return String.fromCharCode.apply(String, codePoints) // avoid extra slice()\n  }\n\n  // Decode in chunks to avoid \"call stack size exceeded\".\n  var res = ''\n  var i = 0\n  while (i < len) {\n    res += String.fromCharCode.apply(\n      String,\n      codePoints.slice(i, i += MAX_ARGUMENTS_LENGTH)\n    )\n  }\n  return res\n}\n\nfunction asciiSlice (buf, start, end) {\n  var ret = ''\n  end = Math.min(buf.length, end)\n\n  for (var i = start; i < end; ++i) {\n    ret += String.fromCharCode(buf[i] & 0x7F)\n  }\n  return ret\n}\n\nfunction latin1Slice (buf, start, end) {\n  var ret = ''\n  end = Math.min(buf.length, end)\n\n  for (var i = start; i < end; ++i) {\n    ret += String.fromCharCode(buf[i])\n  }\n  return ret\n}\n\nfunction hexSlice (buf, start, end) {\n  var len = buf.length\n\n  if (!start || start < 0) start = 0\n  if (!end || end < 0 || end > len) end = len\n\n  var out = ''\n  for (var i = start; i < end; ++i) {\n    out += toHex(buf[i])\n  }\n  return out\n}\n\nfunction utf16leSlice (buf, start, end) {\n  var bytes = buf.slice(start, end)\n  var res = ''\n  for (var i = 0; i < bytes.length; i += 2) {\n    res += String.fromCharCode(bytes[i] + bytes[i + 1] * 256)\n  }\n  return res\n}\n\nBuffer.prototype.slice = function slice (start, end) {\n  var len = this.length\n  start = ~~start\n  end = end === undefined ? len : ~~end\n\n  if (start < 0) {\n    start += len\n    if (start < 0) start = 0\n  } else if (start > len) {\n    start = len\n  }\n\n  if (end < 0) {\n    end += len\n    if (end < 0) end = 0\n  } else if (end > len) {\n    end = len\n  }\n\n  if (end < start) end = start\n\n  var newBuf\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    newBuf = this.subarray(start, end)\n    newBuf.__proto__ = Buffer.prototype\n  } else {\n    var sliceLen = end - start\n    newBuf = new Buffer(sliceLen, undefined)\n    for (var i = 0; i < sliceLen; ++i) {\n      newBuf[i] = this[i + start]\n    }\n  }\n\n  return newBuf\n}\n\n/*\n * Need to make sure that buffer isn't trying to write out of bounds.\n */\nfunction checkOffset (offset, ext, length) {\n  if ((offset % 1) !== 0 || offset < 0) throw new RangeError('offset is not uint')\n  if (offset + ext > length) throw new RangeError('Trying to access beyond buffer length')\n}\n\nBuffer.prototype.readUIntLE = function readUIntLE (offset, byteLength, noAssert) {\n  offset = offset | 0\n  byteLength = byteLength | 0\n  if (!noAssert) checkOffset(offset, byteLength, this.length)\n\n  var val = this[offset]\n  var mul = 1\n  var i = 0\n  while (++i < byteLength && (mul *= 0x100)) {\n    val += this[offset + i] * mul\n  }\n\n  return val\n}\n\nBuffer.prototype.readUIntBE = function readUIntBE (offset, byteLength, noAssert) {\n  offset = offset | 0\n  byteLength = byteLength | 0\n  if (!noAssert) {\n    checkOffset(offset, byteLength, this.length)\n  }\n\n  var val = this[offset + --byteLength]\n  var mul = 1\n  while (byteLength > 0 && (mul *= 0x100)) {\n    val += this[offset + --byteLength] * mul\n  }\n\n  return val\n}\n\nBuffer.prototype.readUInt8 = function readUInt8 (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 1, this.length)\n  return this[offset]\n}\n\nBuffer.prototype.readUInt16LE = function readUInt16LE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 2, this.length)\n  return this[offset] | (this[offset + 1] << 8)\n}\n\nBuffer.prototype.readUInt16BE = function readUInt16BE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 2, this.length)\n  return (this[offset] << 8) | this[offset + 1]\n}\n\nBuffer.prototype.readUInt32LE = function readUInt32LE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length)\n\n  return ((this[offset]) |\n      (this[offset + 1] << 8) |\n      (this[offset + 2] << 16)) +\n      (this[offset + 3] * 0x1000000)\n}\n\nBuffer.prototype.readUInt32BE = function readUInt32BE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length)\n\n  return (this[offset] * 0x1000000) +\n    ((this[offset + 1] << 16) |\n    (this[offset + 2] << 8) |\n    this[offset + 3])\n}\n\nBuffer.prototype.readIntLE = function readIntLE (offset, byteLength, noAssert) {\n  offset = offset | 0\n  byteLength = byteLength | 0\n  if (!noAssert) checkOffset(offset, byteLength, this.length)\n\n  var val = this[offset]\n  var mul = 1\n  var i = 0\n  while (++i < byteLength && (mul *= 0x100)) {\n    val += this[offset + i] * mul\n  }\n  mul *= 0x80\n\n  if (val >= mul) val -= Math.pow(2, 8 * byteLength)\n\n  return val\n}\n\nBuffer.prototype.readIntBE = function readIntBE (offset, byteLength, noAssert) {\n  offset = offset | 0\n  byteLength = byteLength | 0\n  if (!noAssert) checkOffset(offset, byteLength, this.length)\n\n  var i = byteLength\n  var mul = 1\n  var val = this[offset + --i]\n  while (i > 0 && (mul *= 0x100)) {\n    val += this[offset + --i] * mul\n  }\n  mul *= 0x80\n\n  if (val >= mul) val -= Math.pow(2, 8 * byteLength)\n\n  return val\n}\n\nBuffer.prototype.readInt8 = function readInt8 (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 1, this.length)\n  if (!(this[offset] & 0x80)) return (this[offset])\n  return ((0xff - this[offset] + 1) * -1)\n}\n\nBuffer.prototype.readInt16LE = function readInt16LE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 2, this.length)\n  var val = this[offset] | (this[offset + 1] << 8)\n  return (val & 0x8000) ? val | 0xFFFF0000 : val\n}\n\nBuffer.prototype.readInt16BE = function readInt16BE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 2, this.length)\n  var val = this[offset + 1] | (this[offset] << 8)\n  return (val & 0x8000) ? val | 0xFFFF0000 : val\n}\n\nBuffer.prototype.readInt32LE = function readInt32LE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length)\n\n  return (this[offset]) |\n    (this[offset + 1] << 8) |\n    (this[offset + 2] << 16) |\n    (this[offset + 3] << 24)\n}\n\nBuffer.prototype.readInt32BE = function readInt32BE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length)\n\n  return (this[offset] << 24) |\n    (this[offset + 1] << 16) |\n    (this[offset + 2] << 8) |\n    (this[offset + 3])\n}\n\nBuffer.prototype.readFloatLE = function readFloatLE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length)\n  return ieee754.read(this, offset, true, 23, 4)\n}\n\nBuffer.prototype.readFloatBE = function readFloatBE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length)\n  return ieee754.read(this, offset, false, 23, 4)\n}\n\nBuffer.prototype.readDoubleLE = function readDoubleLE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 8, this.length)\n  return ieee754.read(this, offset, true, 52, 8)\n}\n\nBuffer.prototype.readDoubleBE = function readDoubleBE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 8, this.length)\n  return ieee754.read(this, offset, false, 52, 8)\n}\n\nfunction checkInt (buf, value, offset, ext, max, min) {\n  if (!Buffer.isBuffer(buf)) throw new TypeError('\"buffer\" argument must be a Buffer instance')\n  if (value > max || value < min) throw new RangeError('\"value\" argument is out of bounds')\n  if (offset + ext > buf.length) throw new RangeError('Index out of range')\n}\n\nBuffer.prototype.writeUIntLE = function writeUIntLE (value, offset, byteLength, noAssert) {\n  value = +value\n  offset = offset | 0\n  byteLength = byteLength | 0\n  if (!noAssert) {\n    var maxBytes = Math.pow(2, 8 * byteLength) - 1\n    checkInt(this, value, offset, byteLength, maxBytes, 0)\n  }\n\n  var mul = 1\n  var i = 0\n  this[offset] = value & 0xFF\n  while (++i < byteLength && (mul *= 0x100)) {\n    this[offset + i] = (value / mul) & 0xFF\n  }\n\n  return offset + byteLength\n}\n\nBuffer.prototype.writeUIntBE = function writeUIntBE (value, offset, byteLength, noAssert) {\n  value = +value\n  offset = offset | 0\n  byteLength = byteLength | 0\n  if (!noAssert) {\n    var maxBytes = Math.pow(2, 8 * byteLength) - 1\n    checkInt(this, value, offset, byteLength, maxBytes, 0)\n  }\n\n  var i = byteLength - 1\n  var mul = 1\n  this[offset + i] = value & 0xFF\n  while (--i >= 0 && (mul *= 0x100)) {\n    this[offset + i] = (value / mul) & 0xFF\n  }\n\n  return offset + byteLength\n}\n\nBuffer.prototype.writeUInt8 = function writeUInt8 (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 1, 0xff, 0)\n  if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value)\n  this[offset] = (value & 0xff)\n  return offset + 1\n}\n\nfunction objectWriteUInt16 (buf, value, offset, littleEndian) {\n  if (value < 0) value = 0xffff + value + 1\n  for (var i = 0, j = Math.min(buf.length - offset, 2); i < j; ++i) {\n    buf[offset + i] = (value & (0xff << (8 * (littleEndian ? i : 1 - i)))) >>>\n      (littleEndian ? i : 1 - i) * 8\n  }\n}\n\nBuffer.prototype.writeUInt16LE = function writeUInt16LE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value & 0xff)\n    this[offset + 1] = (value >>> 8)\n  } else {\n    objectWriteUInt16(this, value, offset, true)\n  }\n  return offset + 2\n}\n\nBuffer.prototype.writeUInt16BE = function writeUInt16BE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value >>> 8)\n    this[offset + 1] = (value & 0xff)\n  } else {\n    objectWriteUInt16(this, value, offset, false)\n  }\n  return offset + 2\n}\n\nfunction objectWriteUInt32 (buf, value, offset, littleEndian) {\n  if (value < 0) value = 0xffffffff + value + 1\n  for (var i = 0, j = Math.min(buf.length - offset, 4); i < j; ++i) {\n    buf[offset + i] = (value >>> (littleEndian ? i : 3 - i) * 8) & 0xff\n  }\n}\n\nBuffer.prototype.writeUInt32LE = function writeUInt32LE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset + 3] = (value >>> 24)\n    this[offset + 2] = (value >>> 16)\n    this[offset + 1] = (value >>> 8)\n    this[offset] = (value & 0xff)\n  } else {\n    objectWriteUInt32(this, value, offset, true)\n  }\n  return offset + 4\n}\n\nBuffer.prototype.writeUInt32BE = function writeUInt32BE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value >>> 24)\n    this[offset + 1] = (value >>> 16)\n    this[offset + 2] = (value >>> 8)\n    this[offset + 3] = (value & 0xff)\n  } else {\n    objectWriteUInt32(this, value, offset, false)\n  }\n  return offset + 4\n}\n\nBuffer.prototype.writeIntLE = function writeIntLE (value, offset, byteLength, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) {\n    var limit = Math.pow(2, 8 * byteLength - 1)\n\n    checkInt(this, value, offset, byteLength, limit - 1, -limit)\n  }\n\n  var i = 0\n  var mul = 1\n  var sub = 0\n  this[offset] = value & 0xFF\n  while (++i < byteLength && (mul *= 0x100)) {\n    if (value < 0 && sub === 0 && this[offset + i - 1] !== 0) {\n      sub = 1\n    }\n    this[offset + i] = ((value / mul) >> 0) - sub & 0xFF\n  }\n\n  return offset + byteLength\n}\n\nBuffer.prototype.writeIntBE = function writeIntBE (value, offset, byteLength, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) {\n    var limit = Math.pow(2, 8 * byteLength - 1)\n\n    checkInt(this, value, offset, byteLength, limit - 1, -limit)\n  }\n\n  var i = byteLength - 1\n  var mul = 1\n  var sub = 0\n  this[offset + i] = value & 0xFF\n  while (--i >= 0 && (mul *= 0x100)) {\n    if (value < 0 && sub === 0 && this[offset + i + 1] !== 0) {\n      sub = 1\n    }\n    this[offset + i] = ((value / mul) >> 0) - sub & 0xFF\n  }\n\n  return offset + byteLength\n}\n\nBuffer.prototype.writeInt8 = function writeInt8 (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 1, 0x7f, -0x80)\n  if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value)\n  if (value < 0) value = 0xff + value + 1\n  this[offset] = (value & 0xff)\n  return offset + 1\n}\n\nBuffer.prototype.writeInt16LE = function writeInt16LE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value & 0xff)\n    this[offset + 1] = (value >>> 8)\n  } else {\n    objectWriteUInt16(this, value, offset, true)\n  }\n  return offset + 2\n}\n\nBuffer.prototype.writeInt16BE = function writeInt16BE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value >>> 8)\n    this[offset + 1] = (value & 0xff)\n  } else {\n    objectWriteUInt16(this, value, offset, false)\n  }\n  return offset + 2\n}\n\nBuffer.prototype.writeInt32LE = function writeInt32LE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value & 0xff)\n    this[offset + 1] = (value >>> 8)\n    this[offset + 2] = (value >>> 16)\n    this[offset + 3] = (value >>> 24)\n  } else {\n    objectWriteUInt32(this, value, offset, true)\n  }\n  return offset + 4\n}\n\nBuffer.prototype.writeInt32BE = function writeInt32BE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)\n  if (value < 0) value = 0xffffffff + value + 1\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value >>> 24)\n    this[offset + 1] = (value >>> 16)\n    this[offset + 2] = (value >>> 8)\n    this[offset + 3] = (value & 0xff)\n  } else {\n    objectWriteUInt32(this, value, offset, false)\n  }\n  return offset + 4\n}\n\nfunction checkIEEE754 (buf, value, offset, ext, max, min) {\n  if (offset + ext > buf.length) throw new RangeError('Index out of range')\n  if (offset < 0) throw new RangeError('Index out of range')\n}\n\nfunction writeFloat (buf, value, offset, littleEndian, noAssert) {\n  if (!noAssert) {\n    checkIEEE754(buf, value, offset, 4, 3.4028234663852886e+38, -3.4028234663852886e+38)\n  }\n  ieee754.write(buf, value, offset, littleEndian, 23, 4)\n  return offset + 4\n}\n\nBuffer.prototype.writeFloatLE = function writeFloatLE (value, offset, noAssert) {\n  return writeFloat(this, value, offset, true, noAssert)\n}\n\nBuffer.prototype.writeFloatBE = function writeFloatBE (value, offset, noAssert) {\n  return writeFloat(this, value, offset, false, noAssert)\n}\n\nfunction writeDouble (buf, value, offset, littleEndian, noAssert) {\n  if (!noAssert) {\n    checkIEEE754(buf, value, offset, 8, 1.7976931348623157E+308, -1.7976931348623157E+308)\n  }\n  ieee754.write(buf, value, offset, littleEndian, 52, 8)\n  return offset + 8\n}\n\nBuffer.prototype.writeDoubleLE = function writeDoubleLE (value, offset, noAssert) {\n  return writeDouble(this, value, offset, true, noAssert)\n}\n\nBuffer.prototype.writeDoubleBE = function writeDoubleBE (value, offset, noAssert) {\n  return writeDouble(this, value, offset, false, noAssert)\n}\n\n// copy(targetBuffer, targetStart=0, sourceStart=0, sourceEnd=buffer.length)\nBuffer.prototype.copy = function copy (target, targetStart, start, end) {\n  if (!start) start = 0\n  if (!end && end !== 0) end = this.length\n  if (targetStart >= target.length) targetStart = target.length\n  if (!targetStart) targetStart = 0\n  if (end > 0 && end < start) end = start\n\n  // Copy 0 bytes; we're done\n  if (end === start) return 0\n  if (target.length === 0 || this.length === 0) return 0\n\n  // Fatal error conditions\n  if (targetStart < 0) {\n    throw new RangeError('targetStart out of bounds')\n  }\n  if (start < 0 || start >= this.length) throw new RangeError('sourceStart out of bounds')\n  if (end < 0) throw new RangeError('sourceEnd out of bounds')\n\n  // Are we oob?\n  if (end > this.length) end = this.length\n  if (target.length - targetStart < end - start) {\n    end = target.length - targetStart + start\n  }\n\n  var len = end - start\n  var i\n\n  if (this === target && start < targetStart && targetStart < end) {\n    // descending copy from end\n    for (i = len - 1; i >= 0; --i) {\n      target[i + targetStart] = this[i + start]\n    }\n  } else if (len < 1000 || !Buffer.TYPED_ARRAY_SUPPORT) {\n    // ascending copy from start\n    for (i = 0; i < len; ++i) {\n      target[i + targetStart] = this[i + start]\n    }\n  } else {\n    Uint8Array.prototype.set.call(\n      target,\n      this.subarray(start, start + len),\n      targetStart\n    )\n  }\n\n  return len\n}\n\n// Usage:\n//    buffer.fill(number[, offset[, end]])\n//    buffer.fill(buffer[, offset[, end]])\n//    buffer.fill(string[, offset[, end]][, encoding])\nBuffer.prototype.fill = function fill (val, start, end, encoding) {\n  // Handle string cases:\n  if (typeof val === 'string') {\n    if (typeof start === 'string') {\n      encoding = start\n      start = 0\n      end = this.length\n    } else if (typeof end === 'string') {\n      encoding = end\n      end = this.length\n    }\n    if (val.length === 1) {\n      var code = val.charCodeAt(0)\n      if (code < 256) {\n        val = code\n      }\n    }\n    if (encoding !== undefined && typeof encoding !== 'string') {\n      throw new TypeError('encoding must be a string')\n    }\n    if (typeof encoding === 'string' && !Buffer.isEncoding(encoding)) {\n      throw new TypeError('Unknown encoding: ' + encoding)\n    }\n  } else if (typeof val === 'number') {\n    val = val & 255\n  }\n\n  // Invalid ranges are not set to a default, so can range check early.\n  if (start < 0 || this.length < start || this.length < end) {\n    throw new RangeError('Out of range index')\n  }\n\n  if (end <= start) {\n    return this\n  }\n\n  start = start >>> 0\n  end = end === undefined ? this.length : end >>> 0\n\n  if (!val) val = 0\n\n  var i\n  if (typeof val === 'number') {\n    for (i = start; i < end; ++i) {\n      this[i] = val\n    }\n  } else {\n    var bytes = Buffer.isBuffer(val)\n      ? val\n      : utf8ToBytes(new Buffer(val, encoding).toString())\n    var len = bytes.length\n    for (i = 0; i < end - start; ++i) {\n      this[i + start] = bytes[i % len]\n    }\n  }\n\n  return this\n}\n\n// HELPER FUNCTIONS\n// ================\n\nvar INVALID_BASE64_RE = /[^+\\/0-9A-Za-z-_]/g\n\nfunction base64clean (str) {\n  // Node strips out invalid characters like \\n and \\t from the string, base64-js does not\n  str = stringtrim(str).replace(INVALID_BASE64_RE, '')\n  // Node converts strings with length < 2 to ''\n  if (str.length < 2) return ''\n  // Node allows for non-padded base64 strings (missing trailing ===), base64-js does not\n  while (str.length % 4 !== 0) {\n    str = str + '='\n  }\n  return str\n}\n\nfunction stringtrim (str) {\n  if (str.trim) return str.trim()\n  return str.replace(/^\\s+|\\s+$/g, '')\n}\n\nfunction toHex (n) {\n  if (n < 16) return '0' + n.toString(16)\n  return n.toString(16)\n}\n\nfunction utf8ToBytes (string, units) {\n  units = units || Infinity\n  var codePoint\n  var length = string.length\n  var leadSurrogate = null\n  var bytes = []\n\n  for (var i = 0; i < length; ++i) {\n    codePoint = string.charCodeAt(i)\n\n    // is surrogate component\n    if (codePoint > 0xD7FF && codePoint < 0xE000) {\n      // last char was a lead\n      if (!leadSurrogate) {\n        // no lead yet\n        if (codePoint > 0xDBFF) {\n          // unexpected trail\n          if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n          continue\n        } else if (i + 1 === length) {\n          // unpaired lead\n          if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n          continue\n        }\n\n        // valid lead\n        leadSurrogate = codePoint\n\n        continue\n      }\n\n      // 2 leads in a row\n      if (codePoint < 0xDC00) {\n        if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n        leadSurrogate = codePoint\n        continue\n      }\n\n      // valid surrogate pair\n      codePoint = (leadSurrogate - 0xD800 << 10 | codePoint - 0xDC00) + 0x10000\n    } else if (leadSurrogate) {\n      // valid bmp char, but last char was a lead\n      if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n    }\n\n    leadSurrogate = null\n\n    // encode utf8\n    if (codePoint < 0x80) {\n      if ((units -= 1) < 0) break\n      bytes.push(codePoint)\n    } else if (codePoint < 0x800) {\n      if ((units -= 2) < 0) break\n      bytes.push(\n        codePoint >> 0x6 | 0xC0,\n        codePoint & 0x3F | 0x80\n      )\n    } else if (codePoint < 0x10000) {\n      if ((units -= 3) < 0) break\n      bytes.push(\n        codePoint >> 0xC | 0xE0,\n        codePoint >> 0x6 & 0x3F | 0x80,\n        codePoint & 0x3F | 0x80\n      )\n    } else if (codePoint < 0x110000) {\n      if ((units -= 4) < 0) break\n      bytes.push(\n        codePoint >> 0x12 | 0xF0,\n        codePoint >> 0xC & 0x3F | 0x80,\n        codePoint >> 0x6 & 0x3F | 0x80,\n        codePoint & 0x3F | 0x80\n      )\n    } else {\n      throw new Error('Invalid code point')\n    }\n  }\n\n  return bytes\n}\n\nfunction asciiToBytes (str) {\n  var byteArray = []\n  for (var i = 0; i < str.length; ++i) {\n    // Node's code seems to be doing this and not & 0x7F..\n    byteArray.push(str.charCodeAt(i) & 0xFF)\n  }\n  return byteArray\n}\n\nfunction utf16leToBytes (str, units) {\n  var c, hi, lo\n  var byteArray = []\n  for (var i = 0; i < str.length; ++i) {\n    if ((units -= 2) < 0) break\n\n    c = str.charCodeAt(i)\n    hi = c >> 8\n    lo = c % 256\n    byteArray.push(lo)\n    byteArray.push(hi)\n  }\n\n  return byteArray\n}\n\nfunction base64ToBytes (str) {\n  return base64.toByteArray(base64clean(str))\n}\n\nfunction blitBuffer (src, dst, offset, length) {\n  for (var i = 0; i < length; ++i) {\n    if ((i + offset >= dst.length) || (i >= src.length)) break\n    dst[i + offset] = src[i]\n  }\n  return i\n}\n\nfunction isnan (val) {\n  return val !== val // eslint-disable-line no-self-compare\n}\n","/**\n * This is the web browser implementation of `debug()`.\n *\n * Expose `debug()` as the module.\n */\n\nexports = module.exports = require('./debug');\nexports.log = log;\nexports.formatArgs = formatArgs;\nexports.save = save;\nexports.load = load;\nexports.useColors = useColors;\nexports.storage = 'undefined' != typeof chrome\n               && 'undefined' != typeof chrome.storage\n                  ? chrome.storage.local\n                  : localstorage();\n\n/**\n * Colors.\n */\n\nexports.colors = [\n  'lightseagreen',\n  'forestgreen',\n  'goldenrod',\n  'dodgerblue',\n  'darkorchid',\n  'crimson'\n];\n\n/**\n * Currently only WebKit-based Web Inspectors, Firefox >= v31,\n * and the Firebug extension (any Firefox version) are known\n * to support \"%c\" CSS customizations.\n *\n * TODO: add a `localStorage` variable to explicitly enable/disable colors\n */\n\nfunction useColors() {\n  // NB: In an Electron preload script, document will be defined but not fully\n  // initialized. Since we know we're in Chrome, we'll just detect this case\n  // explicitly\n  if (typeof window !== 'undefined' && window && typeof window.process !== 'undefined' && window.process.type === 'renderer') {\n    return true;\n  }\n\n  // is webkit? http://stackoverflow.com/a/16459606/376773\n  // document is undefined in react-native: https://github.com/facebook/react-native/pull/1632\n  return (typeof document !== 'undefined' && document && 'WebkitAppearance' in document.documentElement.style) ||\n    // is firebug? http://stackoverflow.com/a/398120/376773\n    (typeof window !== 'undefined' && window && window.console && (console.firebug || (console.exception && console.table))) ||\n    // is firefox >= v31?\n    // https://developer.mozilla.org/en-US/docs/Tools/Web_Console#Styling_messages\n    (typeof navigator !== 'undefined' && navigator && navigator.userAgent && navigator.userAgent.toLowerCase().match(/firefox\\/(\\d+)/) && parseInt(RegExp.$1, 10) >= 31) ||\n    // double check webkit in userAgent just in case we are in a worker\n    (typeof navigator !== 'undefined' && navigator && navigator.userAgent && navigator.userAgent.toLowerCase().match(/applewebkit\\/(\\d+)/));\n}\n\n/**\n * Map %j to `JSON.stringify()`, since no Web Inspectors do that by default.\n */\n\nexports.formatters.j = function(v) {\n  try {\n    return JSON.stringify(v);\n  } catch (err) {\n    return '[UnexpectedJSONParseError]: ' + err.message;\n  }\n};\n\n\n/**\n * Colorize log arguments if enabled.\n *\n * @api public\n */\n\nfunction formatArgs(args) {\n  var useColors = this.useColors;\n\n  args[0] = (useColors ? '%c' : '')\n    + this.namespace\n    + (useColors ? ' %c' : ' ')\n    + args[0]\n    + (useColors ? '%c ' : ' ')\n    + '+' + exports.humanize(this.diff);\n\n  if (!useColors) return;\n\n  var c = 'color: ' + this.color;\n  args.splice(1, 0, c, 'color: inherit')\n\n  // the final \"%c\" is somewhat tricky, because there could be other\n  // arguments passed either before or after the %c, so we need to\n  // figure out the correct index to insert the CSS into\n  var index = 0;\n  var lastC = 0;\n  args[0].replace(/%[a-zA-Z%]/g, function(match) {\n    if ('%%' === match) return;\n    index++;\n    if ('%c' === match) {\n      // we only are interested in the *last* %c\n      // (the user may have provided their own)\n      lastC = index;\n    }\n  });\n\n  args.splice(lastC, 0, c);\n}\n\n/**\n * Invokes `console.log()` when available.\n * No-op when `console.log` is not a \"function\".\n *\n * @api public\n */\n\nfunction log() {\n  // this hackery is required for IE8/9, where\n  // the `console.log` function doesn't have 'apply'\n  return 'object' === typeof console\n    && console.log\n    && Function.prototype.apply.call(console.log, console, arguments);\n}\n\n/**\n * Save `namespaces`.\n *\n * @param {String} namespaces\n * @api private\n */\n\nfunction save(namespaces) {\n  try {\n    if (null == namespaces) {\n      exports.storage.removeItem('debug');\n    } else {\n      exports.storage.debug = namespaces;\n    }\n  } catch(e) {}\n}\n\n/**\n * Load `namespaces`.\n *\n * @return {String} returns the previously persisted debug modes\n * @api private\n */\n\nfunction load() {\n  try {\n    return exports.storage.debug;\n  } catch(e) {}\n\n  // If debug isn't set in LS, and we're in Electron, try to load $DEBUG\n  if (typeof process !== 'undefined' && 'env' in process) {\n    return process.env.DEBUG;\n  }\n}\n\n/**\n * Enable namespaces listed in `localStorage.debug` initially.\n */\n\nexports.enable(load());\n\n/**\n * Localstorage attempts to return the localstorage.\n *\n * This is necessary because safari throws\n * when a user disables cookies/localstorage\n * and you attempt to access it.\n *\n * @return {LocalStorage}\n * @api private\n */\n\nfunction localstorage() {\n  try {\n    return window.localStorage;\n  } catch (e) {}\n}\n","\n/**\n * This is the common logic for both the Node.js and web browser\n * implementations of `debug()`.\n *\n * Expose `debug()` as the module.\n */\n\nexports = module.exports = createDebug.debug = createDebug.default = createDebug;\nexports.coerce = coerce;\nexports.disable = disable;\nexports.enable = enable;\nexports.enabled = enabled;\nexports.humanize = require('ms');\n\n/**\n * The currently active debug mode names, and names to skip.\n */\n\nexports.names = [];\nexports.skips = [];\n\n/**\n * Map of special \"%n\" handling functions, for the debug \"format\" argument.\n *\n * Valid key names are a single, lower or upper-case letter, i.e. \"n\" and \"N\".\n */\n\nexports.formatters = {};\n\n/**\n * Previous log timestamp.\n */\n\nvar prevTime;\n\n/**\n * Select a color.\n * @param {String} namespace\n * @return {Number}\n * @api private\n */\n\nfunction selectColor(namespace) {\n  var hash = 0, i;\n\n  for (i in namespace) {\n    hash  = ((hash << 5) - hash) + namespace.charCodeAt(i);\n    hash |= 0; // Convert to 32bit integer\n  }\n\n  return exports.colors[Math.abs(hash) % exports.colors.length];\n}\n\n/**\n * Create a debugger with the given `namespace`.\n *\n * @param {String} namespace\n * @return {Function}\n * @api public\n */\n\nfunction createDebug(namespace) {\n\n  function debug() {\n    // disabled?\n    if (!debug.enabled) return;\n\n    var self = debug;\n\n    // set `diff` timestamp\n    var curr = +new Date();\n    var ms = curr - (prevTime || curr);\n    self.diff = ms;\n    self.prev = prevTime;\n    self.curr = curr;\n    prevTime = curr;\n\n    // turn the `arguments` into a proper Array\n    var args = new Array(arguments.length);\n    for (var i = 0; i < args.length; i++) {\n      args[i] = arguments[i];\n    }\n\n    args[0] = exports.coerce(args[0]);\n\n    if ('string' !== typeof args[0]) {\n      // anything else let's inspect with %O\n      args.unshift('%O');\n    }\n\n    // apply any `formatters` transformations\n    var index = 0;\n    args[0] = args[0].replace(/%([a-zA-Z%])/g, function(match, format) {\n      // if we encounter an escaped % then don't increase the array index\n      if (match === '%%') return match;\n      index++;\n      var formatter = exports.formatters[format];\n      if ('function' === typeof formatter) {\n        var val = args[index];\n        match = formatter.call(self, val);\n\n        // now we need to remove `args[index]` since it's inlined in the `format`\n        args.splice(index, 1);\n        index--;\n      }\n      return match;\n    });\n\n    // apply env-specific formatting (colors, etc.)\n    exports.formatArgs.call(self, args);\n\n    var logFn = debug.log || exports.log || console.log.bind(console);\n    logFn.apply(self, args);\n  }\n\n  debug.namespace = namespace;\n  debug.enabled = exports.enabled(namespace);\n  debug.useColors = exports.useColors();\n  debug.color = selectColor(namespace);\n\n  // env-specific initialization logic for debug instances\n  if ('function' === typeof exports.init) {\n    exports.init(debug);\n  }\n\n  return debug;\n}\n\n/**\n * Enables a debug mode by namespaces. This can include modes\n * separated by a colon and wildcards.\n *\n * @param {String} namespaces\n * @api public\n */\n\nfunction enable(namespaces) {\n  exports.save(namespaces);\n\n  var split = (namespaces || '').split(/[\\s,]+/);\n  var len = split.length;\n\n  for (var i = 0; i < len; i++) {\n    if (!split[i]) continue; // ignore empty strings\n    namespaces = split[i].replace(/\\*/g, '.*?');\n    if (namespaces[0] === '-') {\n      exports.skips.push(new RegExp('^' + namespaces.substr(1) + '$'));\n    } else {\n      exports.names.push(new RegExp('^' + namespaces + '$'));\n    }\n  }\n}\n\n/**\n * Disable debug output.\n *\n * @api public\n */\n\nfunction disable() {\n  exports.enable('');\n}\n\n/**\n * Returns true if the given mode name is enabled, false otherwise.\n *\n * @param {String} name\n * @return {Boolean}\n * @api public\n */\n\nfunction enabled(name) {\n  var i, len;\n  for (i = 0, len = exports.skips.length; i < len; i++) {\n    if (exports.skips[i].test(name)) {\n      return false;\n    }\n  }\n  for (i = 0, len = exports.names.length; i < len; i++) {\n    if (exports.names[i].test(name)) {\n      return true;\n    }\n  }\n  return false;\n}\n\n/**\n * Coerce `val`.\n *\n * @param {Mixed} val\n * @return {Mixed}\n * @api private\n */\n\nfunction coerce(val) {\n  if (val instanceof Error) return val.stack || val.message;\n  return val;\n}\n","exports.read = function (buffer, offset, isLE, mLen, nBytes) {\n  var e, m\n  var eLen = nBytes * 8 - mLen - 1\n  var eMax = (1 << eLen) - 1\n  var eBias = eMax >> 1\n  var nBits = -7\n  var i = isLE ? (nBytes - 1) : 0\n  var d = isLE ? -1 : 1\n  var s = buffer[offset + i]\n\n  i += d\n\n  e = s & ((1 << (-nBits)) - 1)\n  s >>= (-nBits)\n  nBits += eLen\n  for (; nBits > 0; e = e * 256 + buffer[offset + i], i += d, nBits -= 8) {}\n\n  m = e & ((1 << (-nBits)) - 1)\n  e >>= (-nBits)\n  nBits += mLen\n  for (; nBits > 0; m = m * 256 + buffer[offset + i], i += d, nBits -= 8) {}\n\n  if (e === 0) {\n    e = 1 - eBias\n  } else if (e === eMax) {\n    return m ? NaN : ((s ? -1 : 1) * Infinity)\n  } else {\n    m = m + Math.pow(2, mLen)\n    e = e - eBias\n  }\n  return (s ? -1 : 1) * m * Math.pow(2, e - mLen)\n}\n\nexports.write = function (buffer, value, offset, isLE, mLen, nBytes) {\n  var e, m, c\n  var eLen = nBytes * 8 - mLen - 1\n  var eMax = (1 << eLen) - 1\n  var eBias = eMax >> 1\n  var rt = (mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0)\n  var i = isLE ? 0 : (nBytes - 1)\n  var d = isLE ? 1 : -1\n  var s = value < 0 || (value === 0 && 1 / value < 0) ? 1 : 0\n\n  value = Math.abs(value)\n\n  if (isNaN(value) || value === Infinity) {\n    m = isNaN(value) ? 1 : 0\n    e = eMax\n  } else {\n    e = Math.floor(Math.log(value) / Math.LN2)\n    if (value * (c = Math.pow(2, -e)) < 1) {\n      e--\n      c *= 2\n    }\n    if (e + eBias >= 1) {\n      value += rt / c\n    } else {\n      value += rt * Math.pow(2, 1 - eBias)\n    }\n    if (value * c >= 2) {\n      e++\n      c /= 2\n    }\n\n    if (e + eBias >= eMax) {\n      m = 0\n      e = eMax\n    } else if (e + eBias >= 1) {\n      m = (value * c - 1) * Math.pow(2, mLen)\n      e = e + eBias\n    } else {\n      m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen)\n      e = 0\n    }\n  }\n\n  for (; mLen >= 8; buffer[offset + i] = m & 0xff, i += d, m /= 256, mLen -= 8) {}\n\n  e = (e << mLen) | m\n  eLen += mLen\n  for (; eLen > 0; buffer[offset + i] = e & 0xff, i += d, e /= 256, eLen -= 8) {}\n\n  buffer[offset + i - d] |= s * 128\n}\n","var toString = {}.toString;\n\nmodule.exports = Array.isArray || function (arr) {\n  return toString.call(arr) == '[object Array]';\n};\n","/*\n * $Id: base64.js,v 2.15 2014/04/05 12:58:57 dankogai Exp dankogai $\n *\n *  Licensed under the MIT license.\n *    http://opensource.org/licenses/mit-license\n *\n *  References:\n *    http://en.wikipedia.org/wiki/Base64\n */\n\n(function(global) {\n    'use strict';\n    // existing version for noConflict()\n    var _Base64 = global.Base64;\n    var version = \"2.1.9\";\n    // if node.js, we use Buffer\n    var buffer;\n    if (typeof module !== 'undefined' && module.exports) {\n        try {\n            buffer = require('buffer').Buffer;\n        } catch (err) {}\n    }\n    // constants\n    var b64chars\n        = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';\n    var b64tab = function(bin) {\n        var t = {};\n        for (var i = 0, l = bin.length; i < l; i++) t[bin.charAt(i)] = i;\n        return t;\n    }(b64chars);\n    var fromCharCode = String.fromCharCode;\n    // encoder stuff\n    var cb_utob = function(c) {\n        if (c.length < 2) {\n            var cc = c.charCodeAt(0);\n            return cc < 0x80 ? c\n                : cc < 0x800 ? (fromCharCode(0xc0 | (cc >>> 6))\n                                + fromCharCode(0x80 | (cc & 0x3f)))\n                : (fromCharCode(0xe0 | ((cc >>> 12) & 0x0f))\n                   + fromCharCode(0x80 | ((cc >>>  6) & 0x3f))\n                   + fromCharCode(0x80 | ( cc         & 0x3f)));\n        } else {\n            var cc = 0x10000\n                + (c.charCodeAt(0) - 0xD800) * 0x400\n                + (c.charCodeAt(1) - 0xDC00);\n            return (fromCharCode(0xf0 | ((cc >>> 18) & 0x07))\n                    + fromCharCode(0x80 | ((cc >>> 12) & 0x3f))\n                    + fromCharCode(0x80 | ((cc >>>  6) & 0x3f))\n                    + fromCharCode(0x80 | ( cc         & 0x3f)));\n        }\n    };\n    var re_utob = /[\\uD800-\\uDBFF][\\uDC00-\\uDFFFF]|[^\\x00-\\x7F]/g;\n    var utob = function(u) {\n        return u.replace(re_utob, cb_utob);\n    };\n    var cb_encode = function(ccc) {\n        var padlen = [0, 2, 1][ccc.length % 3],\n        ord = ccc.charCodeAt(0) << 16\n            | ((ccc.length > 1 ? ccc.charCodeAt(1) : 0) << 8)\n            | ((ccc.length > 2 ? ccc.charCodeAt(2) : 0)),\n        chars = [\n            b64chars.charAt( ord >>> 18),\n            b64chars.charAt((ord >>> 12) & 63),\n            padlen >= 2 ? '=' : b64chars.charAt((ord >>> 6) & 63),\n            padlen >= 1 ? '=' : b64chars.charAt(ord & 63)\n        ];\n        return chars.join('');\n    };\n    var btoa = global.btoa ? function(b) {\n        return global.btoa(b);\n    } : function(b) {\n        return b.replace(/[\\s\\S]{1,3}/g, cb_encode);\n    };\n    var _encode = buffer ? function (u) {\n        return (u.constructor === buffer.constructor ? u : new buffer(u))\n        .toString('base64')\n    }\n    : function (u) { return btoa(utob(u)) }\n    ;\n    var encode = function(u, urisafe) {\n        return !urisafe\n            ? _encode(String(u))\n            : _encode(String(u)).replace(/[+\\/]/g, function(m0) {\n                return m0 == '+' ? '-' : '_';\n            }).replace(/=/g, '');\n    };\n    var encodeURI = function(u) { return encode(u, true) };\n    // decoder stuff\n    var re_btou = new RegExp([\n        '[\\xC0-\\xDF][\\x80-\\xBF]',\n        '[\\xE0-\\xEF][\\x80-\\xBF]{2}',\n        '[\\xF0-\\xF7][\\x80-\\xBF]{3}'\n    ].join('|'), 'g');\n    var cb_btou = function(cccc) {\n        switch(cccc.length) {\n        case 4:\n            var cp = ((0x07 & cccc.charCodeAt(0)) << 18)\n                |    ((0x3f & cccc.charCodeAt(1)) << 12)\n                |    ((0x3f & cccc.charCodeAt(2)) <<  6)\n                |     (0x3f & cccc.charCodeAt(3)),\n            offset = cp - 0x10000;\n            return (fromCharCode((offset  >>> 10) + 0xD800)\n                    + fromCharCode((offset & 0x3FF) + 0xDC00));\n        case 3:\n            return fromCharCode(\n                ((0x0f & cccc.charCodeAt(0)) << 12)\n                    | ((0x3f & cccc.charCodeAt(1)) << 6)\n                    |  (0x3f & cccc.charCodeAt(2))\n            );\n        default:\n            return  fromCharCode(\n                ((0x1f & cccc.charCodeAt(0)) << 6)\n                    |  (0x3f & cccc.charCodeAt(1))\n            );\n        }\n    };\n    var btou = function(b) {\n        return b.replace(re_btou, cb_btou);\n    };\n    var cb_decode = function(cccc) {\n        var len = cccc.length,\n        padlen = len % 4,\n        n = (len > 0 ? b64tab[cccc.charAt(0)] << 18 : 0)\n            | (len > 1 ? b64tab[cccc.charAt(1)] << 12 : 0)\n            | (len > 2 ? b64tab[cccc.charAt(2)] <<  6 : 0)\n            | (len > 3 ? b64tab[cccc.charAt(3)]       : 0),\n        chars = [\n            fromCharCode( n >>> 16),\n            fromCharCode((n >>>  8) & 0xff),\n            fromCharCode( n         & 0xff)\n        ];\n        chars.length -= [0, 0, 2, 1][padlen];\n        return chars.join('');\n    };\n    var atob = global.atob ? function(a) {\n        return global.atob(a);\n    } : function(a){\n        return a.replace(/[\\s\\S]{1,4}/g, cb_decode);\n    };\n    var _decode = buffer ? function(a) {\n        return (a.constructor === buffer.constructor\n                ? a : new buffer(a, 'base64')).toString();\n    }\n    : function(a) { return btou(atob(a)) };\n    var decode = function(a){\n        return _decode(\n            String(a).replace(/[-_]/g, function(m0) { return m0 == '-' ? '+' : '/' })\n                .replace(/[^A-Za-z0-9\\+\\/]/g, '')\n        );\n    };\n    var noConflict = function() {\n        var Base64 = global.Base64;\n        global.Base64 = _Base64;\n        return Base64;\n    };\n    // export Base64\n    global.Base64 = {\n        VERSION: version,\n        atob: atob,\n        btoa: btoa,\n        fromBase64: decode,\n        toBase64: encode,\n        utob: utob,\n        encode: encode,\n        encodeURI: encodeURI,\n        btou: btou,\n        decode: decode,\n        noConflict: noConflict\n    };\n    // if ES5 is available, make Base64.extendString() available\n    if (typeof Object.defineProperty === 'function') {\n        var noEnum = function(v){\n            return {value:v,enumerable:false,writable:true,configurable:true};\n        };\n        global.Base64.extendString = function () {\n            Object.defineProperty(\n                String.prototype, 'fromBase64', noEnum(function () {\n                    return decode(this)\n                }));\n            Object.defineProperty(\n                String.prototype, 'toBase64', noEnum(function (urisafe) {\n                    return encode(this, urisafe)\n                }));\n            Object.defineProperty(\n                String.prototype, 'toBase64URI', noEnum(function () {\n                    return encode(this, true)\n                }));\n        };\n    }\n    // that's it!\n    if (global['Meteor']) {\n       Base64 = global.Base64; // for normal export in Meteor.js\n    }\n})(this);\n","/**\n * Helpers.\n */\n\nvar s = 1000\nvar m = s * 60\nvar h = m * 60\nvar d = h * 24\nvar y = d * 365.25\n\n/**\n * Parse or format the given `val`.\n *\n * Options:\n *\n *  - `long` verbose formatting [false]\n *\n * @param {String|Number} val\n * @param {Object} options\n * @throws {Error} throw an error if val is not a non-empty string or a number\n * @return {String|Number}\n * @api public\n */\n\nmodule.exports = function (val, options) {\n  options = options || {}\n  var type = typeof val\n  if (type === 'string' && val.length > 0) {\n    return parse(val)\n  } else if (type === 'number' && isNaN(val) === false) {\n    return options.long ?\n\t\t\tfmtLong(val) :\n\t\t\tfmtShort(val)\n  }\n  throw new Error('val is not a non-empty string or a valid number. val=' + JSON.stringify(val))\n}\n\n/**\n * Parse the given `str` and return milliseconds.\n *\n * @param {String} str\n * @return {Number}\n * @api private\n */\n\nfunction parse(str) {\n  str = String(str)\n  if (str.length > 10000) {\n    return\n  }\n  var match = /^((?:\\d+)?\\.?\\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|years?|yrs?|y)?$/i.exec(str)\n  if (!match) {\n    return\n  }\n  var n = parseFloat(match[1])\n  var type = (match[2] || 'ms').toLowerCase()\n  switch (type) {\n    case 'years':\n    case 'year':\n    case 'yrs':\n    case 'yr':\n    case 'y':\n      return n * y\n    case 'days':\n    case 'day':\n    case 'd':\n      return n * d\n    case 'hours':\n    case 'hour':\n    case 'hrs':\n    case 'hr':\n    case 'h':\n      return n * h\n    case 'minutes':\n    case 'minute':\n    case 'mins':\n    case 'min':\n    case 'm':\n      return n * m\n    case 'seconds':\n    case 'second':\n    case 'secs':\n    case 'sec':\n    case 's':\n      return n * s\n    case 'milliseconds':\n    case 'millisecond':\n    case 'msecs':\n    case 'msec':\n    case 'ms':\n      return n\n    default:\n      return undefined\n  }\n}\n\n/**\n * Short format for `ms`.\n *\n * @param {Number} ms\n * @return {String}\n * @api private\n */\n\nfunction fmtShort(ms) {\n  if (ms >= d) {\n    return Math.round(ms / d) + 'd'\n  }\n  if (ms >= h) {\n    return Math.round(ms / h) + 'h'\n  }\n  if (ms >= m) {\n    return Math.round(ms / m) + 'm'\n  }\n  if (ms >= s) {\n    return Math.round(ms / s) + 's'\n  }\n  return ms + 'ms'\n}\n\n/**\n * Long format for `ms`.\n *\n * @param {Number} ms\n * @return {String}\n * @api private\n */\n\nfunction fmtLong(ms) {\n  return plural(ms, d, 'day') ||\n    plural(ms, h, 'hour') ||\n    plural(ms, m, 'minute') ||\n    plural(ms, s, 'second') ||\n    ms + ' ms'\n}\n\n/**\n * Pluralization helper.\n */\n\nfunction plural(ms, n, name) {\n  if (ms < n) {\n    return\n  }\n  if (ms < n * 1.5) {\n    return Math.floor(ms / n) + ' ' + name\n  }\n  return Math.ceil(ms / n) + ' ' + name + 's'\n}\n","// shim for using process in browser\nvar process = module.exports = {};\n\n// cached from whatever global is present so that test runners that stub it\n// don't break things.  But we need to wrap it in a try catch in case it is\n// wrapped in strict mode code which doesn't define any globals.  It's inside a\n// function because try/catches deoptimize in certain engines.\n\nvar cachedSetTimeout;\nvar cachedClearTimeout;\n\nfunction defaultSetTimout() {\n    throw new Error('setTimeout has not been defined');\n}\nfunction defaultClearTimeout () {\n    throw new Error('clearTimeout has not been defined');\n}\n(function () {\n    try {\n        if (typeof setTimeout === 'function') {\n            cachedSetTimeout = setTimeout;\n        } else {\n            cachedSetTimeout = defaultSetTimout;\n        }\n    } catch (e) {\n        cachedSetTimeout = defaultSetTimout;\n    }\n    try {\n        if (typeof clearTimeout === 'function') {\n            cachedClearTimeout = clearTimeout;\n        } else {\n            cachedClearTimeout = defaultClearTimeout;\n        }\n    } catch (e) {\n        cachedClearTimeout = defaultClearTimeout;\n    }\n} ())\nfunction runTimeout(fun) {\n    if (cachedSetTimeout === setTimeout) {\n        //normal enviroments in sane situations\n        return setTimeout(fun, 0);\n    }\n    // if setTimeout wasn't available but was latter defined\n    if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {\n        cachedSetTimeout = setTimeout;\n        return setTimeout(fun, 0);\n    }\n    try {\n        // when when somebody has screwed with setTimeout but no I.E. maddness\n        return cachedSetTimeout(fun, 0);\n    } catch(e){\n        try {\n            // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally\n            return cachedSetTimeout.call(null, fun, 0);\n        } catch(e){\n            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error\n            return cachedSetTimeout.call(this, fun, 0);\n        }\n    }\n\n\n}\nfunction runClearTimeout(marker) {\n    if (cachedClearTimeout === clearTimeout) {\n        //normal enviroments in sane situations\n        return clearTimeout(marker);\n    }\n    // if clearTimeout wasn't available but was latter defined\n    if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {\n        cachedClearTimeout = clearTimeout;\n        return clearTimeout(marker);\n    }\n    try {\n        // when when somebody has screwed with setTimeout but no I.E. maddness\n        return cachedClearTimeout(marker);\n    } catch (e){\n        try {\n            // When we are in I.E. but the script has been evaled so I.E. doesn't  trust the global object when called normally\n            return cachedClearTimeout.call(null, marker);\n        } catch (e){\n            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error.\n            // Some versions of I.E. have different rules for clearTimeout vs setTimeout\n            return cachedClearTimeout.call(this, marker);\n        }\n    }\n\n\n\n}\nvar queue = [];\nvar draining = false;\nvar currentQueue;\nvar queueIndex = -1;\n\nfunction cleanUpNextTick() {\n    if (!draining || !currentQueue) {\n        return;\n    }\n    draining = false;\n    if (currentQueue.length) {\n        queue = currentQueue.concat(queue);\n    } else {\n        queueIndex = -1;\n    }\n    if (queue.length) {\n        drainQueue();\n    }\n}\n\nfunction drainQueue() {\n    if (draining) {\n        return;\n    }\n    var timeout = runTimeout(cleanUpNextTick);\n    draining = true;\n\n    var len = queue.length;\n    while(len) {\n        currentQueue = queue;\n        queue = [];\n        while (++queueIndex < len) {\n            if (currentQueue) {\n                currentQueue[queueIndex].run();\n            }\n        }\n        queueIndex = -1;\n        len = queue.length;\n    }\n    currentQueue = null;\n    draining = false;\n    runClearTimeout(timeout);\n}\n\nprocess.nextTick = function (fun) {\n    var args = new Array(arguments.length - 1);\n    if (arguments.length > 1) {\n        for (var i = 1; i < arguments.length; i++) {\n            args[i - 1] = arguments[i];\n        }\n    }\n    queue.push(new Item(fun, args));\n    if (queue.length === 1 && !draining) {\n        runTimeout(drainQueue);\n    }\n};\n\n// v8 likes predictible objects\nfunction Item(fun, array) {\n    this.fun = fun;\n    this.array = array;\n}\nItem.prototype.run = function () {\n    this.fun.apply(null, this.array);\n};\nprocess.title = 'browser';\nprocess.browser = true;\nprocess.env = {};\nprocess.argv = [];\nprocess.version = ''; // empty string to avoid regexp issues\nprocess.versions = {};\n\nfunction noop() {}\n\nprocess.on = noop;\nprocess.addListener = noop;\nprocess.once = noop;\nprocess.off = noop;\nprocess.removeListener = noop;\nprocess.removeAllListeners = noop;\nprocess.emit = noop;\n\nprocess.binding = function (name) {\n    throw new Error('process.binding is not supported');\n};\n\nprocess.cwd = function () { return '/' };\nprocess.chdir = function (dir) {\n    throw new Error('process.chdir is not supported');\n};\nprocess.umask = function() { return 0; };\n","/*! https://mths.be/utf8js v2.1.2 by @mathias */\n;(function(root) {\n\n\t// Detect free variables `exports`\n\tvar freeExports = typeof exports == 'object' && exports;\n\n\t// Detect free variable `module`\n\tvar freeModule = typeof module == 'object' && module &&\n\t\tmodule.exports == freeExports && module;\n\n\t// Detect free variable `global`, from Node.js or Browserified code,\n\t// and use it as `root`\n\tvar freeGlobal = typeof global == 'object' && global;\n\tif (freeGlobal.global === freeGlobal || freeGlobal.window === freeGlobal) {\n\t\troot = freeGlobal;\n\t}\n\n\t/*--------------------------------------------------------------------------*/\n\n\tvar stringFromCharCode = String.fromCharCode;\n\n\t// Taken from https://mths.be/punycode\n\tfunction ucs2decode(string) {\n\t\tvar output = [];\n\t\tvar counter = 0;\n\t\tvar length = string.length;\n\t\tvar value;\n\t\tvar extra;\n\t\twhile (counter < length) {\n\t\t\tvalue = string.charCodeAt(counter++);\n\t\t\tif (value >= 0xD800 && value <= 0xDBFF && counter < length) {\n\t\t\t\t// high surrogate, and there is a next character\n\t\t\t\textra = string.charCodeAt(counter++);\n\t\t\t\tif ((extra & 0xFC00) == 0xDC00) { // low surrogate\n\t\t\t\t\toutput.push(((value & 0x3FF) << 10) + (extra & 0x3FF) + 0x10000);\n\t\t\t\t} else {\n\t\t\t\t\t// unmatched surrogate; only append this code unit, in case the next\n\t\t\t\t\t// code unit is the high surrogate of a surrogate pair\n\t\t\t\t\toutput.push(value);\n\t\t\t\t\tcounter--;\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\toutput.push(value);\n\t\t\t}\n\t\t}\n\t\treturn output;\n\t}\n\n\t// Taken from https://mths.be/punycode\n\tfunction ucs2encode(array) {\n\t\tvar length = array.length;\n\t\tvar index = -1;\n\t\tvar value;\n\t\tvar output = '';\n\t\twhile (++index < length) {\n\t\t\tvalue = array[index];\n\t\t\tif (value > 0xFFFF) {\n\t\t\t\tvalue -= 0x10000;\n\t\t\t\toutput += stringFromCharCode(value >>> 10 & 0x3FF | 0xD800);\n\t\t\t\tvalue = 0xDC00 | value & 0x3FF;\n\t\t\t}\n\t\t\toutput += stringFromCharCode(value);\n\t\t}\n\t\treturn output;\n\t}\n\n\tfunction checkScalarValue(codePoint) {\n\t\tif (codePoint >= 0xD800 && codePoint <= 0xDFFF) {\n\t\t\tthrow Error(\n\t\t\t\t'Lone surrogate U+' + codePoint.toString(16).toUpperCase() +\n\t\t\t\t' is not a scalar value'\n\t\t\t);\n\t\t}\n\t}\n\t/*--------------------------------------------------------------------------*/\n\n\tfunction createByte(codePoint, shift) {\n\t\treturn stringFromCharCode(((codePoint >> shift) & 0x3F) | 0x80);\n\t}\n\n\tfunction encodeCodePoint(codePoint) {\n\t\tif ((codePoint & 0xFFFFFF80) == 0) { // 1-byte sequence\n\t\t\treturn stringFromCharCode(codePoint);\n\t\t}\n\t\tvar symbol = '';\n\t\tif ((codePoint & 0xFFFFF800) == 0) { // 2-byte sequence\n\t\t\tsymbol = stringFromCharCode(((codePoint >> 6) & 0x1F) | 0xC0);\n\t\t}\n\t\telse if ((codePoint & 0xFFFF0000) == 0) { // 3-byte sequence\n\t\t\tcheckScalarValue(codePoint);\n\t\t\tsymbol = stringFromCharCode(((codePoint >> 12) & 0x0F) | 0xE0);\n\t\t\tsymbol += createByte(codePoint, 6);\n\t\t}\n\t\telse if ((codePoint & 0xFFE00000) == 0) { // 4-byte sequence\n\t\t\tsymbol = stringFromCharCode(((codePoint >> 18) & 0x07) | 0xF0);\n\t\t\tsymbol += createByte(codePoint, 12);\n\t\t\tsymbol += createByte(codePoint, 6);\n\t\t}\n\t\tsymbol += stringFromCharCode((codePoint & 0x3F) | 0x80);\n\t\treturn symbol;\n\t}\n\n\tfunction utf8encode(string) {\n\t\tvar codePoints = ucs2decode(string);\n\t\tvar length = codePoints.length;\n\t\tvar index = -1;\n\t\tvar codePoint;\n\t\tvar byteString = '';\n\t\twhile (++index < length) {\n\t\t\tcodePoint = codePoints[index];\n\t\t\tbyteString += encodeCodePoint(codePoint);\n\t\t}\n\t\treturn byteString;\n\t}\n\n\t/*--------------------------------------------------------------------------*/\n\n\tfunction readContinuationByte() {\n\t\tif (byteIndex >= byteCount) {\n\t\t\tthrow Error('Invalid byte index');\n\t\t}\n\n\t\tvar continuationByte = byteArray[byteIndex] & 0xFF;\n\t\tbyteIndex++;\n\n\t\tif ((continuationByte & 0xC0) == 0x80) {\n\t\t\treturn continuationByte & 0x3F;\n\t\t}\n\n\t\t// If we end up here, it’s not a continuation byte\n\t\tthrow Error('Invalid continuation byte');\n\t}\n\n\tfunction decodeSymbol() {\n\t\tvar byte1;\n\t\tvar byte2;\n\t\tvar byte3;\n\t\tvar byte4;\n\t\tvar codePoint;\n\n\t\tif (byteIndex > byteCount) {\n\t\t\tthrow Error('Invalid byte index');\n\t\t}\n\n\t\tif (byteIndex == byteCount) {\n\t\t\treturn false;\n\t\t}\n\n\t\t// Read first byte\n\t\tbyte1 = byteArray[byteIndex] & 0xFF;\n\t\tbyteIndex++;\n\n\t\t// 1-byte sequence (no continuation bytes)\n\t\tif ((byte1 & 0x80) == 0) {\n\t\t\treturn byte1;\n\t\t}\n\n\t\t// 2-byte sequence\n\t\tif ((byte1 & 0xE0) == 0xC0) {\n\t\t\tbyte2 = readContinuationByte();\n\t\t\tcodePoint = ((byte1 & 0x1F) << 6) | byte2;\n\t\t\tif (codePoint >= 0x80) {\n\t\t\t\treturn codePoint;\n\t\t\t} else {\n\t\t\t\tthrow Error('Invalid continuation byte');\n\t\t\t}\n\t\t}\n\n\t\t// 3-byte sequence (may include unpaired surrogates)\n\t\tif ((byte1 & 0xF0) == 0xE0) {\n\t\t\tbyte2 = readContinuationByte();\n\t\t\tbyte3 = readContinuationByte();\n\t\t\tcodePoint = ((byte1 & 0x0F) << 12) | (byte2 << 6) | byte3;\n\t\t\tif (codePoint >= 0x0800) {\n\t\t\t\tcheckScalarValue(codePoint);\n\t\t\t\treturn codePoint;\n\t\t\t} else {\n\t\t\t\tthrow Error('Invalid continuation byte');\n\t\t\t}\n\t\t}\n\n\t\t// 4-byte sequence\n\t\tif ((byte1 & 0xF8) == 0xF0) {\n\t\t\tbyte2 = readContinuationByte();\n\t\t\tbyte3 = readContinuationByte();\n\t\t\tbyte4 = readContinuationByte();\n\t\t\tcodePoint = ((byte1 & 0x07) << 0x12) | (byte2 << 0x0C) |\n\t\t\t\t(byte3 << 0x06) | byte4;\n\t\t\tif (codePoint >= 0x010000 && codePoint <= 0x10FFFF) {\n\t\t\t\treturn codePoint;\n\t\t\t}\n\t\t}\n\n\t\tthrow Error('Invalid UTF-8 detected');\n\t}\n\n\tvar byteArray;\n\tvar byteCount;\n\tvar byteIndex;\n\tfunction utf8decode(byteString) {\n\t\tbyteArray = ucs2decode(byteString);\n\t\tbyteCount = byteArray.length;\n\t\tbyteIndex = 0;\n\t\tvar codePoints = [];\n\t\tvar tmp;\n\t\twhile ((tmp = decodeSymbol()) !== false) {\n\t\t\tcodePoints.push(tmp);\n\t\t}\n\t\treturn ucs2encode(codePoints);\n\t}\n\n\t/*--------------------------------------------------------------------------*/\n\n\tvar utf8 = {\n\t\t'version': '2.1.2',\n\t\t'encode': utf8encode,\n\t\t'decode': utf8decode\n\t};\n\n\t// Some AMD build optimizers, like r.js, check for specific condition patterns\n\t// like the following:\n\tif (\n\t\ttypeof define == 'function' &&\n\t\ttypeof define.amd == 'object' &&\n\t\tdefine.amd\n\t) {\n\t\tdefine(function() {\n\t\t\treturn utf8;\n\t\t});\n\t}\telse if (freeExports && !freeExports.nodeType) {\n\t\tif (freeModule) { // in Node.js or RingoJS v0.8.0+\n\t\t\tfreeModule.exports = utf8;\n\t\t} else { // in Narwhal or RingoJS v0.7.0-\n\t\t\tvar object = {};\n\t\t\tvar hasOwnProperty = object.hasOwnProperty;\n\t\t\tfor (var key in utf8) {\n\t\t\t\thasOwnProperty.call(utf8, key) && (freeExports[key] = utf8[key]);\n\t\t\t}\n\t\t}\n\t} else { // in Rhino or a web browser\n\t\troot.utf8 = utf8;\n\t}\n\n}(this));\n"]}"} \ No newline at end of file diff --git a/dist/GitHub.bundle.min.js b/dist/GitHub.bundle.min.js index 33a983b1..ed9ba183 100644 --- a/dist/GitHub.bundle.min.js +++ b/dist/GitHub.bundle.min.js @@ -1,4 +1,4 @@ !function(e){if("object"==typeof exports&&"undefined"!=typeof module)module.exports=e();else if("function"==typeof define&&define.amd)define([],e);else{var t;t="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof self?self:this,t.GitHub=e()}}(function(){var e;return function e(t,r,n){function o(u,s){if(!r[u]){if(!t[u]){var a="function"==typeof require&&require;if(!s&&a)return a(u,!0);if(i)return i(u,!0);var f=new Error("Cannot find module '"+u+"'");throw f.code="MODULE_NOT_FOUND",f}var c=r[u]={exports:{}};t[u][0].call(c.exports,function(e){var r=t[u][1][e];return o(r?r:e)},c,c.exports,e,t,r,n)}return r[u].exports}for(var i="function"==typeof require&&require,u=0;u1&&void 0!==arguments[1]?arguments[1]:"https://api.github.com";o(this,e),this.__apiBase=r,this.__auth=t||{}}return i(e,[{key:"getGist",value:function(e){return new s.default(e,this.__auth,this.__apiBase)}},{key:"getUser",value:function(e){return new f.default(e,this.__auth,this.__apiBase)}},{key:"getOrganization",value:function(e){return new v.default(e,this.__auth,this.__apiBase)}},{key:"getTeam",value:function(e){return new w.default(e,this.__auth,this.__apiBase)}},{key:"getRepo",value:function(e,t){return new g.default(this._getFullName(e,t),this.__auth,this.__apiBase)}},{key:"getIssues",value:function(e,t){return new l.default(this._getFullName(e,t),this.__auth,this.__apiBase)}},{key:"search",value:function(e){return new p.default(e,this.__auth,this.__apiBase)}},{key:"getRateLimit",value:function(){return new y.default(this.__auth,this.__apiBase)}},{key:"getMarkdown",value:function(){return new T.default(this.__auth,this.__apiBase)}},{key:"getProject",value:function(e){return new A.default(e,this.__auth,this.__apiBase)}},{key:"_getFullName",value:function(e,t){var r=e;return t&&(r=e+"/"+t),r}}]),e}();t.exports=P},{"./Gist":1,"./Issue":3,"./Markdown":4,"./Organization":5,"./Project":6,"./RateLimit":7,"./Repository":8,"./Search":10,"./Team":11,"./User":12}],3:[function(e,t,r){"use strict";function n(e){return e&&e.__esModule?e:{default:e}}function o(e,t){if(!(e instanceof t))throw new TypeError("Cannot call a class as a function")}function i(e,t){if(!e)throw new ReferenceError("this hasn't been initialised - super() hasn't been called");return!t||"object"!=typeof t&&"function"!=typeof t?e:t}function u(e,t){if("function"!=typeof t&&null!==t)throw new TypeError("Super expression must either be null or a function, not "+typeof t);e.prototype=Object.create(t&&t.prototype,{constructor:{value:e,enumerable:!1,writable:!0,configurable:!0}}),t&&(Object.setPrototypeOf?Object.setPrototypeOf(e,t):e.__proto__=t)}var s=function(){function e(e,t){for(var r=0;r0&&void 0!==arguments[0]?arguments[0]:"",t=e.split(/\s*,\s*/);return t.reduce(function(e,t){return t.search(/rel="next"/)!==-1?(t.match(/<(.*)>/)||[])[1]:e},void 0)}function c(e,t){return function(r){var n=void 0;if(r.hasOwnProperty("config")){var o=r.response,i=o.status,u=o.statusText,s=r.config,a=s.method,f=s.url,c=i+" error making request "+a+" "+f+': "'+u+'"';n=new v(c,t,r),m(c+" "+JSON.stringify(r.data))}else n=r;if(!e)throw m("throwing error"),n;m("going to error callback"),e(n)}}var l="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(e){return typeof e}:function(e){return e&&"function"==typeof Symbol&&e.constructor===Symbol&&e!==Symbol.prototype?"symbol":typeof e},h=function(){function e(e,t){for(var r=0;r0&&void 0!==arguments[0]?arguments[0]:{};return e.visibility||e.affiliation||(e.type=e.type||"all"),e.sort=e.sort||"updated",e.per_page=e.per_page||"100",e}},{key:"_dateToISO",value:function(e){return e&&e instanceof Date&&(e=e.toISOString()),e}},{key:"_request",value:function(e,t,r,n,o){var i=this.__getURL(t),u=(r||{}).AcceptHeader;u&&delete r.AcceptHeader;var s=this.__getRequestHeaders(o,u),f={},h=r&&"object"===("undefined"==typeof r?"undefined":l(r))&&a(e);h&&(f=r,r=void 0);var p={url:i,method:e,headers:s,params:f,data:r,responseType:o?"text":"json"};m(p.method+" to "+p.url);var y=(0,d.default)(p).catch(c(n,t));return n&&y.then(function(e){e.data&&Object.keys(e.data).length>0?n(null,e.data,e):"GET"!==p.method&&Object.keys(e.data).length<1?n(null,e.status<300,e):n(null,e.data,e)}),y}},{key:"_request204or404",value:function(e,t,r){var n=arguments.length>3&&void 0!==arguments[3]?arguments[3]:"GET";return this._request(n,e,t).then(function(e){return r&&r(null,!0,e),!0},function(e){if(404===e.response.status)return r&&r(null,!1,e),!1;throw r&&r(e),e})}},{key:"_requestAllPages",value:function(e,t,r,n){var i=this;return n=n||[],this._request("GET",e,t).then(function(u){var s,a=void 0;if(u.data instanceof Array)a=u.data;else{if(!(u.data.items instanceof Array)){var c="cannot figure out how to append "+u.data+" to the result set";throw new v(c,e,u)}a=u.data.items}(s=n).push.apply(s,o(a));var l=f(u.headers.link);return l&&"number"!=typeof t.page?(m("getting next page: "+l),i._requestAllPages(l,t,r,n)):(r&&r(null,n,u),u.data=n,u)}).catch(c(r,e))}}]),e}();t.exports=b;var w=["GET","HEAD","DELETE"]},{axios:13,debug:40,"js-base64":44}],10:[function(e,t,r){"use strict";function n(e){return e&&e.__esModule?e:{default:e -}}function o(e,t){if(!(e instanceof t))throw new TypeError("Cannot call a class as a function")}function i(e,t){if(!e)throw new ReferenceError("this hasn't been initialised - super() hasn't been called");return!t||"object"!=typeof t&&"function"!=typeof t?e:t}function u(e,t){if("function"!=typeof t&&null!==t)throw new TypeError("Super expression must either be null or a function, not "+typeof t);e.prototype=Object.create(t&&t.prototype,{constructor:{value:e,enumerable:!1,writable:!0,configurable:!0}}),t&&(Object.setPrototypeOf?Object.setPrototypeOf(e,t):e.__proto__=t)}var s=function(){function e(e,t){for(var r=0;r1&&void 0!==arguments[1]?arguments[1]:{},n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:void 0,o={};return Object.keys(this.__defaults).forEach(function(e){o[e]=t.__defaults[e]}),Object.keys(r).forEach(function(e){o[e]=r[e]}),h("searching "+e+" with options:",o),this._requestAllPages("/search/"+e,o,n)}},{key:"forRepositories",value:function(e,t){return this._search("repositories",e,t)}},{key:"forCode",value:function(e,t){return this._search("code",e,t)}},{key:"forIssues",value:function(e,t){return this._search("issues",e,t)}},{key:"forUsers",value:function(e,t){return this._search("users",e,t)}}]),t}(f.default);t.exports=p},{"./Requestable":9,debug:40}],11:[function(e,t,r){"use strict";function n(e){return e&&e.__esModule?e:{default:e}}function o(e,t){if(!(e instanceof t))throw new TypeError("Cannot call a class as a function")}function i(e,t){if(!e)throw new ReferenceError("this hasn't been initialised - super() hasn't been called");return!t||"object"!=typeof t&&"function"!=typeof t?e:t}function u(e,t){if("function"!=typeof t&&null!==t)throw new TypeError("Super expression must either be null or a function, not "+typeof t);e.prototype=Object.create(t&&t.prototype,{constructor:{value:e,enumerable:!1,writable:!0,configurable:!0}}),t&&(Object.setPrototypeOf?Object.setPrototypeOf(e,t):e.__proto__=t)}var s=function(){function e(e,t){for(var r=0;r=200&&e<300}};f.headers={common:{Accept:"application/json, text/plain, */*"}},i.forEach(["delete","get","head"],function(e){f.headers[e]={}}),i.forEach(["post","put","patch"],function(e){f.headers[e]=i.merge(a)}),t.exports=f}).call(this,e("_process"))},{"./adapters/http":14,"./adapters/xhr":14,"./helpers/normalizeHeaderName":34,"./utils":37,_process:46}],27:[function(e,t,r){"use strict";t.exports=function(e,t){return function(){for(var r=new Array(arguments.length),n=0;n>8-s%1*8)){if(r=o.charCodeAt(s+=.75),r>255)throw new n;t=t<<8|r}return u}var i="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";n.prototype=new Error,n.prototype.code=5,n.prototype.name="InvalidCharacterError",t.exports=o},{}],29:[function(e,t,r){"use strict";function n(e){return encodeURIComponent(e).replace(/%40/gi,"@").replace(/%3A/gi,":").replace(/%24/g,"$").replace(/%2C/gi,",").replace(/%20/g,"+").replace(/%5B/gi,"[").replace(/%5D/gi,"]")}var o=e("./../utils");t.exports=function(e,t,r){if(!t)return e;var i;if(r)i=r(t);else if(o.isURLSearchParams(t))i=t.toString();else{var u=[];o.forEach(t,function(e,t){null!==e&&"undefined"!=typeof e&&(o.isArray(e)&&(t+="[]"),o.isArray(e)||(e=[e]),o.forEach(e,function(e){o.isDate(e)?e=e.toISOString():o.isObject(e)&&(e=JSON.stringify(e)),u.push(n(t)+"="+n(e))}))}),i=u.join("&")}return i&&(e+=(e.indexOf("?")===-1?"?":"&")+i),e}},{"./../utils":37}],30:[function(e,t,r){"use strict";t.exports=function(e,t){return e.replace(/\/+$/,"")+"/"+t.replace(/^\/+/,"")}},{}],31:[function(e,t,r){"use strict";var n=e("./../utils");t.exports=n.isStandardBrowserEnv()?function(){return{write:function(e,t,r,o,i,u){var s=[];s.push(e+"="+encodeURIComponent(t)),n.isNumber(r)&&s.push("expires="+new Date(r).toGMTString()),n.isString(o)&&s.push("path="+o),n.isString(i)&&s.push("domain="+i),u===!0&&s.push("secure"),document.cookie=s.join("; ")},read:function(e){var t=document.cookie.match(new RegExp("(^|;\\s*)("+e+")=([^;]*)"));return t?decodeURIComponent(t[3]):null},remove:function(e){this.write(e,"",Date.now()-864e5)}}}():function(){return{write:function(){},read:function(){return null},remove:function(){}}}()},{"./../utils":37}],32:[function(e,t,r){"use strict";t.exports=function(e){return/^([a-z][a-z\d\+\-\.]*:)?\/\//i.test(e)}},{}],33:[function(e,t,r){"use strict";var n=e("./../utils");t.exports=n.isStandardBrowserEnv()?function(){function e(e){var t=e;return r&&(o.setAttribute("href",t),t=o.href),o.setAttribute("href",t),{href:o.href,protocol:o.protocol?o.protocol.replace(/:$/,""):"",host:o.host,search:o.search?o.search.replace(/^\?/,""):"",hash:o.hash?o.hash.replace(/^#/,""):"",hostname:o.hostname,port:o.port,pathname:"/"===o.pathname.charAt(0)?o.pathname:"/"+o.pathname}}var t,r=/(msie|trident)/i.test(navigator.userAgent),o=document.createElement("a");return t=e(window.location.href),function(r){var o=n.isString(r)?e(r):r;return o.protocol===t.protocol&&o.host===t.host}}():function(){return function(){return!0}}()},{"./../utils":37}],34:[function(e,t,r){"use strict";var n=e("../utils");t.exports=function(e,t){n.forEach(e,function(r,n){n!==t&&n.toUpperCase()===t.toUpperCase()&&(e[t]=r,delete e[n])})}},{"../utils":37}],35:[function(e,t,r){"use strict";var n=e("./../utils");t.exports=function(e){var t,r,o,i={};return e?(n.forEach(e.split("\n"),function(e){o=e.indexOf(":"),t=n.trim(e.substr(0,o)).toLowerCase(),r=n.trim(e.substr(o+1)),t&&(i[t]=i[t]?i[t]+", "+r:r)}),i):i}},{"./../utils":37}],36:[function(e,t,r){"use strict";t.exports=function(e){return function(t){return e.apply(null,t)}}},{}],37:[function(e,t,r){"use strict";function n(e){return"[object Array]"===T.call(e)}function o(e){return"[object ArrayBuffer]"===T.call(e)}function i(e){return"undefined"!=typeof FormData&&e instanceof FormData}function u(e){var t;return t="undefined"!=typeof ArrayBuffer&&ArrayBuffer.isView?ArrayBuffer.isView(e):e&&e.buffer&&e.buffer instanceof ArrayBuffer}function s(e){return"string"==typeof e}function a(e){return"number"==typeof e}function f(e){return"undefined"==typeof e}function c(e){return null!==e&&"object"==typeof e}function l(e){return"[object Date]"===T.call(e)}function h(e){return"[object File]"===T.call(e)}function p(e){return"[object Blob]"===T.call(e)}function d(e){return"[object Function]"===T.call(e)}function y(e){return c(e)&&d(e.pipe)}function _(e){return"undefined"!=typeof URLSearchParams&&e instanceof URLSearchParams}function g(e){return e.replace(/^\s*/,"").replace(/\s*$/,"")}function m(){return"undefined"!=typeof window&&"undefined"!=typeof document&&"function"==typeof document.createElement}function v(e,t){if(null!==e&&"undefined"!=typeof e)if("object"==typeof e||n(e)||(e=[e]),n(e))for(var r=0,o=e.length;r0)throw new Error("Invalid string. Length must be a multiple of 4");return"="===e[t-2]?2:"="===e[t-1]?1:0}function o(e){return 3*e.length/4-n(e)}function i(e){var t,r,o,i,u,s,a=e.length;u=n(e),s=new l(3*a/4-u),o=u>0?a-4:a;var f=0;for(t=0,r=0;t>16&255,s[f++]=i>>8&255,s[f++]=255&i;return 2===u?(i=c[e.charCodeAt(t)]<<2|c[e.charCodeAt(t+1)]>>4,s[f++]=255&i):1===u&&(i=c[e.charCodeAt(t)]<<10|c[e.charCodeAt(t+1)]<<4|c[e.charCodeAt(t+2)]>>2,s[f++]=i>>8&255,s[f++]=255&i),s}function u(e){return f[e>>18&63]+f[e>>12&63]+f[e>>6&63]+f[63&e]}function s(e,t,r){for(var n,o=[],i=t;ic?c:a+u));return 1===n?(t=e[r-1],o+=f[t>>2],o+=f[t<<4&63],o+="=="):2===n&&(t=(e[r-2]<<8)+e[r-1],o+=f[t>>10],o+=f[t>>4&63],o+=f[t<<2&63],o+="="),i.push(o),i.join("")}r.byteLength=o,r.toByteArray=i,r.fromByteArray=a;for(var f=[],c=[],l="undefined"!=typeof Uint8Array?Uint8Array:Array,h="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/",p=0,d=h.length;p=o())throw new RangeError("Attempt to allocate Buffer larger than maximum size: 0x"+o().toString(16)+" bytes");return 0|e}function _(e){return+e!=e&&(e=0),u.alloc(+e)}function g(e,t){if(u.isBuffer(e))return e.length;if("undefined"!=typeof ArrayBuffer&&"function"==typeof ArrayBuffer.isView&&(ArrayBuffer.isView(e)||e instanceof ArrayBuffer))return e.byteLength;"string"!=typeof e&&(e=""+e);var r=e.length;if(0===r)return 0;for(var n=!1;;)switch(t){case"ascii":case"latin1":case"binary":return r;case"utf8":case"utf-8":case void 0:return z(e).length;case"ucs2":case"ucs-2":case"utf16le":case"utf-16le":return 2*r;case"hex":return r>>>1;case"base64":return V(e).length;default:if(n)return z(e).length;t=(""+t).toLowerCase(),n=!0}}function m(e,t,r){var n=!1;if((void 0===t||t<0)&&(t=0),t>this.length)return"";if((void 0===r||r>this.length)&&(r=this.length),r<=0)return"";if(r>>>=0,t>>>=0,r<=t)return"";for(e||(e="utf8");;)switch(e){case"hex":return x(this,t,r);case"utf8":case"utf-8":return q(this,t,r);case"ascii":return C(this,t,r);case"latin1":case"binary":return j(this,t,r);case"base64":return O(this,t,r);case"ucs2":case"ucs-2":case"utf16le":case"utf-16le":return B(this,t,r);default:if(n)throw new TypeError("Unknown encoding: "+e);e=(e+"").toLowerCase(),n=!0}}function v(e,t,r){var n=e[t];e[t]=e[r],e[r]=n}function b(e,t,r,n,o){if(0===e.length)return-1;if("string"==typeof r?(n=r,r=0):r>2147483647?r=2147483647:r<-2147483648&&(r=-2147483648),r=+r,isNaN(r)&&(r=o?0:e.length-1),r<0&&(r=e.length+r),r>=e.length){if(o)return-1;r=e.length-1}else if(r<0){if(!o)return-1;r=0}if("string"==typeof t&&(t=u.from(t,n)),u.isBuffer(t))return 0===t.length?-1:w(e,t,r,n,o);if("number"==typeof t)return t&=255,u.TYPED_ARRAY_SUPPORT&&"function"==typeof Uint8Array.prototype.indexOf?o?Uint8Array.prototype.indexOf.call(e,t,r):Uint8Array.prototype.lastIndexOf.call(e,t,r):w(e,[t],r,n,o);throw new TypeError("val must be string, number or Buffer")}function w(e,t,r,n,o){function i(e,t){return 1===u?e[t]:e.readUInt16BE(t*u)}var u=1,s=e.length,a=t.length;if(void 0!==n&&(n=String(n).toLowerCase(),"ucs2"===n||"ucs-2"===n||"utf16le"===n||"utf-16le"===n)){if(e.length<2||t.length<2)return-1;u=2,s/=2,a/=2,r/=2}var f;if(o){var c=-1;for(f=r;fs&&(r=s-a),f=r;f>=0;f--){for(var l=!0,h=0;ho&&(n=o)):n=o;var i=t.length;if(i%2!==0)throw new TypeError("Invalid hex string");n>i/2&&(n=i/2);for(var u=0;u239?4:i>223?3:i>191?2:1;if(o+s<=r){var a,f,c,l;switch(s){case 1:i<128&&(u=i);break;case 2:a=e[o+1],128===(192&a)&&(l=(31&i)<<6|63&a,l>127&&(u=l));break;case 3:a=e[o+1],f=e[o+2],128===(192&a)&&128===(192&f)&&(l=(15&i)<<12|(63&a)<<6|63&f,l>2047&&(l<55296||l>57343)&&(u=l));break;case 4:a=e[o+1],f=e[o+2],c=e[o+3],128===(192&a)&&128===(192&f)&&128===(192&c)&&(l=(15&i)<<18|(63&a)<<12|(63&f)<<6|63&c,l>65535&&l<1114112&&(u=l))}}null===u?(u=65533,s=1):u>65535&&(u-=65536,n.push(u>>>10&1023|55296),u=56320|1023&u),n.push(u),o+=s}return S(n)}function S(e){var t=e.length;if(t<=ee)return String.fromCharCode.apply(String,e);for(var r="",n=0;nn)&&(r=n);for(var o="",i=t;ir)throw new RangeError("Trying to access beyond buffer length")}function I(e,t,r,n,o,i){if(!u.isBuffer(e))throw new TypeError('"buffer" argument must be a Buffer instance');if(t>o||te.length)throw new RangeError("Index out of range")}function L(e,t,r,n){t<0&&(t=65535+t+1);for(var o=0,i=Math.min(e.length-r,2);o>>8*(n?o:1-o)}function D(e,t,r,n){t<0&&(t=4294967295+t+1);for(var o=0,i=Math.min(e.length-r,4);o>>8*(n?o:3-o)&255}function M(e,t,r,n,o,i){if(r+n>e.length)throw new RangeError("Index out of range");if(r<0)throw new RangeError("Index out of range")}function G(e,t,r,n,o){return o||M(e,t,r,4,3.4028234663852886e38,-3.4028234663852886e38),Z.write(e,t,r,n,23,4),r+4}function N(e,t,r,n,o){return o||M(e,t,r,8,1.7976931348623157e308,-1.7976931348623157e308),Z.write(e,t,r,n,52,8),r+8}function H(e){if(e=Y(e).replace(te,""),e.length<2)return"";for(;e.length%4!==0;)e+="=";return e}function Y(e){return e.trim?e.trim():e.replace(/^\s+|\s+$/g,"")}function F(e){return e<16?"0"+e.toString(16):e.toString(16)}function z(e,t){t=t||1/0;for(var r,n=e.length,o=null,i=[],u=0;u55295&&r<57344){if(!o){if(r>56319){(t-=3)>-1&&i.push(239,191,189);continue}if(u+1===n){(t-=3)>-1&&i.push(239,191,189);continue}o=r;continue}if(r<56320){(t-=3)>-1&&i.push(239,191,189),o=r;continue}r=(o-55296<<10|r-56320)+65536}else o&&(t-=3)>-1&&i.push(239,191,189);if(o=null,r<128){if((t-=1)<0)break;i.push(r)}else if(r<2048){if((t-=2)<0)break;i.push(r>>6|192,63&r|128)}else if(r<65536){if((t-=3)<0)break;i.push(r>>12|224,r>>6&63|128,63&r|128)}else{if(!(r<1114112))throw new Error("Invalid code point");if((t-=4)<0)break;i.push(r>>18|240,r>>12&63|128,r>>6&63|128,63&r|128)}}return i}function J(e){for(var t=[],r=0;r>8,o=r%256,i.push(o),i.push(n);return i}function V(e){return $.toByteArray(H(e))}function W(e,t,r,n){for(var o=0;o=t.length||o>=e.length);++o)t[o+r]=e[o];return o}function K(e){return e!==e}var $=e("base64-js"),Z=e("ieee754"),Q=e("isarray");r.Buffer=u,r.SlowBuffer=_,r.INSPECT_MAX_BYTES=50,u.TYPED_ARRAY_SUPPORT=void 0!==t.TYPED_ARRAY_SUPPORT?t.TYPED_ARRAY_SUPPORT:n(),r.kMaxLength=o(),u.poolSize=8192,u._augment=function(e){return e.__proto__=u.prototype,e},u.from=function(e,t,r){return s(null,e,t,r)},u.TYPED_ARRAY_SUPPORT&&(u.prototype.__proto__=Uint8Array.prototype,u.__proto__=Uint8Array,"undefined"!=typeof Symbol&&Symbol.species&&u[Symbol.species]===u&&Object.defineProperty(u,Symbol.species,{value:null,configurable:!0})),u.alloc=function(e,t,r){ -return f(null,e,t,r)},u.allocUnsafe=function(e){return c(null,e)},u.allocUnsafeSlow=function(e){return c(null,e)},u.isBuffer=function(e){return!(null==e||!e._isBuffer)},u.compare=function(e,t){if(!u.isBuffer(e)||!u.isBuffer(t))throw new TypeError("Arguments must be Buffers");if(e===t)return 0;for(var r=e.length,n=t.length,o=0,i=Math.min(r,n);o0&&(e=this.toString("hex",0,t).match(/.{2}/g).join(" "),this.length>t&&(e+=" ... ")),""},u.prototype.compare=function(e,t,r,n,o){if(!u.isBuffer(e))throw new TypeError("Argument must be a Buffer");if(void 0===t&&(t=0),void 0===r&&(r=e?e.length:0),void 0===n&&(n=0),void 0===o&&(o=this.length),t<0||r>e.length||n<0||o>this.length)throw new RangeError("out of range index");if(n>=o&&t>=r)return 0;if(n>=o)return-1;if(t>=r)return 1;if(t>>>=0,r>>>=0,n>>>=0,o>>>=0,this===e)return 0;for(var i=o-n,s=r-t,a=Math.min(i,s),f=this.slice(n,o),c=e.slice(t,r),l=0;lo)&&(r=o),e.length>0&&(r<0||t<0)||t>this.length)throw new RangeError("Attempt to write outside buffer bounds");n||(n="utf8");for(var i=!1;;)switch(n){case"hex":return E(this,e,t,r);case"utf8":case"utf-8":return T(this,e,t,r);case"ascii":return k(this,e,t,r);case"latin1":case"binary":return A(this,e,t,r);case"base64":return P(this,e,t,r);case"ucs2":case"ucs-2":case"utf16le":case"utf-16le":return R(this,e,t,r);default:if(i)throw new TypeError("Unknown encoding: "+n);n=(""+n).toLowerCase(),i=!0}},u.prototype.toJSON=function(){return{type:"Buffer",data:Array.prototype.slice.call(this._arr||this,0)}};var ee=4096;u.prototype.slice=function(e,t){var r=this.length;e=~~e,t=void 0===t?r:~~t,e<0?(e+=r,e<0&&(e=0)):e>r&&(e=r),t<0?(t+=r,t<0&&(t=0)):t>r&&(t=r),t0&&(o*=256);)n+=this[e+--t]*o;return n},u.prototype.readUInt8=function(e,t){return t||U(e,1,this.length),this[e]},u.prototype.readUInt16LE=function(e,t){return t||U(e,2,this.length),this[e]|this[e+1]<<8},u.prototype.readUInt16BE=function(e,t){return t||U(e,2,this.length),this[e]<<8|this[e+1]},u.prototype.readUInt32LE=function(e,t){return t||U(e,4,this.length),(this[e]|this[e+1]<<8|this[e+2]<<16)+16777216*this[e+3]},u.prototype.readUInt32BE=function(e,t){return t||U(e,4,this.length),16777216*this[e]+(this[e+1]<<16|this[e+2]<<8|this[e+3])},u.prototype.readIntLE=function(e,t,r){e|=0,t|=0,r||U(e,t,this.length);for(var n=this[e],o=1,i=0;++i=o&&(n-=Math.pow(2,8*t)),n},u.prototype.readIntBE=function(e,t,r){e|=0,t|=0,r||U(e,t,this.length);for(var n=t,o=1,i=this[e+--n];n>0&&(o*=256);)i+=this[e+--n]*o;return o*=128,i>=o&&(i-=Math.pow(2,8*t)),i},u.prototype.readInt8=function(e,t){return t||U(e,1,this.length),128&this[e]?(255-this[e]+1)*-1:this[e]},u.prototype.readInt16LE=function(e,t){t||U(e,2,this.length);var r=this[e]|this[e+1]<<8;return 32768&r?4294901760|r:r},u.prototype.readInt16BE=function(e,t){t||U(e,2,this.length);var r=this[e+1]|this[e]<<8;return 32768&r?4294901760|r:r},u.prototype.readInt32LE=function(e,t){return t||U(e,4,this.length),this[e]|this[e+1]<<8|this[e+2]<<16|this[e+3]<<24},u.prototype.readInt32BE=function(e,t){return t||U(e,4,this.length),this[e]<<24|this[e+1]<<16|this[e+2]<<8|this[e+3]},u.prototype.readFloatLE=function(e,t){return t||U(e,4,this.length),Z.read(this,e,!0,23,4)},u.prototype.readFloatBE=function(e,t){return t||U(e,4,this.length),Z.read(this,e,!1,23,4)},u.prototype.readDoubleLE=function(e,t){return t||U(e,8,this.length),Z.read(this,e,!0,52,8)},u.prototype.readDoubleBE=function(e,t){return t||U(e,8,this.length),Z.read(this,e,!1,52,8)},u.prototype.writeUIntLE=function(e,t,r,n){if(e=+e,t|=0,r|=0,!n){var o=Math.pow(2,8*r)-1;I(this,e,t,r,o,0)}var i=1,u=0;for(this[t]=255&e;++u=0&&(u*=256);)this[t+i]=e/u&255;return t+r},u.prototype.writeUInt8=function(e,t,r){return e=+e,t|=0,r||I(this,e,t,1,255,0),u.TYPED_ARRAY_SUPPORT||(e=Math.floor(e)),this[t]=255&e,t+1},u.prototype.writeUInt16LE=function(e,t,r){return e=+e,t|=0,r||I(this,e,t,2,65535,0),u.TYPED_ARRAY_SUPPORT?(this[t]=255&e,this[t+1]=e>>>8):L(this,e,t,!0),t+2},u.prototype.writeUInt16BE=function(e,t,r){return e=+e,t|=0,r||I(this,e,t,2,65535,0),u.TYPED_ARRAY_SUPPORT?(this[t]=e>>>8,this[t+1]=255&e):L(this,e,t,!1),t+2},u.prototype.writeUInt32LE=function(e,t,r){return e=+e,t|=0,r||I(this,e,t,4,4294967295,0),u.TYPED_ARRAY_SUPPORT?(this[t+3]=e>>>24,this[t+2]=e>>>16,this[t+1]=e>>>8,this[t]=255&e):D(this,e,t,!0),t+4},u.prototype.writeUInt32BE=function(e,t,r){return e=+e,t|=0,r||I(this,e,t,4,4294967295,0),u.TYPED_ARRAY_SUPPORT?(this[t]=e>>>24,this[t+1]=e>>>16,this[t+2]=e>>>8,this[t+3]=255&e):D(this,e,t,!1),t+4},u.prototype.writeIntLE=function(e,t,r,n){if(e=+e,t|=0,!n){var o=Math.pow(2,8*r-1);I(this,e,t,r,o-1,-o)}var i=0,u=1,s=0;for(this[t]=255&e;++i>0)-s&255;return t+r},u.prototype.writeIntBE=function(e,t,r,n){if(e=+e,t|=0,!n){var o=Math.pow(2,8*r-1);I(this,e,t,r,o-1,-o)}var i=r-1,u=1,s=0;for(this[t+i]=255&e;--i>=0&&(u*=256);)e<0&&0===s&&0!==this[t+i+1]&&(s=1),this[t+i]=(e/u>>0)-s&255;return t+r},u.prototype.writeInt8=function(e,t,r){return e=+e,t|=0,r||I(this,e,t,1,127,-128),u.TYPED_ARRAY_SUPPORT||(e=Math.floor(e)),e<0&&(e=255+e+1),this[t]=255&e,t+1},u.prototype.writeInt16LE=function(e,t,r){return e=+e,t|=0,r||I(this,e,t,2,32767,-32768),u.TYPED_ARRAY_SUPPORT?(this[t]=255&e,this[t+1]=e>>>8):L(this,e,t,!0),t+2},u.prototype.writeInt16BE=function(e,t,r){return e=+e,t|=0,r||I(this,e,t,2,32767,-32768),u.TYPED_ARRAY_SUPPORT?(this[t]=e>>>8,this[t+1]=255&e):L(this,e,t,!1),t+2},u.prototype.writeInt32LE=function(e,t,r){return e=+e,t|=0,r||I(this,e,t,4,2147483647,-2147483648),u.TYPED_ARRAY_SUPPORT?(this[t]=255&e,this[t+1]=e>>>8,this[t+2]=e>>>16,this[t+3]=e>>>24):D(this,e,t,!0),t+4},u.prototype.writeInt32BE=function(e,t,r){return e=+e,t|=0,r||I(this,e,t,4,2147483647,-2147483648),e<0&&(e=4294967295+e+1),u.TYPED_ARRAY_SUPPORT?(this[t]=e>>>24,this[t+1]=e>>>16,this[t+2]=e>>>8,this[t+3]=255&e):D(this,e,t,!1),t+4},u.prototype.writeFloatLE=function(e,t,r){return G(this,e,t,!0,r)},u.prototype.writeFloatBE=function(e,t,r){return G(this,e,t,!1,r)},u.prototype.writeDoubleLE=function(e,t,r){return N(this,e,t,!0,r)},u.prototype.writeDoubleBE=function(e,t,r){return N(this,e,t,!1,r)},u.prototype.copy=function(e,t,r,n){if(r||(r=0),n||0===n||(n=this.length),t>=e.length&&(t=e.length),t||(t=0),n>0&&n=this.length)throw new RangeError("sourceStart out of bounds");if(n<0)throw new RangeError("sourceEnd out of bounds");n>this.length&&(n=this.length),e.length-t=0;--o)e[o+t]=this[o+r];else if(i<1e3||!u.TYPED_ARRAY_SUPPORT)for(o=0;o>>=0,r=void 0===r?this.length:r>>>0,e||(e=0);var i;if("number"==typeof e)for(i=t;i=31||"undefined"!=typeof navigator&&navigator&&navigator.userAgent&&navigator.userAgent.toLowerCase().match(/applewebkit\/(\d+)/))}function i(e){var t=this.useColors;if(e[0]=(t?"%c":"")+this.namespace+(t?" %c":" ")+e[0]+(t?"%c ":" ")+"+"+r.humanize(this.diff),t){var n="color: "+this.color;e.splice(1,0,n,"color: inherit");var o=0,i=0;e[0].replace(/%[a-zA-Z%]/g,function(e){"%%"!==e&&(o++,"%c"===e&&(i=o))}),e.splice(i,0,n)}}function u(){return"object"==typeof console&&console.log&&Function.prototype.apply.call(console.log,console,arguments)}function s(e){try{null==e?r.storage.removeItem("debug"):r.storage.debug=e}catch(e){}}function a(){try{return r.storage.debug}catch(e){}if("undefined"!=typeof n&&"env"in n)return n.env.DEBUG}function f(){try{return window.localStorage}catch(e){}}r=t.exports=e("./debug"),r.log=u,r.formatArgs=i,r.save=s,r.load=a,r.useColors=o,r.storage="undefined"!=typeof chrome&&"undefined"!=typeof chrome.storage?chrome.storage.local:f(),r.colors=["lightseagreen","forestgreen","goldenrod","dodgerblue","darkorchid","crimson"],r.formatters.j=function(e){try{return JSON.stringify(e)}catch(e){return"[UnexpectedJSONParseError]: "+e.message}},r.enable(a())}).call(this,e("_process"))},{"./debug":41,_process:46}],41:[function(e,t,r){function n(e){var t,n=0;for(t in e)n=(n<<5)-n+e.charCodeAt(t),n|=0;return r.colors[Math.abs(n)%r.colors.length]}function o(e){function t(){if(t.enabled){var e=t,n=+new Date,o=n-(f||n);e.diff=o,e.prev=f,e.curr=n,f=n;for(var i=new Array(arguments.length),u=0;u>1,c=-7,l=r?o-1:0,h=r?-1:1,p=e[t+l];for(l+=h,i=p&(1<<-c)-1,p>>=-c,c+=s;c>0;i=256*i+e[t+l],l+=h,c-=8);for(u=i&(1<<-c)-1,i>>=-c,c+=n;c>0;u=256*u+e[t+l],l+=h,c-=8);if(0===i)i=1-f;else{if(i===a)return u?NaN:(p?-1:1)*(1/0);u+=Math.pow(2,n),i-=f}return(p?-1:1)*u*Math.pow(2,i-n)},r.write=function(e,t,r,n,o,i){var u,s,a,f=8*i-o-1,c=(1<>1,h=23===o?Math.pow(2,-24)-Math.pow(2,-77):0,p=n?0:i-1,d=n?1:-1,y=t<0||0===t&&1/t<0?1:0;for(t=Math.abs(t),isNaN(t)||t===1/0?(s=isNaN(t)?1:0,u=c):(u=Math.floor(Math.log(t)/Math.LN2),t*(a=Math.pow(2,-u))<1&&(u--,a*=2),t+=u+l>=1?h/a:h*Math.pow(2,1-l),t*a>=2&&(u++,a/=2),u+l>=c?(s=0,u=c):u+l>=1?(s=(t*a-1)*Math.pow(2,o),u+=l):(s=t*Math.pow(2,l-1)*Math.pow(2,o),u=0));o>=8;e[r+p]=255&s,p+=d,s/=256,o-=8);for(u=u<0;e[r+p]=255&u,p+=d,u/=256,f-=8);e[r+p-d]|=128*y}},{}],43:[function(e,t,r){var n={}.toString;t.exports=Array.isArray||function(e){return"[object Array]"==n.call(e)}},{}],44:[function(e,t,r){!function(r){"use strict";var n,o=r.Base64,i="2.1.9";if("undefined"!=typeof t&&t.exports)try{n=e("buffer").Buffer}catch(e){}var u="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/",s=function(e){for(var t={},r=0,n=e.length;r>>6)+a(128|63&t):a(224|t>>>12&15)+a(128|t>>>6&63)+a(128|63&t)}var t=65536+1024*(e.charCodeAt(0)-55296)+(e.charCodeAt(1)-56320);return a(240|t>>>18&7)+a(128|t>>>12&63)+a(128|t>>>6&63)+a(128|63&t)},c=/[\uD800-\uDBFF][\uDC00-\uDFFFF]|[^\x00-\x7F]/g,l=function(e){return e.replace(c,f)},h=function(e){var t=[0,2,1][e.length%3],r=e.charCodeAt(0)<<16|(e.length>1?e.charCodeAt(1):0)<<8|(e.length>2?e.charCodeAt(2):0),n=[u.charAt(r>>>18),u.charAt(r>>>12&63),t>=2?"=":u.charAt(r>>>6&63),t>=1?"=":u.charAt(63&r)];return n.join("")},p=r.btoa?function(e){return r.btoa(e)}:function(e){return e.replace(/[\s\S]{1,3}/g,h)},d=n?function(e){return(e.constructor===n.constructor?e:new n(e)).toString("base64")}:function(e){return p(l(e))},y=function(e,t){return t?d(String(e)).replace(/[+\/]/g,function(e){return"+"==e?"-":"_"}).replace(/=/g,""):d(String(e))},_=function(e){return y(e,!0)},g=new RegExp(["[À-ß][€-¿]","[à-ï][€-¿]{2}","[ð-÷][€-¿]{3}"].join("|"),"g"),m=function(e){switch(e.length){case 4:var t=(7&e.charCodeAt(0))<<18|(63&e.charCodeAt(1))<<12|(63&e.charCodeAt(2))<<6|63&e.charCodeAt(3),r=t-65536;return a((r>>>10)+55296)+a((1023&r)+56320);case 3:return a((15&e.charCodeAt(0))<<12|(63&e.charCodeAt(1))<<6|63&e.charCodeAt(2));default:return a((31&e.charCodeAt(0))<<6|63&e.charCodeAt(1))}},v=function(e){return e.replace(g,m)},b=function(e){var t=e.length,r=t%4,n=(t>0?s[e.charAt(0)]<<18:0)|(t>1?s[e.charAt(1)]<<12:0)|(t>2?s[e.charAt(2)]<<6:0)|(t>3?s[e.charAt(3)]:0),o=[a(n>>>16),a(n>>>8&255),a(255&n)];return o.length-=[0,0,2,1][r],o.join("")},w=r.atob?function(e){return r.atob(e)}:function(e){return e.replace(/[\s\S]{1,4}/g,b)},E=n?function(e){return(e.constructor===n.constructor?e:new n(e,"base64")).toString()}:function(e){return v(w(e))},T=function(e){return E(String(e).replace(/[-_]/g,function(e){return"-"==e?"+":"/"}).replace(/[^A-Za-z0-9\+\/]/g,""))},k=function(){var e=r.Base64;return r.Base64=o,e};if(r.Base64={VERSION:i,atob:w,btoa:p,fromBase64:T,toBase64:y,utob:l,encode:y,encodeURI:_,btou:v,decode:T,noConflict:k},"function"==typeof Object.defineProperty){var A=function(e){return{value:e,enumerable:!1,writable:!0,configurable:!0}};r.Base64.extendString=function(){Object.defineProperty(String.prototype,"fromBase64",A(function(){return T(this)})),Object.defineProperty(String.prototype,"toBase64",A(function(e){return y(this,e)})),Object.defineProperty(String.prototype,"toBase64URI",A(function(){return y(this,!0)}))}}r.Meteor&&(Base64=r.Base64)}(this)},{buffer:39}],45:[function(e,t,r){function n(e){if(e=String(e),!(e.length>1e4)){var t=/^((?:\d+)?\.?\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|years?|yrs?|y)?$/i.exec(e);if(t){var r=parseFloat(t[1]),n=(t[2]||"ms").toLowerCase();switch(n){case"years":case"year":case"yrs":case"yr":case"y":return r*l;case"days":case"day":case"d":return r*c;case"hours":case"hour":case"hrs":case"hr":case"h":return r*f;case"minutes":case"minute":case"mins":case"min":case"m":return r*a;case"seconds":case"second":case"secs":case"sec":case"s":return r*s;case"milliseconds":case"millisecond":case"msecs":case"msec":case"ms":return r;default:return}}}}function o(e){return e>=c?Math.round(e/c)+"d":e>=f?Math.round(e/f)+"h":e>=a?Math.round(e/a)+"m":e>=s?Math.round(e/s)+"s":e+"ms"}function i(e){return u(e,c,"day")||u(e,f,"hour")||u(e,a,"minute")||u(e,s,"second")||e+" ms"}function u(e,t,r){if(!(e0)return n(e);if("number"===r&&isNaN(e)===!1)return t.long?i(e):o(e);throw new Error("val is not a non-empty string or a valid number. val="+JSON.stringify(e))}},{}],46:[function(e,t,r){function n(){throw new Error("setTimeout has not been defined")}function o(){throw new Error("clearTimeout has not been defined")}function i(e){if(l===setTimeout)return setTimeout(e,0);if((l===n||!l)&&setTimeout)return l=setTimeout,setTimeout(e,0);try{return l(e,0)}catch(t){try{return l.call(null,e,0)}catch(t){return l.call(this,e,0)}}}function u(e){if(h===clearTimeout)return clearTimeout(e);if((h===o||!h)&&clearTimeout)return h=clearTimeout,clearTimeout(e);try{return h(e)}catch(t){try{return h.call(null,e)}catch(t){return h.call(this,e)}}}function s(){_&&d&&(_=!1,d.length?y=d.concat(y):g=-1,y.length&&a())}function a(){if(!_){var e=i(s);_=!0;for(var t=y.length;t;){for(d=y,y=[];++g1)for(var r=1;r=55296&&t<=56319&&o65535&&(t-=65536,o+=b(t>>>10&1023|55296),t=56320|1023&t),o+=b(t);return o}function s(e){if(e>=55296&&e<=57343)throw Error("Lone surrogate U+"+e.toString(16).toUpperCase()+" is not a scalar value")}function a(e,t){return b(e>>t&63|128)}function f(e){if(0==(4294967168&e))return b(e);var t="";return 0==(4294965248&e)?t=b(e>>6&31|192):0==(4294901760&e)?(s(e),t=b(e>>12&15|224),t+=a(e,6)):0==(4292870144&e)&&(t=b(e>>18&7|240),t+=a(e,12),t+=a(e,6)),t+=b(63&e|128)}function c(e){for(var t,r=i(e),n=r.length,o=-1,u="";++o=m)throw Error("Invalid byte index");var e=255&g[v];if(v++,128==(192&e))return 63&e;throw Error("Invalid continuation byte")}function h(){var e,t,r,n,o;if(v>m)throw Error("Invalid byte index");if(v==m)return!1;if(e=255&g[v],v++,0==(128&e))return e;if(192==(224&e)){if(t=l(),o=(31&e)<<6|t,o>=128)return o;throw Error("Invalid continuation byte")}if(224==(240&e)){if(t=l(),r=l(),o=(15&e)<<12|t<<6|r,o>=2048)return s(o),o;throw Error("Invalid continuation byte")}if(240==(248&e)&&(t=l(),r=l(),n=l(),o=(7&e)<<18|t<<12|r<<6|n,o>=65536&&o<=1114111))return o;throw Error("Invalid UTF-8 detected")}function p(e){g=i(e),m=g.length,v=0;for(var t,r=[];(t=h())!==!1;)r.push(t);return u(r)}var d="object"==typeof n&&n,y="object"==typeof r&&r&&r.exports==d&&r,_="object"==typeof t&&t;_.global!==_&&_.window!==_||(o=_);var g,m,v,b=String.fromCharCode,w={version:"2.1.2",encode:c,decode:p};if("function"==typeof e&&"object"==typeof e.amd&&e.amd)e(function(){return w});else if(d&&!d.nodeType)if(y)y.exports=w;else{var E={},T=E.hasOwnProperty;for(var k in w)T.call(w,k)&&(d[k]=w[k])}else o.utf8=w}(this)}).call(this,"undefined"!=typeof global?global:"undefined"!=typeof self?self:"undefined"!=typeof window?window:{})},{}]},{},[2])(2)}); +}}function o(e,t){if(!(e instanceof t))throw new TypeError("Cannot call a class as a function")}function i(e,t){if(!e)throw new ReferenceError("this hasn't been initialised - super() hasn't been called");return!t||"object"!=typeof t&&"function"!=typeof t?e:t}function u(e,t){if("function"!=typeof t&&null!==t)throw new TypeError("Super expression must either be null or a function, not "+typeof t);e.prototype=Object.create(t&&t.prototype,{constructor:{value:e,enumerable:!1,writable:!0,configurable:!0}}),t&&(Object.setPrototypeOf?Object.setPrototypeOf(e,t):e.__proto__=t)}var s=function(){function e(e,t){for(var r=0;r1&&void 0!==arguments[1]?arguments[1]:{},n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:void 0,o={};return Object.keys(this.__defaults).forEach(function(e){o[e]=t.__defaults[e]}),Object.keys(r).forEach(function(e){o[e]=r[e]}),h("searching "+e+" with options:",o),this._requestAllPages("/search/"+e,o,n)}},{key:"forRepositories",value:function(e,t){return this._search("repositories",e,t)}},{key:"forCode",value:function(e,t){return this._search("code",e,t)}},{key:"forIssues",value:function(e,t){return this._search("issues",e,t)}},{key:"forUsers",value:function(e,t){return this._search("users",e,t)}}]),t}(f.default);t.exports=p},{"./Requestable":9,debug:40}],11:[function(e,t,r){"use strict";function n(e){return e&&e.__esModule?e:{default:e}}function o(e,t){if(!(e instanceof t))throw new TypeError("Cannot call a class as a function")}function i(e,t){if(!e)throw new ReferenceError("this hasn't been initialised - super() hasn't been called");return!t||"object"!=typeof t&&"function"!=typeof t?e:t}function u(e,t){if("function"!=typeof t&&null!==t)throw new TypeError("Super expression must either be null or a function, not "+typeof t);e.prototype=Object.create(t&&t.prototype,{constructor:{value:e,enumerable:!1,writable:!0,configurable:!0}}),t&&(Object.setPrototypeOf?Object.setPrototypeOf(e,t):e.__proto__=t)}var s=function(){function e(e,t){for(var r=0;r=200&&e<300}};f.headers={common:{Accept:"application/json, text/plain, */*"}},i.forEach(["delete","get","head"],function(e){f.headers[e]={}}),i.forEach(["post","put","patch"],function(e){f.headers[e]=i.merge(a)}),t.exports=f}).call(this,e("_process"))},{"./adapters/http":14,"./adapters/xhr":14,"./helpers/normalizeHeaderName":34,"./utils":37,_process:46}],27:[function(e,t,r){"use strict";t.exports=function(e,t){return function(){for(var r=new Array(arguments.length),n=0;n>8-s%1*8)){if(r=o.charCodeAt(s+=.75),r>255)throw new n;t=t<<8|r}return u}var i="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";n.prototype=new Error,n.prototype.code=5,n.prototype.name="InvalidCharacterError",t.exports=o},{}],29:[function(e,t,r){"use strict";function n(e){return encodeURIComponent(e).replace(/%40/gi,"@").replace(/%3A/gi,":").replace(/%24/g,"$").replace(/%2C/gi,",").replace(/%20/g,"+").replace(/%5B/gi,"[").replace(/%5D/gi,"]")}var o=e("./../utils");t.exports=function(e,t,r){if(!t)return e;var i;if(r)i=r(t);else if(o.isURLSearchParams(t))i=t.toString();else{var u=[];o.forEach(t,function(e,t){null!==e&&"undefined"!=typeof e&&(o.isArray(e)&&(t+="[]"),o.isArray(e)||(e=[e]),o.forEach(e,function(e){o.isDate(e)?e=e.toISOString():o.isObject(e)&&(e=JSON.stringify(e)),u.push(n(t)+"="+n(e))}))}),i=u.join("&")}return i&&(e+=(e.indexOf("?")===-1?"?":"&")+i),e}},{"./../utils":37}],30:[function(e,t,r){"use strict";t.exports=function(e,t){return e.replace(/\/+$/,"")+"/"+t.replace(/^\/+/,"")}},{}],31:[function(e,t,r){"use strict";var n=e("./../utils");t.exports=n.isStandardBrowserEnv()?function(){return{write:function(e,t,r,o,i,u){var s=[];s.push(e+"="+encodeURIComponent(t)),n.isNumber(r)&&s.push("expires="+new Date(r).toGMTString()),n.isString(o)&&s.push("path="+o),n.isString(i)&&s.push("domain="+i),u===!0&&s.push("secure"),document.cookie=s.join("; ")},read:function(e){var t=document.cookie.match(new RegExp("(^|;\\s*)("+e+")=([^;]*)"));return t?decodeURIComponent(t[3]):null},remove:function(e){this.write(e,"",Date.now()-864e5)}}}():function(){return{write:function(){},read:function(){return null},remove:function(){}}}()},{"./../utils":37}],32:[function(e,t,r){"use strict";t.exports=function(e){return/^([a-z][a-z\d\+\-\.]*:)?\/\//i.test(e)}},{}],33:[function(e,t,r){"use strict";var n=e("./../utils");t.exports=n.isStandardBrowserEnv()?function(){function e(e){var t=e;return r&&(o.setAttribute("href",t),t=o.href),o.setAttribute("href",t),{href:o.href,protocol:o.protocol?o.protocol.replace(/:$/,""):"",host:o.host,search:o.search?o.search.replace(/^\?/,""):"",hash:o.hash?o.hash.replace(/^#/,""):"",hostname:o.hostname,port:o.port,pathname:"/"===o.pathname.charAt(0)?o.pathname:"/"+o.pathname}}var t,r=/(msie|trident)/i.test(navigator.userAgent),o=document.createElement("a");return t=e(window.location.href),function(r){var o=n.isString(r)?e(r):r;return o.protocol===t.protocol&&o.host===t.host}}():function(){return function(){return!0}}()},{"./../utils":37}],34:[function(e,t,r){"use strict";var n=e("../utils");t.exports=function(e,t){n.forEach(e,function(r,n){n!==t&&n.toUpperCase()===t.toUpperCase()&&(e[t]=r,delete e[n])})}},{"../utils":37}],35:[function(e,t,r){"use strict";var n=e("./../utils");t.exports=function(e){var t,r,o,i={};return e?(n.forEach(e.split("\n"),function(e){o=e.indexOf(":"),t=n.trim(e.substr(0,o)).toLowerCase(),r=n.trim(e.substr(o+1)),t&&(i[t]=i[t]?i[t]+", "+r:r)}),i):i}},{"./../utils":37}],36:[function(e,t,r){"use strict";t.exports=function(e){return function(t){return e.apply(null,t)}}},{}],37:[function(e,t,r){"use strict";function n(e){return"[object Array]"===T.call(e)}function o(e){return"[object ArrayBuffer]"===T.call(e)}function i(e){return"undefined"!=typeof FormData&&e instanceof FormData}function u(e){var t;return t="undefined"!=typeof ArrayBuffer&&ArrayBuffer.isView?ArrayBuffer.isView(e):e&&e.buffer&&e.buffer instanceof ArrayBuffer}function s(e){return"string"==typeof e}function a(e){return"number"==typeof e}function f(e){return"undefined"==typeof e}function c(e){return null!==e&&"object"==typeof e}function l(e){return"[object Date]"===T.call(e)}function h(e){return"[object File]"===T.call(e)}function p(e){return"[object Blob]"===T.call(e)}function d(e){return"[object Function]"===T.call(e)}function y(e){return c(e)&&d(e.pipe)}function _(e){return"undefined"!=typeof URLSearchParams&&e instanceof URLSearchParams}function g(e){return e.replace(/^\s*/,"").replace(/\s*$/,"")}function m(){return"undefined"!=typeof window&&"undefined"!=typeof document&&"function"==typeof document.createElement}function v(e,t){if(null!==e&&"undefined"!=typeof e)if("object"==typeof e||n(e)||(e=[e]),n(e))for(var r=0,o=e.length;r0)throw new Error("Invalid string. Length must be a multiple of 4");return"="===e[t-2]?2:"="===e[t-1]?1:0}function o(e){return 3*e.length/4-n(e)}function i(e){var t,r,o,i,u,s,a=e.length;u=n(e),s=new l(3*a/4-u),o=u>0?a-4:a;var f=0;for(t=0,r=0;t>16&255,s[f++]=i>>8&255,s[f++]=255&i;return 2===u?(i=c[e.charCodeAt(t)]<<2|c[e.charCodeAt(t+1)]>>4,s[f++]=255&i):1===u&&(i=c[e.charCodeAt(t)]<<10|c[e.charCodeAt(t+1)]<<4|c[e.charCodeAt(t+2)]>>2,s[f++]=i>>8&255,s[f++]=255&i),s}function u(e){return f[e>>18&63]+f[e>>12&63]+f[e>>6&63]+f[63&e]}function s(e,t,r){for(var n,o=[],i=t;ic?c:a+u));return 1===n?(t=e[r-1],o+=f[t>>2],o+=f[t<<4&63],o+="=="):2===n&&(t=(e[r-2]<<8)+e[r-1],o+=f[t>>10],o+=f[t>>4&63],o+=f[t<<2&63],o+="="),i.push(o),i.join("")}r.byteLength=o,r.toByteArray=i,r.fromByteArray=a;for(var f=[],c=[],l="undefined"!=typeof Uint8Array?Uint8Array:Array,h="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/",p=0,d=h.length;p=o())throw new RangeError("Attempt to allocate Buffer larger than maximum size: 0x"+o().toString(16)+" bytes");return 0|e}function _(e){return+e!=e&&(e=0),u.alloc(+e)}function g(e,t){if(u.isBuffer(e))return e.length;if("undefined"!=typeof ArrayBuffer&&"function"==typeof ArrayBuffer.isView&&(ArrayBuffer.isView(e)||e instanceof ArrayBuffer))return e.byteLength;"string"!=typeof e&&(e=""+e);var r=e.length;if(0===r)return 0;for(var n=!1;;)switch(t){case"ascii":case"latin1":case"binary":return r;case"utf8":case"utf-8":case void 0:return z(e).length;case"ucs2":case"ucs-2":case"utf16le":case"utf-16le":return 2*r;case"hex":return r>>>1;case"base64":return V(e).length;default:if(n)return z(e).length;t=(""+t).toLowerCase(),n=!0}}function m(e,t,r){var n=!1;if((void 0===t||t<0)&&(t=0),t>this.length)return"";if((void 0===r||r>this.length)&&(r=this.length),r<=0)return"";if(r>>>=0,t>>>=0,r<=t)return"";for(e||(e="utf8");;)switch(e){case"hex":return x(this,t,r);case"utf8":case"utf-8":return q(this,t,r);case"ascii":return C(this,t,r);case"latin1":case"binary":return j(this,t,r);case"base64":return O(this,t,r);case"ucs2":case"ucs-2":case"utf16le":case"utf-16le":return B(this,t,r);default:if(n)throw new TypeError("Unknown encoding: "+e);e=(e+"").toLowerCase(),n=!0}}function v(e,t,r){var n=e[t];e[t]=e[r],e[r]=n}function b(e,t,r,n,o){if(0===e.length)return-1;if("string"==typeof r?(n=r,r=0):r>2147483647?r=2147483647:r<-2147483648&&(r=-2147483648),r=+r,isNaN(r)&&(r=o?0:e.length-1),r<0&&(r=e.length+r),r>=e.length){if(o)return-1;r=e.length-1}else if(r<0){if(!o)return-1;r=0}if("string"==typeof t&&(t=u.from(t,n)),u.isBuffer(t))return 0===t.length?-1:w(e,t,r,n,o);if("number"==typeof t)return t&=255,u.TYPED_ARRAY_SUPPORT&&"function"==typeof Uint8Array.prototype.indexOf?o?Uint8Array.prototype.indexOf.call(e,t,r):Uint8Array.prototype.lastIndexOf.call(e,t,r):w(e,[t],r,n,o);throw new TypeError("val must be string, number or Buffer")}function w(e,t,r,n,o){function i(e,t){return 1===u?e[t]:e.readUInt16BE(t*u)}var u=1,s=e.length,a=t.length;if(void 0!==n&&(n=String(n).toLowerCase(),"ucs2"===n||"ucs-2"===n||"utf16le"===n||"utf-16le"===n)){if(e.length<2||t.length<2)return-1;u=2,s/=2,a/=2,r/=2}var f;if(o){var c=-1;for(f=r;fs&&(r=s-a),f=r;f>=0;f--){for(var l=!0,h=0;ho&&(n=o)):n=o;var i=t.length;if(i%2!==0)throw new TypeError("Invalid hex string");n>i/2&&(n=i/2);for(var u=0;u239?4:i>223?3:i>191?2:1;if(o+s<=r){var a,f,c,l;switch(s){case 1:i<128&&(u=i);break;case 2:a=e[o+1],128===(192&a)&&(l=(31&i)<<6|63&a,l>127&&(u=l));break;case 3:a=e[o+1],f=e[o+2],128===(192&a)&&128===(192&f)&&(l=(15&i)<<12|(63&a)<<6|63&f,l>2047&&(l<55296||l>57343)&&(u=l));break;case 4:a=e[o+1],f=e[o+2],c=e[o+3],128===(192&a)&&128===(192&f)&&128===(192&c)&&(l=(15&i)<<18|(63&a)<<12|(63&f)<<6|63&c,l>65535&&l<1114112&&(u=l))}}null===u?(u=65533,s=1):u>65535&&(u-=65536,n.push(u>>>10&1023|55296),u=56320|1023&u),n.push(u),o+=s}return S(n)}function S(e){var t=e.length;if(t<=ee)return String.fromCharCode.apply(String,e);for(var r="",n=0;nn)&&(r=n);for(var o="",i=t;ir)throw new RangeError("Trying to access beyond buffer length")}function I(e,t,r,n,o,i){if(!u.isBuffer(e))throw new TypeError('"buffer" argument must be a Buffer instance');if(t>o||te.length)throw new RangeError("Index out of range")}function L(e,t,r,n){t<0&&(t=65535+t+1);for(var o=0,i=Math.min(e.length-r,2);o>>8*(n?o:1-o)}function D(e,t,r,n){t<0&&(t=4294967295+t+1);for(var o=0,i=Math.min(e.length-r,4);o>>8*(n?o:3-o)&255}function M(e,t,r,n,o,i){if(r+n>e.length)throw new RangeError("Index out of range");if(r<0)throw new RangeError("Index out of range")}function G(e,t,r,n,o){return o||M(e,t,r,4,3.4028234663852886e38,-3.4028234663852886e38),Z.write(e,t,r,n,23,4),r+4}function N(e,t,r,n,o){return o||M(e,t,r,8,1.7976931348623157e308,-1.7976931348623157e308),Z.write(e,t,r,n,52,8),r+8}function H(e){if(e=Y(e).replace(te,""),e.length<2)return"";for(;e.length%4!==0;)e+="=";return e}function Y(e){return e.trim?e.trim():e.replace(/^\s+|\s+$/g,"")}function F(e){return e<16?"0"+e.toString(16):e.toString(16)}function z(e,t){t=t||1/0;for(var r,n=e.length,o=null,i=[],u=0;u55295&&r<57344){if(!o){if(r>56319){(t-=3)>-1&&i.push(239,191,189);continue}if(u+1===n){(t-=3)>-1&&i.push(239,191,189);continue}o=r;continue}if(r<56320){(t-=3)>-1&&i.push(239,191,189),o=r;continue}r=(o-55296<<10|r-56320)+65536}else o&&(t-=3)>-1&&i.push(239,191,189);if(o=null,r<128){if((t-=1)<0)break;i.push(r)}else if(r<2048){if((t-=2)<0)break;i.push(r>>6|192,63&r|128)}else if(r<65536){if((t-=3)<0)break;i.push(r>>12|224,r>>6&63|128,63&r|128)}else{if(!(r<1114112))throw new Error("Invalid code point");if((t-=4)<0)break;i.push(r>>18|240,r>>12&63|128,r>>6&63|128,63&r|128)}}return i}function J(e){for(var t=[],r=0;r>8,o=r%256,i.push(o),i.push(n);return i}function V(e){return $.toByteArray(H(e))}function W(e,t,r,n){for(var o=0;o=t.length||o>=e.length);++o)t[o+r]=e[o];return o}function K(e){return e!==e}var $=e("base64-js"),Z=e("ieee754"),Q=e("isarray");r.Buffer=u,r.SlowBuffer=_,r.INSPECT_MAX_BYTES=50,u.TYPED_ARRAY_SUPPORT=void 0!==t.TYPED_ARRAY_SUPPORT?t.TYPED_ARRAY_SUPPORT:n(),r.kMaxLength=o(),u.poolSize=8192,u._augment=function(e){return e.__proto__=u.prototype,e},u.from=function(e,t,r){return s(null,e,t,r)},u.TYPED_ARRAY_SUPPORT&&(u.prototype.__proto__=Uint8Array.prototype,u.__proto__=Uint8Array,"undefined"!=typeof Symbol&&Symbol.species&&u[Symbol.species]===u&&Object.defineProperty(u,Symbol.species,{value:null,configurable:!0})),u.alloc=function(e,t,r){return f(null,e,t,r)},u.allocUnsafe=function(e){return c(null,e)},u.allocUnsafeSlow=function(e){return c(null,e); +},u.isBuffer=function(e){return!(null==e||!e._isBuffer)},u.compare=function(e,t){if(!u.isBuffer(e)||!u.isBuffer(t))throw new TypeError("Arguments must be Buffers");if(e===t)return 0;for(var r=e.length,n=t.length,o=0,i=Math.min(r,n);o0&&(e=this.toString("hex",0,t).match(/.{2}/g).join(" "),this.length>t&&(e+=" ... ")),""},u.prototype.compare=function(e,t,r,n,o){if(!u.isBuffer(e))throw new TypeError("Argument must be a Buffer");if(void 0===t&&(t=0),void 0===r&&(r=e?e.length:0),void 0===n&&(n=0),void 0===o&&(o=this.length),t<0||r>e.length||n<0||o>this.length)throw new RangeError("out of range index");if(n>=o&&t>=r)return 0;if(n>=o)return-1;if(t>=r)return 1;if(t>>>=0,r>>>=0,n>>>=0,o>>>=0,this===e)return 0;for(var i=o-n,s=r-t,a=Math.min(i,s),f=this.slice(n,o),c=e.slice(t,r),l=0;lo)&&(r=o),e.length>0&&(r<0||t<0)||t>this.length)throw new RangeError("Attempt to write outside buffer bounds");n||(n="utf8");for(var i=!1;;)switch(n){case"hex":return E(this,e,t,r);case"utf8":case"utf-8":return T(this,e,t,r);case"ascii":return k(this,e,t,r);case"latin1":case"binary":return A(this,e,t,r);case"base64":return P(this,e,t,r);case"ucs2":case"ucs-2":case"utf16le":case"utf-16le":return R(this,e,t,r);default:if(i)throw new TypeError("Unknown encoding: "+n);n=(""+n).toLowerCase(),i=!0}},u.prototype.toJSON=function(){return{type:"Buffer",data:Array.prototype.slice.call(this._arr||this,0)}};var ee=4096;u.prototype.slice=function(e,t){var r=this.length;e=~~e,t=void 0===t?r:~~t,e<0?(e+=r,e<0&&(e=0)):e>r&&(e=r),t<0?(t+=r,t<0&&(t=0)):t>r&&(t=r),t0&&(o*=256);)n+=this[e+--t]*o;return n},u.prototype.readUInt8=function(e,t){return t||U(e,1,this.length),this[e]},u.prototype.readUInt16LE=function(e,t){return t||U(e,2,this.length),this[e]|this[e+1]<<8},u.prototype.readUInt16BE=function(e,t){return t||U(e,2,this.length),this[e]<<8|this[e+1]},u.prototype.readUInt32LE=function(e,t){return t||U(e,4,this.length),(this[e]|this[e+1]<<8|this[e+2]<<16)+16777216*this[e+3]},u.prototype.readUInt32BE=function(e,t){return t||U(e,4,this.length),16777216*this[e]+(this[e+1]<<16|this[e+2]<<8|this[e+3])},u.prototype.readIntLE=function(e,t,r){e|=0,t|=0,r||U(e,t,this.length);for(var n=this[e],o=1,i=0;++i=o&&(n-=Math.pow(2,8*t)),n},u.prototype.readIntBE=function(e,t,r){e|=0,t|=0,r||U(e,t,this.length);for(var n=t,o=1,i=this[e+--n];n>0&&(o*=256);)i+=this[e+--n]*o;return o*=128,i>=o&&(i-=Math.pow(2,8*t)),i},u.prototype.readInt8=function(e,t){return t||U(e,1,this.length),128&this[e]?(255-this[e]+1)*-1:this[e]},u.prototype.readInt16LE=function(e,t){t||U(e,2,this.length);var r=this[e]|this[e+1]<<8;return 32768&r?4294901760|r:r},u.prototype.readInt16BE=function(e,t){t||U(e,2,this.length);var r=this[e+1]|this[e]<<8;return 32768&r?4294901760|r:r},u.prototype.readInt32LE=function(e,t){return t||U(e,4,this.length),this[e]|this[e+1]<<8|this[e+2]<<16|this[e+3]<<24},u.prototype.readInt32BE=function(e,t){return t||U(e,4,this.length),this[e]<<24|this[e+1]<<16|this[e+2]<<8|this[e+3]},u.prototype.readFloatLE=function(e,t){return t||U(e,4,this.length),Z.read(this,e,!0,23,4)},u.prototype.readFloatBE=function(e,t){return t||U(e,4,this.length),Z.read(this,e,!1,23,4)},u.prototype.readDoubleLE=function(e,t){return t||U(e,8,this.length),Z.read(this,e,!0,52,8)},u.prototype.readDoubleBE=function(e,t){return t||U(e,8,this.length),Z.read(this,e,!1,52,8)},u.prototype.writeUIntLE=function(e,t,r,n){if(e=+e,t|=0,r|=0,!n){var o=Math.pow(2,8*r)-1;I(this,e,t,r,o,0)}var i=1,u=0;for(this[t]=255&e;++u=0&&(u*=256);)this[t+i]=e/u&255;return t+r},u.prototype.writeUInt8=function(e,t,r){return e=+e,t|=0,r||I(this,e,t,1,255,0),u.TYPED_ARRAY_SUPPORT||(e=Math.floor(e)),this[t]=255&e,t+1},u.prototype.writeUInt16LE=function(e,t,r){return e=+e,t|=0,r||I(this,e,t,2,65535,0),u.TYPED_ARRAY_SUPPORT?(this[t]=255&e,this[t+1]=e>>>8):L(this,e,t,!0),t+2},u.prototype.writeUInt16BE=function(e,t,r){return e=+e,t|=0,r||I(this,e,t,2,65535,0),u.TYPED_ARRAY_SUPPORT?(this[t]=e>>>8,this[t+1]=255&e):L(this,e,t,!1),t+2},u.prototype.writeUInt32LE=function(e,t,r){return e=+e,t|=0,r||I(this,e,t,4,4294967295,0),u.TYPED_ARRAY_SUPPORT?(this[t+3]=e>>>24,this[t+2]=e>>>16,this[t+1]=e>>>8,this[t]=255&e):D(this,e,t,!0),t+4},u.prototype.writeUInt32BE=function(e,t,r){return e=+e,t|=0,r||I(this,e,t,4,4294967295,0),u.TYPED_ARRAY_SUPPORT?(this[t]=e>>>24,this[t+1]=e>>>16,this[t+2]=e>>>8,this[t+3]=255&e):D(this,e,t,!1),t+4},u.prototype.writeIntLE=function(e,t,r,n){if(e=+e,t|=0,!n){var o=Math.pow(2,8*r-1);I(this,e,t,r,o-1,-o)}var i=0,u=1,s=0;for(this[t]=255&e;++i>0)-s&255;return t+r},u.prototype.writeIntBE=function(e,t,r,n){if(e=+e,t|=0,!n){var o=Math.pow(2,8*r-1);I(this,e,t,r,o-1,-o)}var i=r-1,u=1,s=0;for(this[t+i]=255&e;--i>=0&&(u*=256);)e<0&&0===s&&0!==this[t+i+1]&&(s=1),this[t+i]=(e/u>>0)-s&255;return t+r},u.prototype.writeInt8=function(e,t,r){return e=+e,t|=0,r||I(this,e,t,1,127,-128),u.TYPED_ARRAY_SUPPORT||(e=Math.floor(e)),e<0&&(e=255+e+1),this[t]=255&e,t+1},u.prototype.writeInt16LE=function(e,t,r){return e=+e,t|=0,r||I(this,e,t,2,32767,-32768),u.TYPED_ARRAY_SUPPORT?(this[t]=255&e,this[t+1]=e>>>8):L(this,e,t,!0),t+2},u.prototype.writeInt16BE=function(e,t,r){return e=+e,t|=0,r||I(this,e,t,2,32767,-32768),u.TYPED_ARRAY_SUPPORT?(this[t]=e>>>8,this[t+1]=255&e):L(this,e,t,!1),t+2},u.prototype.writeInt32LE=function(e,t,r){return e=+e,t|=0,r||I(this,e,t,4,2147483647,-2147483648),u.TYPED_ARRAY_SUPPORT?(this[t]=255&e,this[t+1]=e>>>8,this[t+2]=e>>>16,this[t+3]=e>>>24):D(this,e,t,!0),t+4},u.prototype.writeInt32BE=function(e,t,r){return e=+e,t|=0,r||I(this,e,t,4,2147483647,-2147483648),e<0&&(e=4294967295+e+1),u.TYPED_ARRAY_SUPPORT?(this[t]=e>>>24,this[t+1]=e>>>16,this[t+2]=e>>>8,this[t+3]=255&e):D(this,e,t,!1),t+4},u.prototype.writeFloatLE=function(e,t,r){return G(this,e,t,!0,r)},u.prototype.writeFloatBE=function(e,t,r){return G(this,e,t,!1,r)},u.prototype.writeDoubleLE=function(e,t,r){return N(this,e,t,!0,r)},u.prototype.writeDoubleBE=function(e,t,r){return N(this,e,t,!1,r)},u.prototype.copy=function(e,t,r,n){if(r||(r=0),n||0===n||(n=this.length),t>=e.length&&(t=e.length),t||(t=0),n>0&&n=this.length)throw new RangeError("sourceStart out of bounds");if(n<0)throw new RangeError("sourceEnd out of bounds");n>this.length&&(n=this.length),e.length-t=0;--o)e[o+t]=this[o+r];else if(i<1e3||!u.TYPED_ARRAY_SUPPORT)for(o=0;o>>=0,r=void 0===r?this.length:r>>>0,e||(e=0);var i;if("number"==typeof e)for(i=t;i=31||"undefined"!=typeof navigator&&navigator&&navigator.userAgent&&navigator.userAgent.toLowerCase().match(/applewebkit\/(\d+)/))}function i(e){var t=this.useColors;if(e[0]=(t?"%c":"")+this.namespace+(t?" %c":" ")+e[0]+(t?"%c ":" ")+"+"+r.humanize(this.diff),t){var n="color: "+this.color;e.splice(1,0,n,"color: inherit");var o=0,i=0;e[0].replace(/%[a-zA-Z%]/g,function(e){"%%"!==e&&(o++,"%c"===e&&(i=o))}),e.splice(i,0,n)}}function u(){return"object"==typeof console&&console.log&&Function.prototype.apply.call(console.log,console,arguments)}function s(e){try{null==e?r.storage.removeItem("debug"):r.storage.debug=e}catch(e){}}function a(){try{return r.storage.debug}catch(e){}if("undefined"!=typeof n&&"env"in n)return n.env.DEBUG}function f(){try{return window.localStorage}catch(e){}}r=t.exports=e("./debug"),r.log=u,r.formatArgs=i,r.save=s,r.load=a,r.useColors=o,r.storage="undefined"!=typeof chrome&&"undefined"!=typeof chrome.storage?chrome.storage.local:f(),r.colors=["lightseagreen","forestgreen","goldenrod","dodgerblue","darkorchid","crimson"],r.formatters.j=function(e){try{return JSON.stringify(e)}catch(e){return"[UnexpectedJSONParseError]: "+e.message}},r.enable(a())}).call(this,e("_process"))},{"./debug":41,_process:46}],41:[function(e,t,r){function n(e){var t,n=0;for(t in e)n=(n<<5)-n+e.charCodeAt(t),n|=0;return r.colors[Math.abs(n)%r.colors.length]}function o(e){function t(){if(t.enabled){var e=t,n=+new Date,o=n-(f||n);e.diff=o,e.prev=f,e.curr=n,f=n;for(var i=new Array(arguments.length),u=0;u>1,c=-7,l=r?o-1:0,h=r?-1:1,p=e[t+l];for(l+=h,i=p&(1<<-c)-1,p>>=-c,c+=s;c>0;i=256*i+e[t+l],l+=h,c-=8);for(u=i&(1<<-c)-1,i>>=-c,c+=n;c>0;u=256*u+e[t+l],l+=h,c-=8);if(0===i)i=1-f;else{if(i===a)return u?NaN:(p?-1:1)*(1/0);u+=Math.pow(2,n),i-=f}return(p?-1:1)*u*Math.pow(2,i-n)},r.write=function(e,t,r,n,o,i){var u,s,a,f=8*i-o-1,c=(1<>1,h=23===o?Math.pow(2,-24)-Math.pow(2,-77):0,p=n?0:i-1,d=n?1:-1,y=t<0||0===t&&1/t<0?1:0;for(t=Math.abs(t),isNaN(t)||t===1/0?(s=isNaN(t)?1:0,u=c):(u=Math.floor(Math.log(t)/Math.LN2),t*(a=Math.pow(2,-u))<1&&(u--,a*=2),t+=u+l>=1?h/a:h*Math.pow(2,1-l),t*a>=2&&(u++,a/=2),u+l>=c?(s=0,u=c):u+l>=1?(s=(t*a-1)*Math.pow(2,o),u+=l):(s=t*Math.pow(2,l-1)*Math.pow(2,o),u=0));o>=8;e[r+p]=255&s,p+=d,s/=256,o-=8);for(u=u<0;e[r+p]=255&u,p+=d,u/=256,f-=8);e[r+p-d]|=128*y}},{}],43:[function(e,t,r){var n={}.toString;t.exports=Array.isArray||function(e){return"[object Array]"==n.call(e)}},{}],44:[function(e,t,r){!function(r){"use strict";var n,o=r.Base64,i="2.1.9";if("undefined"!=typeof t&&t.exports)try{n=e("buffer").Buffer}catch(e){}var u="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/",s=function(e){for(var t={},r=0,n=e.length;r>>6)+a(128|63&t):a(224|t>>>12&15)+a(128|t>>>6&63)+a(128|63&t)}var t=65536+1024*(e.charCodeAt(0)-55296)+(e.charCodeAt(1)-56320);return a(240|t>>>18&7)+a(128|t>>>12&63)+a(128|t>>>6&63)+a(128|63&t)},c=/[\uD800-\uDBFF][\uDC00-\uDFFFF]|[^\x00-\x7F]/g,l=function(e){return e.replace(c,f)},h=function(e){var t=[0,2,1][e.length%3],r=e.charCodeAt(0)<<16|(e.length>1?e.charCodeAt(1):0)<<8|(e.length>2?e.charCodeAt(2):0),n=[u.charAt(r>>>18),u.charAt(r>>>12&63),t>=2?"=":u.charAt(r>>>6&63),t>=1?"=":u.charAt(63&r)];return n.join("")},p=r.btoa?function(e){return r.btoa(e)}:function(e){return e.replace(/[\s\S]{1,3}/g,h)},d=n?function(e){return(e.constructor===n.constructor?e:new n(e)).toString("base64")}:function(e){return p(l(e))},y=function(e,t){return t?d(String(e)).replace(/[+\/]/g,function(e){return"+"==e?"-":"_"}).replace(/=/g,""):d(String(e))},_=function(e){return y(e,!0)},g=new RegExp(["[À-ß][€-¿]","[à-ï][€-¿]{2}","[ð-÷][€-¿]{3}"].join("|"),"g"),m=function(e){switch(e.length){case 4:var t=(7&e.charCodeAt(0))<<18|(63&e.charCodeAt(1))<<12|(63&e.charCodeAt(2))<<6|63&e.charCodeAt(3),r=t-65536;return a((r>>>10)+55296)+a((1023&r)+56320);case 3:return a((15&e.charCodeAt(0))<<12|(63&e.charCodeAt(1))<<6|63&e.charCodeAt(2));default:return a((31&e.charCodeAt(0))<<6|63&e.charCodeAt(1))}},v=function(e){return e.replace(g,m)},b=function(e){var t=e.length,r=t%4,n=(t>0?s[e.charAt(0)]<<18:0)|(t>1?s[e.charAt(1)]<<12:0)|(t>2?s[e.charAt(2)]<<6:0)|(t>3?s[e.charAt(3)]:0),o=[a(n>>>16),a(n>>>8&255),a(255&n)];return o.length-=[0,0,2,1][r],o.join("")},w=r.atob?function(e){return r.atob(e)}:function(e){return e.replace(/[\s\S]{1,4}/g,b)},E=n?function(e){return(e.constructor===n.constructor?e:new n(e,"base64")).toString()}:function(e){return v(w(e))},T=function(e){return E(String(e).replace(/[-_]/g,function(e){return"-"==e?"+":"/"}).replace(/[^A-Za-z0-9\+\/]/g,""))},k=function(){var e=r.Base64;return r.Base64=o,e};if(r.Base64={VERSION:i,atob:w,btoa:p,fromBase64:T,toBase64:y,utob:l,encode:y,encodeURI:_,btou:v,decode:T,noConflict:k},"function"==typeof Object.defineProperty){var A=function(e){return{value:e,enumerable:!1,writable:!0,configurable:!0}};r.Base64.extendString=function(){Object.defineProperty(String.prototype,"fromBase64",A(function(){return T(this)})),Object.defineProperty(String.prototype,"toBase64",A(function(e){return y(this,e)})),Object.defineProperty(String.prototype,"toBase64URI",A(function(){return y(this,!0)}))}}r.Meteor&&(Base64=r.Base64)}(this)},{buffer:39}],45:[function(e,t,r){function n(e){if(e=String(e),!(e.length>1e4)){var t=/^((?:\d+)?\.?\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|years?|yrs?|y)?$/i.exec(e);if(t){var r=parseFloat(t[1]),n=(t[2]||"ms").toLowerCase();switch(n){case"years":case"year":case"yrs":case"yr":case"y":return r*l;case"days":case"day":case"d":return r*c;case"hours":case"hour":case"hrs":case"hr":case"h":return r*f;case"minutes":case"minute":case"mins":case"min":case"m":return r*a;case"seconds":case"second":case"secs":case"sec":case"s":return r*s;case"milliseconds":case"millisecond":case"msecs":case"msec":case"ms":return r;default:return}}}}function o(e){return e>=c?Math.round(e/c)+"d":e>=f?Math.round(e/f)+"h":e>=a?Math.round(e/a)+"m":e>=s?Math.round(e/s)+"s":e+"ms"}function i(e){return u(e,c,"day")||u(e,f,"hour")||u(e,a,"minute")||u(e,s,"second")||e+" ms"}function u(e,t,r){if(!(e0)return n(e);if("number"===r&&isNaN(e)===!1)return t.long?i(e):o(e);throw new Error("val is not a non-empty string or a valid number. val="+JSON.stringify(e))}},{}],46:[function(e,t,r){function n(){throw new Error("setTimeout has not been defined")}function o(){throw new Error("clearTimeout has not been defined")}function i(e){if(l===setTimeout)return setTimeout(e,0);if((l===n||!l)&&setTimeout)return l=setTimeout,setTimeout(e,0);try{return l(e,0)}catch(t){try{return l.call(null,e,0)}catch(t){return l.call(this,e,0)}}}function u(e){if(h===clearTimeout)return clearTimeout(e);if((h===o||!h)&&clearTimeout)return h=clearTimeout,clearTimeout(e);try{return h(e)}catch(t){try{return h.call(null,e)}catch(t){return h.call(this,e)}}}function s(){_&&d&&(_=!1,d.length?y=d.concat(y):g=-1,y.length&&a())}function a(){if(!_){var e=i(s);_=!0;for(var t=y.length;t;){for(d=y,y=[];++g1)for(var r=1;r=55296&&t<=56319&&o65535&&(t-=65536,o+=b(t>>>10&1023|55296),t=56320|1023&t),o+=b(t);return o}function s(e){if(e>=55296&&e<=57343)throw Error("Lone surrogate U+"+e.toString(16).toUpperCase()+" is not a scalar value")}function a(e,t){return b(e>>t&63|128)}function f(e){if(0==(4294967168&e))return b(e);var t="";return 0==(4294965248&e)?t=b(e>>6&31|192):0==(4294901760&e)?(s(e),t=b(e>>12&15|224),t+=a(e,6)):0==(4292870144&e)&&(t=b(e>>18&7|240),t+=a(e,12),t+=a(e,6)),t+=b(63&e|128)}function c(e){for(var t,r=i(e),n=r.length,o=-1,u="";++o=m)throw Error("Invalid byte index");var e=255&g[v];if(v++,128==(192&e))return 63&e;throw Error("Invalid continuation byte")}function h(){var e,t,r,n,o;if(v>m)throw Error("Invalid byte index");if(v==m)return!1;if(e=255&g[v],v++,0==(128&e))return e;if(192==(224&e)){if(t=l(),o=(31&e)<<6|t,o>=128)return o;throw Error("Invalid continuation byte")}if(224==(240&e)){if(t=l(),r=l(),o=(15&e)<<12|t<<6|r,o>=2048)return s(o),o;throw Error("Invalid continuation byte")}if(240==(248&e)&&(t=l(),r=l(),n=l(),o=(7&e)<<18|t<<12|r<<6|n,o>=65536&&o<=1114111))return o;throw Error("Invalid UTF-8 detected")}function p(e){g=i(e),m=g.length,v=0;for(var t,r=[];(t=h())!==!1;)r.push(t);return u(r)}var d="object"==typeof n&&n,y="object"==typeof r&&r&&r.exports==d&&r,_="object"==typeof t&&t;_.global!==_&&_.window!==_||(o=_);var g,m,v,b=String.fromCharCode,w={version:"2.1.2",encode:c,decode:p};if("function"==typeof e&&"object"==typeof e.amd&&e.amd)e(function(){return w});else if(d&&!d.nodeType)if(y)y.exports=w;else{var E={},T=E.hasOwnProperty;for(var k in w)T.call(w,k)&&(d[k]=w[k])}else o.utf8=w}(this)}).call(this,"undefined"!=typeof global?global:"undefined"!=typeof self?self:"undefined"!=typeof window?window:{})},{}]},{},[2])(2)}); //# sourceMappingURL=GitHub.bundle.min.js.map diff --git a/dist/GitHub.bundle.min.js.map b/dist/GitHub.bundle.min.js.map index 568a06ec..98b32689 100644 --- a/dist/GitHub.bundle.min.js.map +++ b/dist/GitHub.bundle.min.js.map @@ -1 +1 @@ -{"version":3,"sources":["node_modules/browser-pack/_prelude.js","lib/Gist.js","lib/GitHub.js","lib/Issue.js","lib/Markdown.js","lib/Organization.js","lib/Project.js","lib/RateLimit.js","lib/Repository.js","lib/Requestable.js","lib/Search.js","lib/Team.js","lib/User.js","node_modules/axios/index.js","node_modules/axios/lib/adapters/xhr.js","node_modules/axios/lib/axios.js","node_modules/axios/lib/cancel/Cancel.js","node_modules/axios/lib/cancel/CancelToken.js","node_modules/axios/lib/cancel/isCancel.js","node_modules/axios/lib/core/Axios.js","node_modules/axios/lib/core/InterceptorManager.js","node_modules/axios/lib/core/createError.js","node_modules/axios/lib/core/dispatchRequest.js","node_modules/axios/lib/core/enhanceError.js","node_modules/axios/lib/core/settle.js","node_modules/axios/lib/core/transformData.js","node_modules/axios/lib/defaults.js","node_modules/axios/lib/helpers/bind.js","node_modules/axios/lib/helpers/btoa.js","node_modules/axios/lib/helpers/buildURL.js","node_modules/axios/lib/helpers/combineURLs.js","node_modules/axios/lib/helpers/cookies.js","node_modules/axios/lib/helpers/isAbsoluteURL.js","node_modules/axios/lib/helpers/isURLSameOrigin.js","node_modules/axios/lib/helpers/normalizeHeaderName.js","node_modules/axios/lib/helpers/parseHeaders.js","node_modules/axios/lib/helpers/spread.js","node_modules/axios/lib/utils.js","node_modules/base64-js/index.js","node_modules/buffer/index.js","node_modules/debug/src/browser.js","node_modules/debug/src/debug.js","node_modules/ieee754/index.js","node_modules/isarray/index.js","node_modules/js-base64/base64.js","node_modules/ms/index.js","node_modules/process/browser.js","node_modules/utf8/utf8.js"],"names":["f","exports","module","define","amd","g","window","global","self","this","GitHub","e","t","n","r","s","o","u","a","require","i","Error","code","l","call","length","1","_Requestable2","Gist","id","auth","apiBase","_classCallCheck","_this","_possibleConstructorReturn","__proto__","Object","getPrototypeOf","__id","cb","_request","gist","_this2","then","response","data","_request204or404","_requestAllPages","revision","comment","body","_Gist","_User","_Issue","_Search","_RateLimit","_Repository","_Organization","_Team","_Markdown","_Project","arguments","undefined","__apiBase","__auth","_Gist2","default","user","_User2","organization","_Organization2","teamId","_Team2","repo","_Repository2","_getFullName","_Issue2","query","_Search2","_RateLimit2","_Markdown2","_Project2","fullname","Issue","repository","__repository","issueData","options","issue","milestone","milestoneData","labelData","label","Markdown","Organization","__name","requestOptions","_getOptionsWithDefaults","direction","username","AcceptHeader","Project","colId","position","listProjectColumns","_ref","Promise","all","map","column","cardsInColumns","cards","reduce","prev","_ref2","push","apply","_toConsumableArray","catch","err","cardId","column_id","RateLimit","_utf","_jsBase","_debug","log","_debug2","Repository","__fullname","__currentTree","branch","sha","ref","number","base","head","since","_dateToISO","until","path","treeSHA","content","postBody","_getContentObject","_utf2","encode","encoding","Buffer","toString","Blob","Base64","_typeof","JSON","stringify","baseTreeSHA","blobSHA","newTree","base_tree","tree","mode","type","baseSHA","parent","message","parents","commitSHA","force","raw","encodeURI","oldBranch","newBranch","_this3","getRef","object","createRef","_this4","getSha","deleteCommit","oldPath","newPath","_this5","oldSha","getTree","_ref2$data","createTree","_ref3","commit","_ref4","updateHead","_this6","filePath","shouldEncode","author","committer","methodHasNoBody","method","METHODS_WITH_NO_BODY","indexOf","getNextPage","linksHeader","links","split","nextUrl","link","search","match","callbackErrorOrThrow","error","hasOwnProperty","_object$response","status","statusText","_object$config","config","url","ResponseError","_axios","request","Requestable","token","password","__AcceptHeader","__authorizationHeader","newCacheBuster","Date","getTime","replace","headers","Content-Type","Accept","Authorization","visibility","affiliation","sort","per_page","date","toISOString","__getURL","__getRequestHeaders","queryParams","shouldUseDataAsParams","params","responseType","requestPromise","_axios2","keys","results","_results","thisGroup","Array","items","page","Search","defaults","__defaults","withOptions","forEach","prop","_search","Team","__teamId","owner","User","__user","endpoint","__getScopedUrl","before","utils","settle","buildURL","parseHeaders","isURLSameOrigin","createError","btoa","bind","resolve","reject","requestData","requestHeaders","isFormData","XMLHttpRequest","loadEvent","xDomain","process","env","NODE_ENV","XDomainRequest","onprogress","ontimeout","open","toUpperCase","paramsSerializer","timeout","readyState","responseURL","responseHeaders","getAllResponseHeaders","responseData","responseText","onerror","isStandardBrowserEnv","cookies","xsrfValue","withCredentials","xsrfCookieName","read","xsrfHeaderName","val","key","toLowerCase","setRequestHeader","onDownloadProgress","addEventListener","onUploadProgress","upload","cancelToken","promise","cancel","abort","send","createInstance","defaultConfig","context","Axios","instance","prototype","extend","axios","create","instanceConfig","merge","Cancel","CancelToken","isCancel","promises","spread","__CANCEL__","executor","TypeError","resolvePromise","reason","throwIfRequested","source","c","value","interceptors","InterceptorManager","dispatchRequest","isAbsoluteURL","combineURLs","baseURL","chain","interceptor","unshift","fulfilled","rejected","shift","handlers","use","eject","fn","h","enhanceError","throwIfCancellationRequested","transformData","transformRequest","common","adapter","transformResponse","validateStatus","fns","setContentTypeIfUnset","isUndefined","getDefaultAdapter","normalizeHeaderName","PROTECTION_PREFIX","DEFAULT_CONTENT_TYPE","isArrayBuffer","isStream","isFile","isBlob","isArrayBufferView","buffer","isURLSearchParams","isObject","parse","maxContentLength","thisArg","args","E","input","block","charCode","str","String","output","idx","chars","charAt","charCodeAt","name","encodeURIComponent","serializedParams","parts","isArray","v","isDate","join","relativeURL","write","expires","domain","secure","cookie","isNumber","toGMTString","isString","document","RegExp","decodeURIComponent","remove","now","test","resolveURL","href","msie","urlParsingNode","setAttribute","protocol","host","hash","hostname","port","pathname","originURL","navigator","userAgent","createElement","location","requestURL","parsed","normalizedName","line","trim","substr","callback","arr","FormData","result","ArrayBuffer","isView","isFunction","pipe","URLSearchParams","obj","assignValue","b","placeHoldersCount","b64","len","byteLength","toByteArray","j","tmp","placeHolders","Arr","L","revLookup","tripletToBase64","num","lookup","encodeChunk","uint8","start","end","fromByteArray","extraBytes","maxChunkLength","len2","Uint8Array","typedArraySupport","foo","subarray","kMaxLength","TYPED_ARRAY_SUPPORT","createBuffer","that","RangeError","arg","encodingOrOffset","allocUnsafe","from","fromArrayBuffer","fromString","fromObject","assertSize","size","alloc","fill","checked","string","isEncoding","actual","slice","fromArrayLike","array","byteOffset","isBuffer","copy","isnan","SlowBuffer","loweredCase","utf8ToBytes","base64ToBytes","slowToString","hexSlice","utf8Slice","asciiSlice","latin1Slice","base64Slice","utf16leSlice","swap","m","bidirectionalIndexOf","dir","isNaN","arrayIndexOf","lastIndexOf","buf","indexSize","readUInt16BE","arrLength","valLength","foundIndex","found","hexWrite","offset","Number","remaining","strLen","parseInt","utf8Write","blitBuffer","asciiWrite","asciiToBytes","latin1Write","base64Write","ucs2Write","utf16leToBytes","base64","Math","min","res","firstByte","codePoint","bytesPerSequence","secondByte","thirdByte","fourthByte","tempCodePoint","decodeCodePointsArray","codePoints","MAX_ARGUMENTS_LENGTH","fromCharCode","ret","out","toHex","bytes","checkOffset","ext","checkInt","max","objectWriteUInt16","littleEndian","objectWriteUInt32","checkIEEE754","writeFloat","noAssert","ieee754","writeDouble","base64clean","stringtrim","INVALID_BASE64_RE","units","Infinity","leadSurrogate","byteArray","hi","lo","src","dst","INSPECT_MAX_BYTES","poolSize","_augment","Symbol","species","defineProperty","configurable","allocUnsafeSlow","_isBuffer","compare","x","y","concat","list","pos","swap16","swap32","swap64","equals","inspect","target","thisStart","thisEnd","thisCopy","targetCopy","includes","isFinite","toJSON","_arr","newBuf","sliceLen","readUIntLE","mul","readUIntBE","readUInt8","readUInt16LE","readUInt32LE","readUInt32BE","readIntLE","pow","readIntBE","readInt8","readInt16LE","readInt16BE","readInt32LE","readInt32BE","readFloatLE","readFloatBE","readDoubleLE","readDoubleBE","writeUIntLE","maxBytes","writeUIntBE","writeUInt8","floor","writeUInt16LE","writeUInt16BE","writeUInt32LE","writeUInt32BE","writeIntLE","limit","sub","writeIntBE","writeInt8","writeInt16LE","writeInt16BE","writeInt32LE","writeInt32BE","writeFloatLE","writeFloatBE","writeDoubleLE","writeDoubleBE","targetStart","set","useColors","documentElement","style","console","firebug","exception","table","$1","formatArgs","namespace","humanize","diff","color","splice","index","lastC","Function","save","namespaces","storage","removeItem","debug","load","DEBUG","localstorage","localStorage","chrome","local","colors","formatters","enable","selectColor","abs","createDebug","enabled","curr","ms","prevTime","coerce","format","formatter","logFn","init","skips","names","disable","stack","isLE","mLen","nBytes","eLen","eMax","eBias","nBits","d","NaN","rt","LN2","_Base64","version","b64chars","b64tab","bin","cb_utob","cc","re_utob","utob","cb_encode","ccc","padlen","ord","_encode","constructor","urisafe","m0","re_btou","cb_btou","cccc","cp","btou","cb_decode","atob","_decode","decode","noConflict","VERSION","fromBase64","toBase64","noEnum","enumerable","writable","extendString","exec","parseFloat","fmtShort","round","fmtLong","plural","ceil","long","defaultSetTimout","defaultClearTimeout","runTimeout","fun","cachedSetTimeout","setTimeout","runClearTimeout","marker","cachedClearTimeout","clearTimeout","cleanUpNextTick","draining","currentQueue","queue","queueIndex","drainQueue","run","Item","noop","nextTick","title","browser","argv","versions","on","addListener","once","off","removeListener","removeAllListeners","emit","binding","cwd","chdir","umask","root","ucs2decode","extra","counter","ucs2encode","stringFromCharCode","checkScalarValue","createByte","encodeCodePoint","symbol","utf8encode","byteString","readContinuationByte","byteIndex","byteCount","continuationByte","decodeSymbol","byte1","byte2","byte3","byte4","utf8decode","freeExports","freeModule","freeGlobal","utf8","nodeType"],"mappings":"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","file":"GitHub.bundle.min.js","sourcesContent":["(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require==\"function\"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error(\"Cannot find module '\"+o+\"'\");throw f.code=\"MODULE_NOT_FOUND\",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require==\"function\"&&require;for(var o=0;o {\n this.__id = response.data.id;\n return response;\n });\n }\n\n /**\n * Delete a gist.\n * @see https://developer.github.com/v3/gists/#delete-a-gist\n * @param {Requestable.callback} [cb] - will receive true if the request succeeds\n * @return {Promise} - the Promise for the http request\n */\n delete(cb) {\n return this._request('DELETE', `/gists/${this.__id}`, null, cb);\n }\n\n /**\n * Fork a gist.\n * @see https://developer.github.com/v3/gists/#fork-a-gist\n * @param {Requestable.callback} [cb] - the function that will receive the gist\n * @return {Promise} - the Promise for the http request\n */\n fork(cb) {\n return this._request('POST', `/gists/${this.__id}/forks`, null, cb);\n }\n\n /**\n * Update a gist.\n * @see https://developer.github.com/v3/gists/#edit-a-gist\n * @param {Object} gist - the new data for the gist\n * @param {Requestable.callback} [cb] - the function that receives the API result\n * @return {Promise} - the Promise for the http request\n */\n update(gist, cb) {\n return this._request('PATCH', `/gists/${this.__id}`, gist, cb);\n }\n\n /**\n * Star a gist.\n * @see https://developer.github.com/v3/gists/#star-a-gist\n * @param {Requestable.callback} [cb] - will receive true if the request is successful\n * @return {Promise} - the Promise for the http request\n */\n star(cb) {\n return this._request('PUT', `/gists/${this.__id}/star`, null, cb);\n }\n\n /**\n * Unstar a gist.\n * @see https://developer.github.com/v3/gists/#unstar-a-gist\n * @param {Requestable.callback} [cb] - will receive true if the request is successful\n * @return {Promise} - the Promise for the http request\n */\n unstar(cb) {\n return this._request('DELETE', `/gists/${this.__id}/star`, null, cb);\n }\n\n /**\n * Check if a gist is starred by the user.\n * @see https://developer.github.com/v3/gists/#check-if-a-gist-is-starred\n * @param {Requestable.callback} [cb] - will receive true if the gist is starred and false if the gist is not starred\n * @return {Promise} - the Promise for the http request\n */\n isStarred(cb) {\n return this._request204or404(`/gists/${this.__id}/star`, null, cb);\n }\n\n /**\n * List the gist's commits\n * @see https://developer.github.com/v3/gists/#list-gist-commits\n * @param {Requestable.callback} [cb] - will receive the array of commits\n * @return {Promise} - the Promise for the http request\n */\n listCommits(cb) {\n return this._requestAllPages(`/gists/${this.__id}/commits`, null, cb);\n }\n\n /**\n * Fetch one of the gist's revision.\n * @see https://developer.github.com/v3/gists/#get-a-specific-revision-of-a-gist\n * @param {string} revision - the id of the revision\n * @param {Requestable.callback} [cb] - will receive the revision\n * @return {Promise} - the Promise for the http request\n */\n getRevision(revision, cb) {\n return this._request('GET', `/gists/${this.__id}/${revision}`, null, cb);\n }\n\n /**\n * List the gist's comments\n * @see https://developer.github.com/v3/gists/comments/#list-comments-on-a-gist\n * @param {Requestable.callback} [cb] - will receive the array of comments\n * @return {Promise} - the promise for the http request\n */\n listComments(cb) {\n return this._requestAllPages(`/gists/${this.__id}/comments`, null, cb);\n }\n\n /**\n * Fetch one of the gist's comments\n * @see https://developer.github.com/v3/gists/comments/#get-a-single-comment\n * @param {number} comment - the id of the comment\n * @param {Requestable.callback} [cb] - will receive the comment\n * @return {Promise} - the Promise for the http request\n */\n getComment(comment, cb) {\n return this._request('GET', `/gists/${this.__id}/comments/${comment}`, null, cb);\n }\n\n /**\n * Comment on a gist\n * @see https://developer.github.com/v3/gists/comments/#create-a-comment\n * @param {string} comment - the comment to add\n * @param {Requestable.callback} [cb] - the function that receives the API result\n * @return {Promise} - the Promise for the http request\n */\n createComment(comment, cb) {\n return this._request('POST', `/gists/${this.__id}/comments`, {body: comment}, cb);\n }\n\n /**\n * Edit a comment on the gist\n * @see https://developer.github.com/v3/gists/comments/#edit-a-comment\n * @param {number} comment - the id of the comment\n * @param {string} body - the new comment\n * @param {Requestable.callback} [cb] - will receive the modified comment\n * @return {Promise} - the promise for the http request\n */\n editComment(comment, body, cb) {\n return this._request('PATCH', `/gists/${this.__id}/comments/${comment}`, {body: body}, cb);\n }\n\n /**\n * Delete a comment on the gist.\n * @see https://developer.github.com/v3/gists/comments/#delete-a-comment\n * @param {number} comment - the id of the comment\n * @param {Requestable.callback} [cb] - will receive true if the request succeeds\n * @return {Promise} - the Promise for the http request\n */\n deleteComment(comment, cb) {\n return this._request('DELETE', `/gists/${this.__id}/comments/${comment}`, null, cb);\n }\n}\n\nmodule.exports = Gist;\n","/**\n * @file\n * @copyright 2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n * Github.js is freely distributable.\n */\n/* eslint valid-jsdoc: [\"error\", {\"requireReturnDescription\": false}] */\n\nimport Gist from './Gist';\nimport User from './User';\nimport Issue from './Issue';\nimport Search from './Search';\nimport RateLimit from './RateLimit';\nimport Repository from './Repository';\nimport Organization from './Organization';\nimport Team from './Team';\nimport Markdown from './Markdown';\nimport Project from './Project';\n\n/**\n * GitHub encapsulates the functionality to create various API wrapper objects.\n */\nclass GitHub {\n /**\n * Create a new GitHub.\n * @param {Requestable.auth} [auth] - the credentials to authenticate to Github. If auth is\n * not provided requests will be made unauthenticated\n * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n */\n constructor(auth, apiBase = 'https://api.github.com') {\n this.__apiBase = apiBase;\n this.__auth = auth || {};\n }\n\n /**\n * Create a new Gist wrapper\n * @param {number} [id] - the id for the gist, leave undefined when creating a new gist\n * @return {Gist}\n */\n getGist(id) {\n return new Gist(id, this.__auth, this.__apiBase);\n }\n\n /**\n * Create a new User wrapper\n * @param {string} [user] - the name of the user to get information about\n * leave undefined for the authenticated user\n * @return {User}\n */\n getUser(user) {\n return new User(user, this.__auth, this.__apiBase);\n }\n\n /**\n * Create a new Organization wrapper\n * @param {string} organization - the name of the organization\n * @return {Organization}\n */\n getOrganization(organization) {\n return new Organization(organization, this.__auth, this.__apiBase);\n }\n\n /**\n * create a new Team wrapper\n * @param {string} teamId - the name of the team\n * @return {team}\n */\n getTeam(teamId) {\n return new Team(teamId, this.__auth, this.__apiBase);\n }\n\n /**\n * Create a new Repository wrapper\n * @param {string} user - the user who owns the respository\n * @param {string} repo - the name of the repository\n * @return {Repository}\n */\n getRepo(user, repo) {\n return new Repository(this._getFullName(user, repo), this.__auth, this.__apiBase);\n }\n\n /**\n * Create a new Issue wrapper\n * @param {string} user - the user who owns the respository\n * @param {string} repo - the name of the repository\n * @return {Issue}\n */\n getIssues(user, repo) {\n return new Issue(this._getFullName(user, repo), this.__auth, this.__apiBase);\n }\n\n /**\n * Create a new Search wrapper\n * @param {string} query - the query to search for\n * @return {Search}\n */\n search(query) {\n return new Search(query, this.__auth, this.__apiBase);\n }\n\n /**\n * Create a new RateLimit wrapper\n * @return {RateLimit}\n */\n getRateLimit() {\n return new RateLimit(this.__auth, this.__apiBase);\n }\n\n /**\n * Create a new Markdown wrapper\n * @return {Markdown}\n */\n getMarkdown() {\n return new Markdown(this.__auth, this.__apiBase);\n }\n\n /**\n * Create a new Project wrapper\n * @param {string} id - the id of the project\n * @return {Markdown}\n */\n getProject(id) {\n return new Project(id, this.__auth, this.__apiBase);\n }\n\n /**\n * Computes the full repository name\n * @param {string} user - the username (or the full name)\n * @param {string} repo - the repository name, must not be passed if `user` is the full name\n * @return {string} the repository's full name\n */\n _getFullName(user, repo) {\n let fullname = user;\n\n if (repo) {\n fullname = `${user}/${repo}`;\n }\n\n return fullname;\n }\n}\n\nmodule.exports = GitHub;\n","/**\n * @file\n * @copyright 2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n * Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\n\n/**\n * Issue wraps the functionality to get issues for repositories\n */\nclass Issue extends Requestable {\n /**\n * Create a new Issue\n * @param {string} repository - the full name of the repository (`:user/:repo`) to get issues for\n * @param {Requestable.auth} [auth] - information required to authenticate to Github\n * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n */\n constructor(repository, auth, apiBase) {\n super(auth, apiBase);\n this.__repository = repository;\n }\n\n /**\n * Create a new issue\n * @see https://developer.github.com/v3/issues/#create-an-issue\n * @param {Object} issueData - the issue to create\n * @param {Requestable.callback} [cb] - will receive the created issue\n * @return {Promise} - the promise for the http request\n */\n createIssue(issueData, cb) {\n return this._request('POST', `/repos/${this.__repository}/issues`, issueData, cb);\n }\n\n /**\n * List the issues for the repository\n * @see https://developer.github.com/v3/issues/#list-issues-for-a-repository\n * @param {Object} options - filtering options\n * @param {Requestable.callback} [cb] - will receive the array of issues\n * @return {Promise} - the promise for the http request\n */\n listIssues(options, cb) {\n return this._requestAllPages(`/repos/${this.__repository}/issues`, options, cb);\n }\n\n /**\n * List the events for an issue\n * @see https://developer.github.com/v3/issues/events/#list-events-for-an-issue\n * @param {number} issue - the issue to get events for\n * @param {Requestable.callback} [cb] - will receive the list of events\n * @return {Promise} - the promise for the http request\n */\n listIssueEvents(issue, cb) {\n return this._request('GET', `/repos/${this.__repository}/issues/${issue}/events`, null, cb);\n }\n\n /**\n * List comments on an issue\n * @see https://developer.github.com/v3/issues/comments/#list-comments-on-an-issue\n * @param {number} issue - the id of the issue to get comments from\n * @param {Requestable.callback} [cb] - will receive the comments\n * @return {Promise} - the promise for the http request\n */\n listIssueComments(issue, cb) {\n return this._request('GET', `/repos/${this.__repository}/issues/${issue}/comments`, null, cb);\n }\n\n /**\n * Get a single comment on an issue\n * @see https://developer.github.com/v3/issues/comments/#get-a-single-comment\n * @param {number} id - the comment id to get\n * @param {Requestable.callback} [cb] - will receive the comment\n * @return {Promise} - the promise for the http request\n */\n getIssueComment(id, cb) {\n return this._request('GET', `/repos/${this.__repository}/issues/comments/${id}`, null, cb);\n }\n\n /**\n * Comment on an issue\n * @see https://developer.github.com/v3/issues/comments/#create-a-comment\n * @param {number} issue - the id of the issue to comment on\n * @param {string} comment - the comment to add\n * @param {Requestable.callback} [cb] - will receive the created comment\n * @return {Promise} - the promise for the http request\n */\n createIssueComment(issue, comment, cb) {\n return this._request('POST', `/repos/${this.__repository}/issues/${issue}/comments`, {body: comment}, cb);\n }\n\n /**\n * Edit a comment on an issue\n * @see https://developer.github.com/v3/issues/comments/#edit-a-comment\n * @param {number} id - the comment id to edit\n * @param {string} comment - the comment to edit\n * @param {Requestable.callback} [cb] - will receive the edited comment\n * @return {Promise} - the promise for the http request\n */\n editIssueComment(id, comment, cb) {\n return this._request('PATCH', `/repos/${this.__repository}/issues/comments/${id}`, {body: comment}, cb);\n }\n\n /**\n * Delete a comment on an issue\n * @see https://developer.github.com/v3/issues/comments/#delete-a-comment\n * @param {number} id - the comment id to delete\n * @param {Requestable.callback} [cb] - will receive true if the request is successful\n * @return {Promise} - the promise for the http request\n */\n deleteIssueComment(id, cb) {\n return this._request('DELETE', `/repos/${this.__repository}/issues/comments/${id}`, null, cb);\n }\n\n /**\n * Edit an issue\n * @see https://developer.github.com/v3/issues/#edit-an-issue\n * @param {number} issue - the issue number to edit\n * @param {Object} issueData - the new issue data\n * @param {Requestable.callback} [cb] - will receive the modified issue\n * @return {Promise} - the promise for the http request\n */\n editIssue(issue, issueData, cb) {\n return this._request('PATCH', `/repos/${this.__repository}/issues/${issue}`, issueData, cb);\n }\n\n /**\n * Get a particular issue\n * @see https://developer.github.com/v3/issues/#get-a-single-issue\n * @param {number} issue - the issue number to fetch\n * @param {Requestable.callback} [cb] - will receive the issue\n * @return {Promise} - the promise for the http request\n */\n getIssue(issue, cb) {\n return this._request('GET', `/repos/${this.__repository}/issues/${issue}`, null, cb);\n }\n\n /**\n * List the milestones for the repository\n * @see https://developer.github.com/v3/issues/milestones/#list-milestones-for-a-repository\n * @param {Object} options - filtering options\n * @param {Requestable.callback} [cb] - will receive the array of milestones\n * @return {Promise} - the promise for the http request\n */\n listMilestones(options, cb) {\n return this._request('GET', `/repos/${this.__repository}/milestones`, options, cb);\n }\n\n /**\n * Get a milestone\n * @see https://developer.github.com/v3/issues/milestones/#get-a-single-milestone\n * @param {string} milestone - the id of the milestone to fetch\n * @param {Requestable.callback} [cb] - will receive the milestone\n * @return {Promise} - the promise for the http request\n */\n getMilestone(milestone, cb) {\n return this._request('GET', `/repos/${this.__repository}/milestones/${milestone}`, null, cb);\n }\n\n /**\n * Create a new milestone\n * @see https://developer.github.com/v3/issues/milestones/#create-a-milestone\n * @param {Object} milestoneData - the milestone definition\n * @param {Requestable.callback} [cb] - will receive the milestone\n * @return {Promise} - the promise for the http request\n */\n createMilestone(milestoneData, cb) {\n return this._request('POST', `/repos/${this.__repository}/milestones`, milestoneData, cb);\n }\n\n /**\n * Edit a milestone\n * @see https://developer.github.com/v3/issues/milestones/#update-a-milestone\n * @param {string} milestone - the id of the milestone to edit\n * @param {Object} milestoneData - the updates to make to the milestone\n * @param {Requestable.callback} [cb] - will receive the updated milestone\n * @return {Promise} - the promise for the http request\n */\n editMilestone(milestone, milestoneData, cb) {\n return this._request('PATCH', `/repos/${this.__repository}/milestones/${milestone}`, milestoneData, cb);\n }\n\n /**\n * Delete a milestone (this is distinct from closing a milestone)\n * @see https://developer.github.com/v3/issues/milestones/#delete-a-milestone\n * @param {string} milestone - the id of the milestone to delete\n * @param {Requestable.callback} [cb] - will receive the status\n * @return {Promise} - the promise for the http request\n */\n deleteMilestone(milestone, cb) {\n return this._request('DELETE', `/repos/${this.__repository}/milestones/${milestone}`, null, cb);\n }\n\n /**\n * Create a new label\n * @see https://developer.github.com/v3/issues/labels/#create-a-label\n * @param {Object} labelData - the label definition\n * @param {Requestable.callback} [cb] - will receive the object representing the label\n * @return {Promise} - the promise for the http request\n */\n createLabel(labelData, cb) {\n return this._request('POST', `/repos/${this.__repository}/labels`, labelData, cb);\n }\n\n /**\n * List the labels for the repository\n * @see https://developer.github.com/v3/issues/labels/#list-all-labels-for-this-repository\n * @param {Object} options - filtering options\n * @param {Requestable.callback} [cb] - will receive the array of labels\n * @return {Promise} - the promise for the http request\n */\n listLabels(options, cb) {\n return this._request('GET', `/repos/${this.__repository}/labels`, options, cb);\n }\n\n /**\n * Get a label\n * @see https://developer.github.com/v3/issues/labels/#get-a-single-label\n * @param {string} label - the name of the label to fetch\n * @param {Requestable.callback} [cb] - will receive the label\n * @return {Promise} - the promise for the http request\n */\n getLabel(label, cb) {\n return this._request('GET', `/repos/${this.__repository}/labels/${label}`, null, cb);\n }\n\n /**\n * Edit a label\n * @see https://developer.github.com/v3/issues/labels/#update-a-label\n * @param {string} label - the name of the label to edit\n * @param {Object} labelData - the updates to make to the label\n * @param {Requestable.callback} [cb] - will receive the updated label\n * @return {Promise} - the promise for the http request\n */\n editLabel(label, labelData, cb) {\n return this._request('PATCH', `/repos/${this.__repository}/labels/${label}`, labelData, cb);\n }\n\n /**\n * Delete a label\n * @see https://developer.github.com/v3/issues/labels/#delete-a-label\n * @param {string} label - the name of the label to delete\n * @param {Requestable.callback} [cb] - will receive the status\n * @return {Promise} - the promise for the http request\n */\n deleteLabel(label, cb) {\n return this._request('DELETE', `/repos/${this.__repository}/labels/${label}`, null, cb);\n }\n}\n\nmodule.exports = Issue;\n","/**\n * @file\n * @copyright 2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n * Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\n\n/**\n * Renders html from Markdown text\n */\nclass Markdown extends Requestable {\n /**\n * construct a Markdown\n * @param {Requestable.auth} auth - the credentials to authenticate to GitHub\n * @param {string} [apiBase] - the base Github API URL\n * @return {Promise} - the promise for the http request\n */\n constructor(auth, apiBase) {\n super(auth, apiBase);\n }\n\n /**\n * Render html from Markdown text.\n * @see https://developer.github.com/v3/markdown/#render-an-arbitrary-markdown-document\n * @param {Object} options - conversion options\n * @param {string} [options.text] - the markdown text to convert\n * @param {string} [options.mode=markdown] - can be either `markdown` or `gfm`\n * @param {string} [options.context] - repository name if mode is gfm\n * @param {Requestable.callback} [cb] - will receive the converted html\n * @return {Promise} - the promise for the http request\n */\n render(options, cb) {\n return this._request('POST', '/markdown', options, cb);\n }\n}\n\nmodule.exports = Markdown;\n","/**\n * @file\n * @copyright 2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n * Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\n\n/**\n * Organization encapsulates the functionality to create repositories in organizations\n */\nclass Organization extends Requestable {\n /**\n * Create a new Organization\n * @param {string} organization - the name of the organization\n * @param {Requestable.auth} [auth] - information required to authenticate to Github\n * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n */\n constructor(organization, auth, apiBase) {\n super(auth, apiBase);\n this.__name = organization;\n }\n\n /**\n * Create a repository in an organization\n * @see https://developer.github.com/v3/repos/#create\n * @param {Object} options - the repository definition\n * @param {Requestable.callback} [cb] - will receive the created repository\n * @return {Promise} - the promise for the http request\n */\n createRepo(options, cb) {\n return this._request('POST', `/orgs/${this.__name}/repos`, options, cb);\n }\n\n /**\n * List the repositories in an organization\n * @see https://developer.github.com/v3/repos/#list-organization-repositories\n * @param {Requestable.callback} [cb] - will receive the list of repositories\n * @return {Promise} - the promise for the http request\n */\n getRepos(cb) {\n let requestOptions = this._getOptionsWithDefaults({direction: 'desc'});\n\n return this._requestAllPages(`/orgs/${this.__name}/repos`, requestOptions, cb);\n }\n\n /**\n * Query if the user is a member or not\n * @param {string} username - the user in question\n * @param {Requestable.callback} [cb] - will receive true if the user is a member\n * @return {Promise} - the promise for the http request\n */\n isMember(username, cb) {\n return this._request204or404(`/orgs/${this.__name}/members/${username}`, null, cb);\n }\n\n /**\n * List the users who are members of the company\n * @see https://developer.github.com/v3/orgs/members/#members-list\n * @param {object} options - filtering options\n * @param {string} [options.filter=all] - can be either `2fa_disabled` or `all`\n * @param {string} [options.role=all] - can be one of: `all`, `admin`, or `member`\n * @param {Requestable.callback} [cb] - will receive the list of users\n * @return {Promise} - the promise for the http request\n */\n listMembers(options, cb) {\n return this._request('GET', `/orgs/${this.__name}/members`, options, cb);\n }\n\n /**\n * List the Teams in the Organization\n * @see https://developer.github.com/v3/orgs/teams/#list-teams\n * @param {Requestable.callback} [cb] - will receive the list of teams\n * @return {Promise} - the promise for the http request\n */\n getTeams(cb) {\n return this._requestAllPages(`/orgs/${this.__name}/teams`, undefined, cb);\n }\n\n /**\n * Create a team\n * @see https://developer.github.com/v3/orgs/teams/#create-team\n * @param {object} options - Team creation parameters\n * @param {string} options.name - The name of the team\n * @param {string} [options.description] - Team description\n * @param {string} [options.repo_names] - Repos to add the team to\n * @param {string} [options.privacy=secret] - The level of privacy the team should have. Can be either one\n * of: `secret`, or `closed`\n * @param {Requestable.callback} [cb] - will receive the created team\n * @return {Promise} - the promise for the http request\n */\n createTeam(options, cb) {\n return this._request('POST', `/orgs/${this.__name}/teams`, options, cb);\n }\n\n /**\n * Get information about all projects\n * @see https://developer.github.com/v3/projects/#list-organization-projects\n * @param {Requestable.callback} [cb] - will receive the list of projects\n * @return {Promise} - the promise for the http request\n */\n listProjects(cb) {\n return this._requestAllPages(`/orgs/${this.__name}/projects`, {AcceptHeader: 'inertia-preview'}, cb);\n }\n\n /**\n * Create a new project\n * @see https://developer.github.com/v3/repos/projects/#create-a-project\n * @param {Object} options - the description of the project\n * @param {Requestable.callback} cb - will receive the newly created project\n * @return {Promise} - the promise for the http request\n */\n createProject(options, cb) {\n options = options || {};\n options.AcceptHeader = 'inertia-preview';\n return this._request('POST', `/orgs/${this.__name}/projects`, options, cb);\n }\n}\n\nmodule.exports = Organization;\n","/**\n * @file\n * @copyright 2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n * Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\n\n/**\n * Project encapsulates the functionality to create, query, and modify cards and columns.\n */\nclass Project extends Requestable {\n /**\n * Create a Project.\n * @param {string} id - the id of the project\n * @param {Requestable.auth} [auth] - information required to authenticate to Github\n * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n */\n constructor(id, auth, apiBase) {\n super(auth, apiBase, 'inertia-preview');\n this.__id = id;\n }\n\n /**\n * Get information about a project\n * @see https://developer.github.com/v3/projects/#get-a-project\n * @param {Requestable.callback} cb - will receive the project information\n * @return {Promise} - the promise for the http request\n */\n getProject(cb) {\n return this._request('GET', `/projects/${this.__id}`, null, cb);\n }\n\n /**\n * Edit a project\n * @see https://developer.github.com/v3/projects/#update-a-project\n * @param {Object} options - the description of the project\n * @param {Requestable.callback} cb - will receive the modified project\n * @return {Promise} - the promise for the http request\n */\n updateProject(options, cb) {\n return this._request('PATCH', `/projects/${this.__id}`, options, cb);\n }\n\n /**\n * Delete a project\n * @see https://developer.github.com/v3/projects/#delete-a-project\n * @param {Requestable.callback} cb - will receive true if the operation is successful\n * @return {Promise} - the promise for the http request\n */\n deleteProject(cb) {\n return this._request('DELETE', `/projects/${this.__id}`, null, cb);\n }\n\n /**\n * Get information about all columns of a project\n * @see https://developer.github.com/v3/projects/columns/#list-project-columns\n * @param {Requestable.callback} [cb] - will receive the list of columns\n * @return {Promise} - the promise for the http request\n */\n listProjectColumns(cb) {\n return this._requestAllPages(`/projects/${this.__id}/columns`, null, cb);\n }\n\n /**\n * Get information about a column\n * @see https://developer.github.com/v3/projects/columns/#get-a-project-column\n * @param {string} colId - the id of the column\n * @param {Requestable.callback} cb - will receive the column information\n * @return {Promise} - the promise for the http request\n */\n getProjectColumn(colId, cb) {\n return this._request('GET', `/projects/columns/${colId}`, null, cb);\n }\n\n /**\n * Create a new column\n * @see https://developer.github.com/v3/projects/columns/#create-a-project-column\n * @param {Object} options - the description of the column\n * @param {Requestable.callback} cb - will receive the newly created column\n * @return {Promise} - the promise for the http request\n */\n createProjectColumn(options, cb) {\n return this._request('POST', `/projects/${this.__id}/columns`, options, cb);\n }\n\n /**\n * Edit a column\n * @see https://developer.github.com/v3/projects/columns/#update-a-project-column\n * @param {string} colId - the column id\n * @param {Object} options - the description of the column\n * @param {Requestable.callback} cb - will receive the modified column\n * @return {Promise} - the promise for the http request\n */\n updateProjectColumn(colId, options, cb) {\n return this._request('PATCH', `/projects/columns/${colId}`, options, cb);\n }\n\n /**\n * Delete a column\n * @see https://developer.github.com/v3/projects/columns/#delete-a-project-column\n * @param {string} colId - the column to be deleted\n * @param {Requestable.callback} cb - will receive true if the operation is successful\n * @return {Promise} - the promise for the http request\n */\n deleteProjectColumn(colId, cb) {\n return this._request('DELETE', `/projects/columns/${colId}`, null, cb);\n }\n\n /**\n * Move a column\n * @see https://developer.github.com/v3/projects/columns/#move-a-project-column\n * @param {string} colId - the column to be moved\n * @param {string} position - can be one of first, last, or after:,\n * where is the id value of a column in the same project.\n * @param {Requestable.callback} cb - will receive true if the operation is successful\n * @return {Promise} - the promise for the http request\n */\n moveProjectColumn(colId, position, cb) {\n return this._request(\n 'POST',\n `/projects/columns/${colId}/moves`,\n {position: position},\n cb\n );\n }\n\n /**\n * Get information about all cards of a project\n * @see https://developer.github.com/v3/projects/cards/#list-project-cards\n * @param {Requestable.callback} [cb] - will receive the list of cards\n * @return {Promise} - the promise for the http request\n */\n listProjectCards(cb) {\n return this.listProjectColumns()\n .then(({data}) => {\n return Promise.all(data.map((column) => {\n return this._requestAllPages(`/projects/columns/${column.id}/cards`, null);\n }));\n }).then((cardsInColumns) => {\n const cards = cardsInColumns.reduce((prev, {data}) => {\n prev.push(...data);\n return prev;\n }, []);\n if (cb) {\n cb(null, cards);\n }\n return cards;\n }).catch((err) => {\n if (cb) {\n cb(err);\n return;\n }\n throw err;\n });\n }\n\n /**\n * Get information about all cards of a column\n * @see https://developer.github.com/v3/projects/cards/#list-project-cards\n * @param {string} colId - the id of the column\n * @param {Requestable.callback} [cb] - will receive the list of cards\n * @return {Promise} - the promise for the http request\n */\n listColumnCards(colId, cb) {\n return this._requestAllPages(`/projects/columns/${colId}/cards`, null, cb);\n }\n\n /**\n * Get information about a card\n * @see https://developer.github.com/v3/projects/cards/#get-a-project-card\n * @param {string} cardId - the id of the card\n * @param {Requestable.callback} cb - will receive the card information\n * @return {Promise} - the promise for the http request\n */\n getProjectCard(cardId, cb) {\n return this._request('GET', `/projects/columns/cards/${cardId}`, null, cb);\n }\n\n /**\n * Create a new card\n * @see https://developer.github.com/v3/projects/cards/#create-a-project-card\n * @param {string} colId - the column id\n * @param {Object} options - the description of the card\n * @param {Requestable.callback} cb - will receive the newly created card\n * @return {Promise} - the promise for the http request\n */\n createProjectCard(colId, options, cb) {\n return this._request('POST', `/projects/columns/${colId}/cards`, options, cb);\n }\n\n /**\n * Edit a card\n * @see https://developer.github.com/v3/projects/cards/#update-a-project-card\n * @param {string} cardId - the card id\n * @param {Object} options - the description of the card\n * @param {Requestable.callback} cb - will receive the modified card\n * @return {Promise} - the promise for the http request\n */\n updateProjectCard(cardId, options, cb) {\n return this._request('PATCH', `/projects/columns/cards/${cardId}`, options, cb);\n }\n\n /**\n * Delete a card\n * @see https://developer.github.com/v3/projects/cards/#delete-a-project-card\n * @param {string} cardId - the card to be deleted\n * @param {Requestable.callback} cb - will receive true if the operation is successful\n * @return {Promise} - the promise for the http request\n */\n deleteProjectCard(cardId, cb) {\n return this._request('DELETE', `/projects/columns/cards/${cardId}`, null, cb);\n }\n\n /**\n * Move a card\n * @see https://developer.github.com/v3/projects/cards/#move-a-project-card\n * @param {string} cardId - the card to be moved\n * @param {string} position - can be one of top, bottom, or after:,\n * where is the id value of a card in the same project.\n * @param {string} colId - the id value of a column in the same project.\n * @param {Requestable.callback} cb - will receive true if the operation is successful\n * @return {Promise} - the promise for the http request\n */\n moveProjectCard(cardId, position, colId, cb) {\n return this._request(\n 'POST',\n `/projects/columns/cards/${cardId}/moves`,\n {position: position, column_id: colId}, // eslint-disable-line camelcase\n cb\n );\n }\n}\n\nmodule.exports = Project;\n","/**\n * @file\n * @copyright 2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n * Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\n\n/**\n * RateLimit allows users to query their rate-limit status\n */\nclass RateLimit extends Requestable {\n /**\n * construct a RateLimit\n * @param {Requestable.auth} auth - the credentials to authenticate to GitHub\n * @param {string} [apiBase] - the base Github API URL\n * @return {Promise} - the promise for the http request\n */\n constructor(auth, apiBase) {\n super(auth, apiBase);\n }\n\n /**\n * Query the current rate limit\n * @see https://developer.github.com/v3/rate_limit/\n * @param {Requestable.callback} [cb] - will receive the rate-limit data\n * @return {Promise} - the promise for the http request\n */\n getRateLimit(cb) {\n return this._request('GET', '/rate_limit', null, cb);\n }\n}\n\nmodule.exports = RateLimit;\n","/**\n * @file\n * @copyright 2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n * Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\nimport Utf8 from 'utf8';\nimport {\n Base64,\n} from 'js-base64';\nimport debug from 'debug';\nconst log = debug('github:repository');\n\n/**\n * Respository encapsulates the functionality to create, query, and modify files.\n */\nclass Repository extends Requestable {\n /**\n * Create a Repository.\n * @param {string} fullname - the full name of the repository\n * @param {Requestable.auth} [auth] - information required to authenticate to Github\n * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n */\n constructor(fullname, auth, apiBase) {\n super(auth, apiBase);\n this.__fullname = fullname;\n this.__currentTree = {\n branch: null,\n sha: null,\n };\n }\n\n /**\n * Get a reference\n * @see https://developer.github.com/v3/git/refs/#get-a-reference\n * @param {string} ref - the reference to get\n * @param {Requestable.callback} [cb] - will receive the reference's refSpec or a list of refSpecs that match `ref`\n * @return {Promise} - the promise for the http request\n */\n getRef(ref, cb) {\n return this._request('GET', `/repos/${this.__fullname}/git/refs/${ref}`, null, cb);\n }\n\n /**\n * Create a reference\n * @see https://developer.github.com/v3/git/refs/#create-a-reference\n * @param {Object} options - the object describing the ref\n * @param {Requestable.callback} [cb] - will receive the ref\n * @return {Promise} - the promise for the http request\n */\n createRef(options, cb) {\n return this._request('POST', `/repos/${this.__fullname}/git/refs`, options, cb);\n }\n\n /**\n * Delete a reference\n * @see https://developer.github.com/v3/git/refs/#delete-a-reference\n * @param {string} ref - the name of the ref to delte\n * @param {Requestable.callback} [cb] - will receive true if the request is successful\n * @return {Promise} - the promise for the http request\n */\n deleteRef(ref, cb) {\n return this._request('DELETE', `/repos/${this.__fullname}/git/refs/${ref}`, null, cb);\n }\n\n /**\n * Delete a repository\n * @see https://developer.github.com/v3/repos/#delete-a-repository\n * @param {Requestable.callback} [cb] - will receive true if the request is successful\n * @return {Promise} - the promise for the http request\n */\n deleteRepo(cb) {\n return this._request('DELETE', `/repos/${this.__fullname}`, null, cb);\n }\n\n /**\n * List the tags on a repository\n * @see https://developer.github.com/v3/repos/#list-tags\n * @param {Requestable.callback} [cb] - will receive the tag data\n * @return {Promise} - the promise for the http request\n */\n listTags(cb) {\n return this._request('GET', `/repos/${this.__fullname}/tags`, null, cb);\n }\n\n /**\n * List the open pull requests on the repository\n * @see https://developer.github.com/v3/pulls/#list-pull-requests\n * @param {Object} options - options to filter the search\n * @param {Requestable.callback} [cb] - will receive the list of PRs\n * @return {Promise} - the promise for the http request\n */\n listPullRequests(options, cb) {\n options = options || {};\n return this._request('GET', `/repos/${this.__fullname}/pulls`, options, cb);\n }\n\n /**\n * Get information about a specific pull request\n * @see https://developer.github.com/v3/pulls/#get-a-single-pull-request\n * @param {number} number - the PR you wish to fetch\n * @param {Requestable.callback} [cb] - will receive the PR from the API\n * @return {Promise} - the promise for the http request\n */\n getPullRequest(number, cb) {\n return this._request('GET', `/repos/${this.__fullname}/pulls/${number}`, null, cb);\n }\n\n /**\n * List the files of a specific pull request\n * @see https://developer.github.com/v3/pulls/#list-pull-requests-files\n * @param {number|string} number - the PR you wish to fetch\n * @param {Requestable.callback} [cb] - will receive the list of files from the API\n * @return {Promise} - the promise for the http request\n */\n listPullRequestFiles(number, cb) {\n return this._request('GET', `/repos/${this.__fullname}/pulls/${number}/files`, null, cb);\n }\n\n /**\n * Compare two branches/commits/repositories\n * @see https://developer.github.com/v3/repos/commits/#compare-two-commits\n * @param {string} base - the base commit\n * @param {string} head - the head commit\n * @param {Requestable.callback} cb - will receive the comparison\n * @return {Promise} - the promise for the http request\n */\n compareBranches(base, head, cb) {\n return this._request('GET', `/repos/${this.__fullname}/compare/${base}...${head}`, null, cb);\n }\n\n /**\n * List all the branches for the repository\n * @see https://developer.github.com/v3/repos/#list-branches\n * @param {Requestable.callback} cb - will receive the list of branches\n * @return {Promise} - the promise for the http request\n */\n listBranches(cb) {\n return this._request('GET', `/repos/${this.__fullname}/branches`, null, cb);\n }\n\n /**\n * Get a raw blob from the repository\n * @see https://developer.github.com/v3/git/blobs/#get-a-blob\n * @param {string} sha - the sha of the blob to fetch\n * @param {Requestable.callback} cb - will receive the blob from the API\n * @return {Promise} - the promise for the http request\n */\n getBlob(sha, cb) {\n return this._request('GET', `/repos/${this.__fullname}/git/blobs/${sha}`, null, cb, 'raw');\n }\n\n /**\n * Get a single branch\n * @see https://developer.github.com/v3/repos/branches/#get-branch\n * @param {string} branch - the name of the branch to fetch\n * @param {Requestable.callback} cb - will receive the branch from the API\n * @returns {Promise} - the promise for the http request\n */\n getBranch(branch, cb) {\n return this._request('GET', `/repos/${this.__fullname}/branches/${branch}`, null, cb);\n }\n\n /**\n * Get a commit from the repository\n * @see https://developer.github.com/v3/repos/commits/#get-a-single-commit\n * @param {string} sha - the sha for the commit to fetch\n * @param {Requestable.callback} cb - will receive the commit data\n * @return {Promise} - the promise for the http request\n */\n getCommit(sha, cb) {\n return this._request('GET', `/repos/${this.__fullname}/git/commits/${sha}`, null, cb);\n }\n\n /**\n * List the commits on a repository, optionally filtering by path, author or time range\n * @see https://developer.github.com/v3/repos/commits/#list-commits-on-a-repository\n * @param {Object} [options] - the filtering options for commits\n * @param {string} [options.sha] - the SHA or branch to start from\n * @param {string} [options.path] - the path to search on\n * @param {string} [options.author] - the commit author\n * @param {(Date|string)} [options.since] - only commits after this date will be returned\n * @param {(Date|string)} [options.until] - only commits before this date will be returned\n * @param {Requestable.callback} cb - will receive the list of commits found matching the criteria\n * @return {Promise} - the promise for the http request\n */\n listCommits(options, cb) {\n options = options || {};\n\n options.since = this._dateToISO(options.since);\n options.until = this._dateToISO(options.until);\n\n return this._request('GET', `/repos/${this.__fullname}/commits`, options, cb);\n }\n\n /**\n * Gets a single commit information for a repository\n * @see https://developer.github.com/v3/repos/commits/#get-a-single-commit\n * @param {string} ref - the reference for the commit-ish\n * @param {Requestable.callback} cb - will receive the commit information\n * @return {Promise} - the promise for the http request\n */\n getSingleCommit(ref, cb) {\n ref = ref || '';\n return this._request('GET', `/repos/${this.__fullname}/commits/${ref}`, null, cb);\n }\n\n /**\n * Get tha sha for a particular object in the repository. This is a convenience function\n * @see https://developer.github.com/v3/repos/contents/#get-contents\n * @param {string} [branch] - the branch to look in, or the repository's default branch if omitted\n * @param {string} path - the path of the file or directory\n * @param {Requestable.callback} cb - will receive a description of the requested object, including a `SHA` property\n * @return {Promise} - the promise for the http request\n */\n getSha(branch, path, cb) {\n branch = branch ? `?ref=${branch}` : '';\n return this._request('GET', `/repos/${this.__fullname}/contents/${path}${branch}`, null, cb);\n }\n\n /**\n * List the commit statuses for a particular sha, branch, or tag\n * @see https://developer.github.com/v3/repos/statuses/#list-statuses-for-a-specific-ref\n * @param {string} sha - the sha, branch, or tag to get statuses for\n * @param {Requestable.callback} cb - will receive the list of statuses\n * @return {Promise} - the promise for the http request\n */\n listStatuses(sha, cb) {\n return this._request('GET', `/repos/${this.__fullname}/commits/${sha}/statuses`, null, cb);\n }\n\n /**\n * Get a description of a git tree\n * @see https://developer.github.com/v3/git/trees/#get-a-tree\n * @param {string} treeSHA - the SHA of the tree to fetch\n * @param {Requestable.callback} cb - will receive the callback data\n * @return {Promise} - the promise for the http request\n */\n getTree(treeSHA, cb) {\n return this._request('GET', `/repos/${this.__fullname}/git/trees/${treeSHA}`, null, cb);\n }\n\n /**\n * Create a blob\n * @see https://developer.github.com/v3/git/blobs/#create-a-blob\n * @param {(string|Buffer|Blob)} content - the content to add to the repository\n * @param {Requestable.callback} cb - will receive the details of the created blob\n * @return {Promise} - the promise for the http request\n */\n createBlob(content, cb) {\n let postBody = this._getContentObject(content);\n\n log('sending content', postBody);\n return this._request('POST', `/repos/${this.__fullname}/git/blobs`, postBody, cb);\n }\n\n /**\n * Get the object that represents the provided content\n * @param {string|Buffer|Blob} content - the content to send to the server\n * @return {Object} the representation of `content` for the GitHub API\n */\n _getContentObject(content) {\n if (typeof content === 'string') {\n log('contet is a string');\n return {\n content: Utf8.encode(content),\n encoding: 'utf-8',\n };\n\n } else if (typeof Buffer !== 'undefined' && content instanceof Buffer) {\n log('We appear to be in Node');\n return {\n content: content.toString('base64'),\n encoding: 'base64',\n };\n\n } else if (typeof Blob !== 'undefined' && content instanceof Blob) {\n log('We appear to be in the browser');\n return {\n content: Base64.encode(content),\n encoding: 'base64',\n };\n\n } else { // eslint-disable-line\n log(`Not sure what this content is: ${typeof content}, ${JSON.stringify(content)}`);\n throw new Error('Unknown content passed to postBlob. Must be string or Buffer (node) or Blob (web)');\n }\n }\n\n /**\n * Update a tree in Git\n * @see https://developer.github.com/v3/git/trees/#create-a-tree\n * @param {string} baseTreeSHA - the SHA of the tree to update\n * @param {string} path - the path for the new file\n * @param {string} blobSHA - the SHA for the blob to put at `path`\n * @param {Requestable.callback} cb - will receive the new tree that is created\n * @return {Promise} - the promise for the http request\n * @deprecated use {@link Repository#createTree} instead\n */\n updateTree(baseTreeSHA, path, blobSHA, cb) {\n let newTree = {\n base_tree: baseTreeSHA, // eslint-disable-line\n tree: [{\n path: path,\n sha: blobSHA,\n mode: '100644',\n type: 'blob',\n }],\n };\n\n return this._request('POST', `/repos/${this.__fullname}/git/trees`, newTree, cb);\n }\n\n /**\n * Create a new tree in git\n * @see https://developer.github.com/v3/git/trees/#create-a-tree\n * @param {Object} tree - the tree to create\n * @param {string} baseSHA - the root sha of the tree\n * @param {Requestable.callback} cb - will receive the new tree that is created\n * @return {Promise} - the promise for the http request\n */\n createTree(tree, baseSHA, cb) {\n return this._request('POST', `/repos/${this.__fullname}/git/trees`, {\n tree,\n base_tree: baseSHA, // eslint-disable-line camelcase\n }, cb);\n }\n\n /**\n * Add a commit to the repository\n * @see https://developer.github.com/v3/git/commits/#create-a-commit\n * @param {string} parent - the SHA of the parent commit\n * @param {string} tree - the SHA of the tree for this commit\n * @param {string} message - the commit message\n * @param {Requestable.callback} cb - will receive the commit that is created\n * @return {Promise} - the promise for the http request\n */\n commit(parent, tree, message, cb) {\n let data = {\n message,\n tree,\n parents: [parent],\n };\n\n return this._request('POST', `/repos/${this.__fullname}/git/commits`, data, cb)\n .then((response) => {\n this.__currentTree.sha = response.data.sha; // Update latest commit\n return response;\n });\n }\n\n /**\n * Update a ref\n * @see https://developer.github.com/v3/git/refs/#update-a-reference\n * @param {string} ref - the ref to update\n * @param {string} commitSHA - the SHA to point the reference to\n * @param {boolean} force - indicates whether to force or ensure a fast-forward update\n * @param {Requestable.callback} cb - will receive the updated ref back\n * @return {Promise} - the promise for the http request\n */\n updateHead(ref, commitSHA, force, cb) {\n return this._request('PATCH', `/repos/${this.__fullname}/git/refs/${ref}`, {\n sha: commitSHA,\n force: force,\n }, cb);\n }\n\n /**\n * Update commit status\n * @see https://developer.github.com/v3/repos/statuses/\n * @param {string} commitSHA - the SHA of the commit that should be updated\n * @param {object} options - Commit status parameters\n * @param {string} options.state - The state of the status. Can be one of: pending, success, error, or failure.\n * @param {string} [options.target_url] - The target URL to associate with this status.\n * @param {string} [options.description] - A short description of the status.\n * @param {string} [options.context] - A string label to differentiate this status among CI systems.\n * @param {Requestable.callback} cb - will receive the updated commit back\n * @return {Promise} - the promise for the http request\n */\n updateStatus(commitSHA, options, cb) {\n return this._request('POST', `/repos/${this.__fullname}/statuses/${commitSHA}`, options, cb);\n }\n\n /**\n * Update repository information\n * @see https://developer.github.com/v3/repos/#edit\n * @param {object} options - New parameters that will be set to the repository\n * @param {string} options.name - Name of the repository\n * @param {string} [options.description] - A short description of the repository\n * @param {string} [options.homepage] - A URL with more information about the repository\n * @param {boolean} [options.private] - Either true to make the repository private, or false to make it public.\n * @param {boolean} [options.has_issues] - Either true to enable issues for this repository, false to disable them.\n * @param {boolean} [options.has_wiki] - Either true to enable the wiki for this repository, false to disable it.\n * @param {boolean} [options.has_downloads] - Either true to enable downloads, false to disable them.\n * @param {string} [options.default_branch] - Updates the default branch for this repository.\n * @param {Requestable.callback} cb - will receive the updated repository back\n * @return {Promise} - the promise for the http request\n */\n updateRepository(options, cb) {\n return this._request('PATCH', `/repos/${this.__fullname}`, options, cb);\n }\n\n /**\n * Get information about the repository\n * @see https://developer.github.com/v3/repos/#get\n * @param {Requestable.callback} cb - will receive the information about the repository\n * @return {Promise} - the promise for the http request\n */\n getDetails(cb) {\n return this._request('GET', `/repos/${this.__fullname}`, null, cb);\n }\n\n /**\n * List the contributors to the repository\n * @see https://developer.github.com/v3/repos/#list-contributors\n * @param {Requestable.callback} cb - will receive the list of contributors\n * @return {Promise} - the promise for the http request\n */\n getContributors(cb) {\n return this._request('GET', `/repos/${this.__fullname}/contributors`, null, cb);\n }\n\n /**\n * List the contributor stats to the repository\n * @see https://developer.github.com/v3/repos/#list-contributors\n * @param {Requestable.callback} cb - will receive the list of contributors\n * @return {Promise} - the promise for the http request\n */\n getContributorStats(cb) {\n return this._request('GET', `/repos/${this.__fullname}/stats/contributors`, null, cb);\n }\n\n /**\n * List the users who are collaborators on the repository. The currently authenticated user must have\n * push access to use this method\n * @see https://developer.github.com/v3/repos/collaborators/#list-collaborators\n * @param {Requestable.callback} cb - will receive the list of collaborators\n * @return {Promise} - the promise for the http request\n */\n getCollaborators(cb) {\n return this._request('GET', `/repos/${this.__fullname}/collaborators`, null, cb);\n }\n\n /**\n * Check if a user is a collaborator on the repository\n * @see https://developer.github.com/v3/repos/collaborators/#check-if-a-user-is-a-collaborator\n * @param {string} username - the user to check\n * @param {Requestable.callback} cb - will receive true if the user is a collaborator and false if they are not\n * @return {Promise} - the promise for the http request {Boolean} [description]\n */\n isCollaborator(username, cb) {\n return this._request('GET', `/repos/${this.__fullname}/collaborators/${username}`, null, cb);\n }\n\n /**\n * Get the contents of a repository\n * @see https://developer.github.com/v3/repos/contents/#get-contents\n * @param {string} ref - the ref to check\n * @param {string} path - the path containing the content to fetch\n * @param {boolean} raw - `true` if the results should be returned raw instead of GitHub's normalized format\n * @param {Requestable.callback} cb - will receive the fetched data\n * @return {Promise} - the promise for the http request\n */\n getContents(ref, path, raw, cb) {\n path = path ? `${encodeURI(path)}` : '';\n return this._request('GET', `/repos/${this.__fullname}/contents/${path}`, {\n ref,\n }, cb, raw);\n }\n\n /**\n * Get the README of a repository\n * @see https://developer.github.com/v3/repos/contents/#get-the-readme\n * @param {string} ref - the ref to check\n * @param {boolean} raw - `true` if the results should be returned raw instead of GitHub's normalized format\n * @param {Requestable.callback} cb - will receive the fetched data\n * @return {Promise} - the promise for the http request\n */\n getReadme(ref, raw, cb) {\n return this._request('GET', `/repos/${this.__fullname}/readme`, {\n ref,\n }, cb, raw);\n }\n\n /**\n * Fork a repository\n * @see https://developer.github.com/v3/repos/forks/#create-a-fork\n * @param {Requestable.callback} cb - will receive the information about the newly created fork\n * @return {Promise} - the promise for the http request\n */\n fork(cb) {\n return this._request('POST', `/repos/${this.__fullname}/forks`, null, cb);\n }\n\n /**\n * List a repository's forks\n * @see https://developer.github.com/v3/repos/forks/#list-forks\n * @param {Requestable.callback} cb - will receive the list of repositories forked from this one\n * @return {Promise} - the promise for the http request\n */\n listForks(cb) {\n return this._request('GET', `/repos/${this.__fullname}/forks`, null, cb);\n }\n\n /**\n * Create a new branch from an existing branch.\n * @param {string} [oldBranch=master] - the name of the existing branch\n * @param {string} newBranch - the name of the new branch\n * @param {Requestable.callback} cb - will receive the commit data for the head of the new branch\n * @return {Promise} - the promise for the http request\n */\n createBranch(oldBranch, newBranch, cb) {\n if (typeof newBranch === 'function') {\n cb = newBranch;\n newBranch = oldBranch;\n oldBranch = 'master';\n }\n\n return this.getRef(`heads/${oldBranch}`)\n .then((response) => {\n let sha = response.data.object.sha;\n return this.createRef({\n sha,\n ref: `refs/heads/${newBranch}`,\n }, cb);\n });\n }\n\n /**\n * Create a new pull request\n * @see https://developer.github.com/v3/pulls/#create-a-pull-request\n * @param {Object} options - the pull request description\n * @param {Requestable.callback} cb - will receive the new pull request\n * @return {Promise} - the promise for the http request\n */\n createPullRequest(options, cb) {\n return this._request('POST', `/repos/${this.__fullname}/pulls`, options, cb);\n }\n\n /**\n * Update a pull request\n * @see https://developer.github.com/v3/pulls/#update-a-pull-request\n * @param {number|string} number - the number of the pull request to update\n * @param {Object} options - the pull request description\n * @param {Requestable.callback} [cb] - will receive the pull request information\n * @return {Promise} - the promise for the http request\n */\n updatePullRequest(number, options, cb) {\n return this._request('PATCH', `/repos/${this.__fullname}/pulls/${number}`, options, cb);\n }\n\n /**\n * List the hooks for the repository\n * @see https://developer.github.com/v3/repos/hooks/#list-hooks\n * @param {Requestable.callback} cb - will receive the list of hooks\n * @return {Promise} - the promise for the http request\n */\n listHooks(cb) {\n return this._request('GET', `/repos/${this.__fullname}/hooks`, null, cb);\n }\n\n /**\n * Get a hook for the repository\n * @see https://developer.github.com/v3/repos/hooks/#get-single-hook\n * @param {number} id - the id of the webook\n * @param {Requestable.callback} cb - will receive the details of the webook\n * @return {Promise} - the promise for the http request\n */\n getHook(id, cb) {\n return this._request('GET', `/repos/${this.__fullname}/hooks/${id}`, null, cb);\n }\n\n /**\n * Add a new hook to the repository\n * @see https://developer.github.com/v3/repos/hooks/#create-a-hook\n * @param {Object} options - the configuration describing the new hook\n * @param {Requestable.callback} cb - will receive the new webhook\n * @return {Promise} - the promise for the http request\n */\n createHook(options, cb) {\n return this._request('POST', `/repos/${this.__fullname}/hooks`, options, cb);\n }\n\n /**\n * Edit an existing webhook\n * @see https://developer.github.com/v3/repos/hooks/#edit-a-hook\n * @param {number} id - the id of the webhook\n * @param {Object} options - the new description of the webhook\n * @param {Requestable.callback} cb - will receive the updated webhook\n * @return {Promise} - the promise for the http request\n */\n updateHook(id, options, cb) {\n return this._request('PATCH', `/repos/${this.__fullname}/hooks/${id}`, options, cb);\n }\n\n /**\n * Delete a webhook\n * @see https://developer.github.com/v3/repos/hooks/#delete-a-hook\n * @param {number} id - the id of the webhook to be deleted\n * @param {Requestable.callback} cb - will receive true if the call is successful\n * @return {Promise} - the promise for the http request\n */\n deleteHook(id, cb) {\n return this._request('DELETE', `/repos/${this.__fullname}/hooks/${id}`, null, cb);\n }\n\n /**\n * List the deploy keys for the repository\n * @see https://developer.github.com/v3/repos/keys/#list-deploy-keys\n * @param {Requestable.callback} cb - will receive the list of deploy keys\n * @return {Promise} - the promise for the http request\n */\n listKeys(cb) {\n return this._request('GET', `/repos/${this.__fullname}/keys`, null, cb);\n }\n\n /**\n * Get a deploy key for the repository\n * @see https://developer.github.com/v3/repos/keys/#get-a-deploy-key\n * @param {number} id - the id of the deploy key\n * @param {Requestable.callback} cb - will receive the details of the deploy key\n * @return {Promise} - the promise for the http request\n */\n getKey(id, cb) {\n return this._request('GET', `/repos/${this.__fullname}/keys/${id}`, null, cb);\n }\n\n /**\n * Add a new deploy key to the repository\n * @see https://developer.github.com/v3/repos/keys/#add-a-new-deploy-key\n * @param {Object} options - the configuration describing the new deploy key\n * @param {Requestable.callback} cb - will receive the new deploy key\n * @return {Promise} - the promise for the http request\n */\n createKey(options, cb) {\n return this._request('POST', `/repos/${this.__fullname}/keys`, options, cb);\n }\n\n /**\n * Delete a deploy key\n * @see https://developer.github.com/v3/repos/keys/#remove-a-deploy-key\n * @param {number} id - the id of the deploy key to be deleted\n * @param {Requestable.callback} cb - will receive true if the call is successful\n * @return {Promise} - the promise for the http request\n */\n deleteKey(id, cb) {\n return this._request('DELETE', `/repos/${this.__fullname}/keys/${id}`, null, cb);\n }\n\n /**\n * Delete a file from a branch\n * @see https://developer.github.com/v3/repos/contents/#delete-a-file\n * @param {string} branch - the branch to delete from, or the default branch if not specified\n * @param {string} path - the path of the file to remove\n * @param {Requestable.callback} cb - will receive the commit in which the delete occurred\n * @return {Promise} - the promise for the http request\n */\n deleteFile(branch, path, cb) {\n return this.getSha(branch, path)\n .then((response) => {\n const deleteCommit = {\n message: `Delete the file at '${path}'`,\n sha: response.data.sha,\n branch,\n };\n return this._request('DELETE', `/repos/${this.__fullname}/contents/${path}`, deleteCommit, cb);\n });\n }\n\n /**\n * Change all references in a repo from oldPath to new_path\n * @param {string} branch - the branch to carry out the reference change, or the default branch if not specified\n * @param {string} oldPath - original path\n * @param {string} newPath - new reference path\n * @param {Requestable.callback} cb - will receive the commit in which the move occurred\n * @return {Promise} - the promise for the http request\n */\n move(branch, oldPath, newPath, cb) {\n let oldSha;\n return this.getRef(`heads/${branch}`)\n .then(({data: {object}}) => this.getTree(`${object.sha}?recursive=true`))\n .then(({data: {tree, sha}}) => {\n oldSha = sha;\n let newTree = tree.map((ref) => {\n if (ref.path === oldPath) {\n ref.path = newPath;\n }\n if (ref.type === 'tree') {\n delete ref.sha;\n }\n return ref;\n });\n return this.createTree(newTree);\n })\n .then(({data: tree}) => this.commit(oldSha, tree.sha, `Renamed '${oldPath}' to '${newPath}'`))\n .then(({data: commit}) => this.updateHead(`heads/${branch}`, commit.sha, true, cb));\n }\n\n /**\n * Write a file to the repository\n * @see https://developer.github.com/v3/repos/contents/#update-a-file\n * @param {string} branch - the name of the branch\n * @param {string} path - the path for the file\n * @param {string} content - the contents of the file\n * @param {string} message - the commit message\n * @param {Object} [options] - commit options\n * @param {Object} [options.author] - the author of the commit\n * @param {Object} [options.commiter] - the committer\n * @param {boolean} [options.encode] - true if the content should be base64 encoded\n * @param {Requestable.callback} cb - will receive the new commit\n * @return {Promise} - the promise for the http request\n */\n writeFile(branch, path, content, message, options, cb) {\n if (typeof options === 'function') {\n cb = options;\n options = {};\n }\n let filePath = path ? encodeURI(path) : '';\n let shouldEncode = options.encode !== false;\n let commit = {\n branch,\n message,\n author: options.author,\n committer: options.committer,\n content: shouldEncode ? Base64.encode(content) : content,\n };\n\n return this.getSha(branch, filePath)\n .then((response) => {\n commit.sha = response.data.sha;\n return this._request('PUT', `/repos/${this.__fullname}/contents/${filePath}`, commit, cb);\n }, () => {\n return this._request('PUT', `/repos/${this.__fullname}/contents/${filePath}`, commit, cb);\n });\n }\n\n /**\n * Check if a repository is starred by you\n * @see https://developer.github.com/v3/activity/starring/#check-if-you-are-starring-a-repository\n * @param {Requestable.callback} cb - will receive true if the repository is starred and false if the repository\n * is not starred\n * @return {Promise} - the promise for the http request {Boolean} [description]\n */\n isStarred(cb) {\n return this._request204or404(`/user/starred/${this.__fullname}`, null, cb);\n }\n\n /**\n * Star a repository\n * @see https://developer.github.com/v3/activity/starring/#star-a-repository\n * @param {Requestable.callback} cb - will receive true if the repository is starred\n * @return {Promise} - the promise for the http request\n */\n star(cb) {\n return this._request('PUT', `/user/starred/${this.__fullname}`, null, cb);\n }\n\n /**\n * Unstar a repository\n * @see https://developer.github.com/v3/activity/starring/#unstar-a-repository\n * @param {Requestable.callback} cb - will receive true if the repository is unstarred\n * @return {Promise} - the promise for the http request\n */\n unstar(cb) {\n return this._request('DELETE', `/user/starred/${this.__fullname}`, null, cb);\n }\n\n /**\n * Create a new release\n * @see https://developer.github.com/v3/repos/releases/#create-a-release\n * @param {Object} options - the description of the release\n * @param {Requestable.callback} cb - will receive the newly created release\n * @return {Promise} - the promise for the http request\n */\n createRelease(options, cb) {\n return this._request('POST', `/repos/${this.__fullname}/releases`, options, cb);\n }\n\n /**\n * Edit a release\n * @see https://developer.github.com/v3/repos/releases/#edit-a-release\n * @param {string} id - the id of the release\n * @param {Object} options - the description of the release\n * @param {Requestable.callback} cb - will receive the modified release\n * @return {Promise} - the promise for the http request\n */\n updateRelease(id, options, cb) {\n return this._request('PATCH', `/repos/${this.__fullname}/releases/${id}`, options, cb);\n }\n\n /**\n * Get information about all releases\n * @see https://developer.github.com/v3/repos/releases/#list-releases-for-a-repository\n * @param {Requestable.callback} cb - will receive the release information\n * @return {Promise} - the promise for the http request\n */\n listReleases(cb) {\n return this._request('GET', `/repos/${this.__fullname}/releases`, null, cb);\n }\n\n /**\n * Get information about a release\n * @see https://developer.github.com/v3/repos/releases/#get-a-single-release\n * @param {string} id - the id of the release\n * @param {Requestable.callback} cb - will receive the release information\n * @return {Promise} - the promise for the http request\n */\n getRelease(id, cb) {\n return this._request('GET', `/repos/${this.__fullname}/releases/${id}`, null, cb);\n }\n\n /**\n * Delete a release\n * @see https://developer.github.com/v3/repos/releases/#delete-a-release\n * @param {string} id - the release to be deleted\n * @param {Requestable.callback} cb - will receive true if the operation is successful\n * @return {Promise} - the promise for the http request\n */\n deleteRelease(id, cb) {\n return this._request('DELETE', `/repos/${this.__fullname}/releases/${id}`, null, cb);\n }\n\n /**\n * Merge a pull request\n * @see https://developer.github.com/v3/pulls/#merge-a-pull-request-merge-button\n * @param {number|string} number - the number of the pull request to merge\n * @param {Object} options - the merge options for the pull request\n * @param {Requestable.callback} [cb] - will receive the merge information if the operation is successful\n * @return {Promise} - the promise for the http request\n */\n mergePullRequest(number, options, cb) {\n return this._request('PUT', `/repos/${this.__fullname}/pulls/${number}/merge`, options, cb);\n }\n\n /**\n * Get information about all projects\n * @see https://developer.github.com/v3/projects/#list-repository-projects\n * @param {Requestable.callback} [cb] - will receive the list of projects\n * @return {Promise} - the promise for the http request\n */\n listProjects(cb) {\n return this._requestAllPages(`/repos/${this.__fullname}/projects`, {AcceptHeader: 'inertia-preview'}, cb);\n }\n\n /**\n * Create a new project\n * @see https://developer.github.com/v3/projects/#create-a-repository-project\n * @param {Object} options - the description of the project\n * @param {Requestable.callback} cb - will receive the newly created project\n * @return {Promise} - the promise for the http request\n */\n createProject(options, cb) {\n options = options || {};\n options.AcceptHeader = 'inertia-preview';\n return this._request('POST', `/repos/${this.__fullname}/projects`, options, cb);\n }\n\n}\n\nmodule.exports = Repository;\n","/**\n * @file\n * @copyright 2016 Yahoo Inc.\n * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n * Github.js is freely distributable.\n */\n\nimport axios from 'axios';\nimport debug from 'debug';\nimport {Base64} from 'js-base64';\n\nconst log = debug('github:request');\n\n/**\n * The error structure returned when a network call fails\n */\nclass ResponseError extends Error {\n /**\n * Construct a new ResponseError\n * @param {string} message - an message to return instead of the the default error message\n * @param {string} path - the requested path\n * @param {Object} response - the object returned by Axios\n */\n constructor(message, path, response) {\n super(message);\n this.path = path;\n this.request = response.config;\n this.response = (response || {}).response || response;\n this.status = response.status;\n }\n}\n\n/**\n * Requestable wraps the logic for making http requests to the API\n */\nclass Requestable {\n /**\n * Either a username and password or an oauth token for Github\n * @typedef {Object} Requestable.auth\n * @prop {string} [username] - the Github username\n * @prop {string} [password] - the user's password\n * @prop {token} [token] - an OAuth token\n */\n /**\n * Initialize the http internals.\n * @param {Requestable.auth} [auth] - the credentials to authenticate to Github. If auth is\n * not provided request will be made unauthenticated\n * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n * @param {string} [AcceptHeader=v3] - the accept header for the requests\n */\n constructor(auth, apiBase, AcceptHeader) {\n this.__apiBase = apiBase || 'https://api.github.com';\n this.__auth = {\n token: auth.token,\n username: auth.username,\n password: auth.password,\n };\n this.__AcceptHeader = AcceptHeader || 'v3';\n\n if (auth.token) {\n this.__authorizationHeader = 'token ' + auth.token;\n } else if (auth.username && auth.password) {\n this.__authorizationHeader = 'Basic ' + Base64.encode(auth.username + ':' + auth.password);\n }\n }\n\n /**\n * Compute the URL to use to make a request.\n * @private\n * @param {string} path - either a URL relative to the API base or an absolute URL\n * @return {string} - the URL to use\n */\n __getURL(path) {\n let url = path;\n\n if (path.indexOf('//') === -1) {\n url = this.__apiBase + path;\n }\n\n let newCacheBuster = 'timestamp=' + new Date().getTime();\n return url.replace(/(timestamp=\\d+)/, newCacheBuster);\n }\n\n /**\n * Compute the headers required for an API request.\n * @private\n * @param {boolean} raw - if the request should be treated as JSON or as a raw request\n * @param {string} AcceptHeader - the accept header for the request\n * @return {Object} - the headers to use in the request\n */\n __getRequestHeaders(raw, AcceptHeader) {\n let headers = {\n 'Content-Type': 'application/json;charset=UTF-8',\n 'Accept': 'application/vnd.github.' + (AcceptHeader || this.__AcceptHeader),\n };\n\n if (raw) {\n headers.Accept += '.raw';\n }\n headers.Accept += '+json';\n\n if (this.__authorizationHeader) {\n headers.Authorization = this.__authorizationHeader;\n }\n\n return headers;\n }\n\n /**\n * Sets the default options for API requests\n * @protected\n * @param {Object} [requestOptions={}] - the current options for the request\n * @return {Object} - the options to pass to the request\n */\n _getOptionsWithDefaults(requestOptions = {}) {\n if (!(requestOptions.visibility || requestOptions.affiliation)) {\n requestOptions.type = requestOptions.type || 'all';\n }\n requestOptions.sort = requestOptions.sort || 'updated';\n requestOptions.per_page = requestOptions.per_page || '100'; // eslint-disable-line\n\n return requestOptions;\n }\n\n /**\n * if a `Date` is passed to this function it will be converted to an ISO string\n * @param {*} date - the object to attempt to cooerce into an ISO date string\n * @return {string} - the ISO representation of `date` or whatever was passed in if it was not a date\n */\n _dateToISO(date) {\n if (date && (date instanceof Date)) {\n date = date.toISOString();\n }\n\n return date;\n }\n\n /**\n * A function that receives the result of the API request.\n * @callback Requestable.callback\n * @param {Requestable.Error} error - the error returned by the API or `null`\n * @param {(Object|true)} result - the data returned by the API or `true` if the API returns `204 No Content`\n * @param {Object} request - the raw {@linkcode https://github.com/mzabriskie/axios#response-schema Response}\n */\n /**\n * Make a request.\n * @param {string} method - the method for the request (GET, PUT, POST, DELETE)\n * @param {string} path - the path for the request\n * @param {*} [data] - the data to send to the server. For HTTP methods that don't have a body the data\n * will be sent as query parameters\n * @param {Requestable.callback} [cb] - the callback for the request\n * @param {boolean} [raw=false] - if the request should be sent as raw. If this is a falsy value then the\n * request will be made as JSON\n * @return {Promise} - the Promise for the http request\n */\n _request(method, path, data, cb, raw) {\n const url = this.__getURL(path);\n\n const AcceptHeader = (data || {}).AcceptHeader;\n if (AcceptHeader) {\n delete data.AcceptHeader;\n }\n const headers = this.__getRequestHeaders(raw, AcceptHeader);\n\n let queryParams = {};\n\n const shouldUseDataAsParams = data && (typeof data === 'object') && methodHasNoBody(method);\n if (shouldUseDataAsParams) {\n queryParams = data;\n data = undefined;\n }\n\n const config = {\n url: url,\n method: method,\n headers: headers,\n params: queryParams,\n data: data,\n responseType: raw ? 'text' : 'json',\n };\n\n log(`${config.method} to ${config.url}`);\n const requestPromise = axios(config).catch(callbackErrorOrThrow(cb, path));\n\n if (cb) {\n requestPromise.then((response) => {\n if (response.data && Object.keys(response.data).length > 0) {\n // When data has results\n cb(null, response.data, response);\n } else if (config.method !== 'GET' && Object.keys(response.data).length < 1) {\n // True when successful submit a request and receive a empty object\n cb(null, (response.status < 300), response);\n } else {\n cb(null, response.data, response);\n }\n });\n }\n\n return requestPromise;\n }\n\n /**\n * Make a request to an endpoint the returns 204 when true and 404 when false\n * @param {string} path - the path to request\n * @param {Object} data - any query parameters for the request\n * @param {Requestable.callback} cb - the callback that will receive `true` or `false`\n * @param {method} [method=GET] - HTTP Method to use\n * @return {Promise} - the promise for the http request\n */\n _request204or404(path, data, cb, method = 'GET') {\n return this._request(method, path, data)\n .then(function success(response) {\n if (cb) {\n cb(null, true, response);\n }\n return true;\n }, function failure(response) {\n if (response.response.status === 404) {\n if (cb) {\n cb(null, false, response);\n }\n return false;\n }\n\n if (cb) {\n cb(response);\n }\n throw response;\n });\n }\n\n /**\n * Make a request and fetch all the available data. Github will paginate responses so for queries\n * that might span multiple pages this method is preferred to {@link Requestable#request}\n * @param {string} path - the path to request\n * @param {Object} options - the query parameters to include\n * @param {Requestable.callback} [cb] - the function to receive the data. The returned data will always be an array.\n * @param {Object[]} results - the partial results. This argument is intended for interal use only.\n * @return {Promise} - a promise which will resolve when all pages have been fetched\n * @deprecated This will be folded into {@link Requestable#_request} in the 2.0 release.\n */\n _requestAllPages(path, options, cb, results) {\n results = results || [];\n\n return this._request('GET', path, options)\n .then((response) => {\n let thisGroup;\n if (response.data instanceof Array) {\n thisGroup = response.data;\n } else if (response.data.items instanceof Array) {\n thisGroup = response.data.items;\n } else {\n let message = `cannot figure out how to append ${response.data} to the result set`;\n throw new ResponseError(message, path, response);\n }\n results.push(...thisGroup);\n\n const nextUrl = getNextPage(response.headers.link);\n if (nextUrl && typeof options.page !== 'number') {\n log(`getting next page: ${nextUrl}`);\n return this._requestAllPages(nextUrl, options, cb, results);\n }\n\n if (cb) {\n cb(null, results, response);\n }\n\n response.data = results;\n return response;\n }).catch(callbackErrorOrThrow(cb, path));\n }\n}\n\nmodule.exports = Requestable;\n\n// ////////////////////////// //\n// Private helper functions //\n// ////////////////////////// //\nconst METHODS_WITH_NO_BODY = ['GET', 'HEAD', 'DELETE'];\nfunction methodHasNoBody(method) {\n return METHODS_WITH_NO_BODY.indexOf(method) !== -1;\n}\n\nfunction getNextPage(linksHeader = '') {\n const links = linksHeader.split(/\\s*,\\s*/); // splits and strips the urls\n return links.reduce(function(nextUrl, link) {\n if (link.search(/rel=\"next\"/) !== -1) {\n return (link.match(/<(.*)>/) || [])[1];\n }\n\n return nextUrl;\n }, undefined);\n}\n\nfunction callbackErrorOrThrow(cb, path) {\n return function handler(object) {\n let error;\n if (object.hasOwnProperty('config')) {\n const {response: {status, statusText}, config: {method, url}} = object;\n let message = (`${status} error making request ${method} ${url}: \"${statusText}\"`);\n error = new ResponseError(message, path, object);\n log(`${message} ${JSON.stringify(object.data)}`);\n } else {\n error = object;\n }\n if (cb) {\n log('going to error callback');\n cb(error);\n } else {\n log('throwing error');\n throw error;\n }\n };\n}\n","/**\n * @file\n * @copyright 2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n * Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\nimport debug from 'debug';\nconst log = debug('github:search');\n\n/**\n * Wrap the Search API\n */\nclass Search extends Requestable {\n /**\n * Create a Search\n * @param {Object} defaults - defaults for the search\n * @param {Requestable.auth} [auth] - information required to authenticate to Github\n * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n */\n constructor(defaults, auth, apiBase) {\n super(auth, apiBase);\n this.__defaults = this._getOptionsWithDefaults(defaults);\n }\n\n /**\n * Available search options\n * @see https://developer.github.com/v3/search/#parameters\n * @typedef {Object} Search.Params\n * @param {string} q - the query to make\n * @param {string} sort - the sort field, one of `stars`, `forks`, or `updated`.\n * Default is [best match](https://developer.github.com/v3/search/#ranking-search-results)\n * @param {string} order - the ordering, either `asc` or `desc`\n */\n /**\n * Perform a search on the GitHub API\n * @private\n * @param {string} path - the scope of the search\n * @param {Search.Params} [withOptions] - additional parameters for the search\n * @param {Requestable.callback} [cb] - will receive the results of the search\n * @return {Promise} - the promise for the http request\n */\n _search(path, withOptions = {}, cb = undefined) {\n let requestOptions = {};\n Object.keys(this.__defaults).forEach((prop) => {\n requestOptions[prop] = this.__defaults[prop];\n });\n Object.keys(withOptions).forEach((prop) => {\n requestOptions[prop] = withOptions[prop];\n });\n\n log(`searching ${path} with options:`, requestOptions);\n return this._requestAllPages(`/search/${path}`, requestOptions, cb);\n }\n\n /**\n * Search for repositories\n * @see https://developer.github.com/v3/search/#search-repositories\n * @param {Search.Params} [options] - additional parameters for the search\n * @param {Requestable.callback} [cb] - will receive the results of the search\n * @return {Promise} - the promise for the http request\n */\n forRepositories(options, cb) {\n return this._search('repositories', options, cb);\n }\n\n /**\n * Search for code\n * @see https://developer.github.com/v3/search/#search-code\n * @param {Search.Params} [options] - additional parameters for the search\n * @param {Requestable.callback} [cb] - will receive the results of the search\n * @return {Promise} - the promise for the http request\n */\n forCode(options, cb) {\n return this._search('code', options, cb);\n }\n\n /**\n * Search for issues\n * @see https://developer.github.com/v3/search/#search-issues\n * @param {Search.Params} [options] - additional parameters for the search\n * @param {Requestable.callback} [cb] - will receive the results of the search\n * @return {Promise} - the promise for the http request\n */\n forIssues(options, cb) {\n return this._search('issues', options, cb);\n }\n\n /**\n * Search for users\n * @see https://developer.github.com/v3/search/#search-users\n * @param {Search.Params} [options] - additional parameters for the search\n * @param {Requestable.callback} [cb] - will receive the results of the search\n * @return {Promise} - the promise for the http request\n */\n forUsers(options, cb) {\n return this._search('users', options, cb);\n }\n}\n\nmodule.exports = Search;\n","/**\n * @file\n * @copyright 2016 Matt Smith (Development Seed)\n * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n * Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\nimport debug from 'debug';\nconst log = debug('github:team');\n\n/**\n * A Team allows scoping of API requests to a particular Github Organization Team.\n */\nclass Team extends Requestable {\n /**\n * Create a Team.\n * @param {string} [teamId] - the id for the team\n * @param {Requestable.auth} [auth] - information required to authenticate to Github\n * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n */\n constructor(teamId, auth, apiBase) {\n super(auth, apiBase);\n this.__teamId = teamId;\n }\n\n /**\n * Get Team information\n * @see https://developer.github.com/v3/orgs/teams/#get-team\n * @param {Requestable.callback} [cb] - will receive the team\n * @return {Promise} - the promise for the http request\n */\n getTeam(cb) {\n log(`Fetching Team ${this.__teamId}`);\n return this._request('Get', `/teams/${this.__teamId}`, undefined, cb);\n }\n\n /**\n * List the Team's repositories\n * @see https://developer.github.com/v3/orgs/teams/#list-team-repos\n * @param {Requestable.callback} [cb] - will receive the list of repositories\n * @return {Promise} - the promise for the http request\n */\n listRepos(cb) {\n log(`Fetching repositories for Team ${this.__teamId}`);\n return this._requestAllPages(`/teams/${this.__teamId}/repos`, undefined, cb);\n }\n\n /**\n * Edit Team information\n * @see https://developer.github.com/v3/orgs/teams/#edit-team\n * @param {object} options - Parameters for team edit\n * @param {string} options.name - The name of the team\n * @param {string} [options.description] - Team description\n * @param {string} [options.repo_names] - Repos to add the team to\n * @param {string} [options.privacy=secret] - The level of privacy the team should have. Can be either one\n * of: `secret`, or `closed`\n * @param {Requestable.callback} [cb] - will receive the updated team\n * @return {Promise} - the promise for the http request\n */\n editTeam(options, cb) {\n log(`Editing Team ${this.__teamId}`);\n return this._request('PATCH', `/teams/${this.__teamId}`, options, cb);\n }\n\n /**\n * List the users who are members of the Team\n * @see https://developer.github.com/v3/orgs/teams/#list-team-members\n * @param {object} options - Parameters for listing team users\n * @param {string} [options.role=all] - can be one of: `all`, `maintainer`, or `member`\n * @param {Requestable.callback} [cb] - will receive the list of users\n * @return {Promise} - the promise for the http request\n */\n listMembers(options, cb) {\n log(`Getting members of Team ${this.__teamId}`);\n return this._requestAllPages(`/teams/${this.__teamId}/members`, options, cb);\n }\n\n /**\n * Get Team membership status for a user\n * @see https://developer.github.com/v3/orgs/teams/#get-team-membership\n * @param {string} username - can be one of: `all`, `maintainer`, or `member`\n * @param {Requestable.callback} [cb] - will receive the membership status of a user\n * @return {Promise} - the promise for the http request\n */\n getMembership(username, cb) {\n log(`Getting membership of user ${username} in Team ${this.__teamId}`);\n return this._request('GET', `/teams/${this.__teamId}/memberships/${username}`, undefined, cb);\n }\n\n /**\n * Add a member to the Team\n * @see https://developer.github.com/v3/orgs/teams/#add-team-membership\n * @param {string} username - can be one of: `all`, `maintainer`, or `member`\n * @param {object} options - Parameters for adding a team member\n * @param {string} [options.role=member] - The role that this user should have in the team. Can be one\n * of: `member`, or `maintainer`\n * @param {Requestable.callback} [cb] - will receive the membership status of added user\n * @return {Promise} - the promise for the http request\n */\n addMembership(username, options, cb) {\n log(`Adding user ${username} to Team ${this.__teamId}`);\n return this._request('PUT', `/teams/${this.__teamId}/memberships/${username}`, options, cb);\n }\n\n /**\n * Get repo management status for team\n * @see https://developer.github.com/v3/orgs/teams/#remove-team-membership\n * @param {string} owner - Organization name\n * @param {string} repo - Repo name\n * @param {Requestable.callback} [cb] - will receive the membership status of added user\n * @return {Promise} - the promise for the http request\n */\n isManagedRepo(owner, repo, cb) {\n log(`Getting repo management by Team ${this.__teamId} for repo ${owner}/${repo}`);\n return this._request204or404(`/teams/${this.__teamId}/repos/${owner}/${repo}`, undefined, cb);\n }\n\n /**\n * Add or Update repo management status for team\n * @see https://developer.github.com/v3/orgs/teams/#add-or-update-team-repository\n * @param {string} owner - Organization name\n * @param {string} repo - Repo name\n * @param {object} options - Parameters for adding or updating repo management for the team\n * @param {string} [options.permission] - The permission to grant the team on this repository. Can be one\n * of: `pull`, `push`, or `admin`\n * @param {Requestable.callback} [cb] - will receive the membership status of added user\n * @return {Promise} - the promise for the http request\n */\n manageRepo(owner, repo, options, cb) {\n log(`Adding or Updating repo management by Team ${this.__teamId} for repo ${owner}/${repo}`);\n return this._request204or404(`/teams/${this.__teamId}/repos/${owner}/${repo}`, options, cb, 'PUT');\n }\n\n /**\n * Remove repo management status for team\n * @see https://developer.github.com/v3/orgs/teams/#remove-team-repository\n * @param {string} owner - Organization name\n * @param {string} repo - Repo name\n * @param {Requestable.callback} [cb] - will receive the membership status of added user\n * @return {Promise} - the promise for the http request\n */\n unmanageRepo(owner, repo, cb) {\n log(`Remove repo management by Team ${this.__teamId} for repo ${owner}/${repo}`);\n return this._request204or404(`/teams/${this.__teamId}/repos/${owner}/${repo}`, undefined, cb, 'DELETE');\n }\n\n /**\n * Delete Team\n * @see https://developer.github.com/v3/orgs/teams/#delete-team\n * @param {Requestable.callback} [cb] - will receive the list of repositories\n * @return {Promise} - the promise for the http request\n */\n deleteTeam(cb) {\n log(`Deleting Team ${this.__teamId}`);\n return this._request204or404(`/teams/${this.__teamId}`, undefined, cb, 'DELETE');\n }\n}\n\nmodule.exports = Team;\n","/**\n * @file\n * @copyright 2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n * Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\nimport debug from 'debug';\nconst log = debug('github:user');\n\n/**\n * A User allows scoping of API requests to a particular Github user.\n */\nclass User extends Requestable {\n /**\n * Create a User.\n * @param {string} [username] - the user to use for user-scoped queries\n * @param {Requestable.auth} [auth] - information required to authenticate to Github\n * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n */\n constructor(username, auth, apiBase) {\n super(auth, apiBase);\n this.__user = username;\n }\n\n /**\n * Get the url for the request. (dependent on if we're requesting for the authenticated user or not)\n * @private\n * @param {string} endpoint - the endpoint being requested\n * @return {string} - the resolved endpoint\n */\n __getScopedUrl(endpoint) {\n if (this.__user) {\n return endpoint ?\n `/users/${this.__user}/${endpoint}` :\n `/users/${this.__user}`\n ;\n\n } else { // eslint-disable-line\n switch (endpoint) {\n case '':\n return '/user';\n\n case 'notifications':\n case 'gists':\n return `/${endpoint}`;\n\n default:\n return `/user/${endpoint}`;\n }\n }\n }\n\n /**\n * List the user's repositories\n * @see https://developer.github.com/v3/repos/#list-user-repositories\n * @param {Object} [options={}] - any options to refine the search\n * @param {Requestable.callback} [cb] - will receive the list of repositories\n * @return {Promise} - the promise for the http request\n */\n listRepos(options, cb) {\n if (typeof options === 'function') {\n cb = options;\n options = {};\n }\n\n options = this._getOptionsWithDefaults(options);\n\n log(`Fetching repositories with options: ${JSON.stringify(options)}`);\n return this._requestAllPages(this.__getScopedUrl('repos'), options, cb);\n }\n\n /**\n * List the orgs that the user belongs to\n * @see https://developer.github.com/v3/orgs/#list-user-organizations\n * @param {Requestable.callback} [cb] - will receive the list of organizations\n * @return {Promise} - the promise for the http request\n */\n listOrgs(cb) {\n return this._request('GET', this.__getScopedUrl('orgs'), null, cb);\n }\n\n /**\n * List the user's gists\n * @see https://developer.github.com/v3/gists/#list-a-users-gists\n * @param {Requestable.callback} [cb] - will receive the list of gists\n * @return {Promise} - the promise for the http request\n */\n listGists(cb) {\n return this._request('GET', this.__getScopedUrl('gists'), null, cb);\n }\n\n /**\n * List the user's starred gists\n * @see https://developer.github.com/v3/gists/#list-starred-gists\n * @param {Requestable.callback} [cb] - will receive the list of gists\n * @return {Promise} - the promise for the http request\n */\n listStarredGists(cb) {\n return this._request('GET', this.__getScopedUrl('gists/starred'), null, cb);\n }\n\n /**\n * List the user's gists\n * @see https://developer.github.com/v3/gists/#list-a-users-gists\n * @param {Requestable.callback} [cb] - will receive the list of gists\n * @return {Promise} - the promise for the http request\n */\n listStarredGists(cb) {\n return this._request('GET', this.__getScopedUrl('gists'), null, cb);\n }\n\n /**\n * List the user's notifications\n * @see https://developer.github.com/v3/activity/notifications/#list-your-notifications\n * @param {Object} [options={}] - any options to refine the search\n * @param {Requestable.callback} [cb] - will receive the list of repositories\n * @return {Promise} - the promise for the http request\n */\n listNotifications(options, cb) {\n options = options || {};\n if (typeof options === 'function') {\n cb = options;\n options = {};\n }\n\n options.since = this._dateToISO(options.since);\n options.before = this._dateToISO(options.before);\n\n return this._request('GET', this.__getScopedUrl('notifications'), options, cb);\n }\n\n /**\n * Show the user's profile\n * @see https://developer.github.com/v3/users/#get-a-single-user\n * @param {Requestable.callback} [cb] - will receive the user's information\n * @return {Promise} - the promise for the http request\n */\n getProfile(cb) {\n return this._request('GET', this.__getScopedUrl(''), null, cb);\n }\n\n /**\n * Gets the list of starred repositories for the user\n * @see https://developer.github.com/v3/activity/starring/#list-repositories-being-starred\n * @param {Requestable.callback} [cb] - will receive the list of starred repositories\n * @return {Promise} - the promise for the http request\n */\n listStarredRepos(cb) {\n let requestOptions = this._getOptionsWithDefaults();\n return this._requestAllPages(this.__getScopedUrl('starred'), requestOptions, cb);\n }\n\n /**\n * List email addresses for a user\n * @see https://developer.github.com/v3/users/emails/#list-email-addresses-for-a-user\n * @param {Requestable.callback} [cb] - will receive the list of emails\n * @return {Promise} - the promise for the http request\n */\n getEmails(cb) {\n return this._request('GET', '/user/emails', null, cb);\n }\n\n /**\n * Have the authenticated user follow this user\n * @see https://developer.github.com/v3/users/followers/#follow-a-user\n * @param {string} username - the user to follow\n * @param {Requestable.callback} [cb] - will receive true if the request succeeds\n * @return {Promise} - the promise for the http request\n */\n follow(username, cb) {\n return this._request('PUT', `/user/following/${this.__user}`, null, cb);\n }\n\n /**\n * Have the currently authenticated user unfollow this user\n * @see https://developer.github.com/v3/users/followers/#follow-a-user\n * @param {string} username - the user to unfollow\n * @param {Requestable.callback} [cb] - receives true if the request succeeds\n * @return {Promise} - the promise for the http request\n */\n unfollow(username, cb) {\n return this._request('DELETE', `/user/following/${this.__user}`, null, cb);\n }\n\n /**\n * Create a new repository for the currently authenticated user\n * @see https://developer.github.com/v3/repos/#create\n * @param {object} options - the repository definition\n * @param {Requestable.callback} [cb] - will receive the API response\n * @return {Promise} - the promise for the http request\n */\n createRepo(options, cb) {\n return this._request('POST', '/user/repos', options, cb);\n }\n}\n\nmodule.exports = User;\n","module.exports = require('./lib/axios');","'use strict';\n\nvar utils = require('./../utils');\nvar settle = require('./../core/settle');\nvar buildURL = require('./../helpers/buildURL');\nvar parseHeaders = require('./../helpers/parseHeaders');\nvar isURLSameOrigin = require('./../helpers/isURLSameOrigin');\nvar createError = require('../core/createError');\nvar btoa = (typeof window !== 'undefined' && window.btoa && window.btoa.bind(window)) || require('./../helpers/btoa');\n\nmodule.exports = function xhrAdapter(config) {\n return new Promise(function dispatchXhrRequest(resolve, reject) {\n var requestData = config.data;\n var requestHeaders = config.headers;\n\n if (utils.isFormData(requestData)) {\n delete requestHeaders['Content-Type']; // Let the browser set it\n }\n\n var request = new XMLHttpRequest();\n var loadEvent = 'onreadystatechange';\n var xDomain = false;\n\n // For IE 8/9 CORS support\n // Only supports POST and GET calls and doesn't returns the response headers.\n // DON'T do this for testing b/c XMLHttpRequest is mocked, not XDomainRequest.\n if (process.env.NODE_ENV !== 'test' &&\n typeof window !== 'undefined' &&\n window.XDomainRequest && !('withCredentials' in request) &&\n !isURLSameOrigin(config.url)) {\n request = new window.XDomainRequest();\n loadEvent = 'onload';\n xDomain = true;\n request.onprogress = function handleProgress() {};\n request.ontimeout = function handleTimeout() {};\n }\n\n // HTTP basic authentication\n if (config.auth) {\n var username = config.auth.username || '';\n var password = config.auth.password || '';\n requestHeaders.Authorization = 'Basic ' + btoa(username + ':' + password);\n }\n\n request.open(config.method.toUpperCase(), buildURL(config.url, config.params, config.paramsSerializer), true);\n\n // Set the request timeout in MS\n request.timeout = config.timeout;\n\n // Listen for ready state\n request[loadEvent] = function handleLoad() {\n if (!request || (request.readyState !== 4 && !xDomain)) {\n return;\n }\n\n // The request errored out and we didn't get a response, this will be\n // handled by onerror instead\n // With one exception: request that using file: protocol, most browsers\n // will return status as 0 even though it's a successful request\n if (request.status === 0 && !(request.responseURL && request.responseURL.indexOf('file:') === 0)) {\n return;\n }\n\n // Prepare the response\n var responseHeaders = 'getAllResponseHeaders' in request ? parseHeaders(request.getAllResponseHeaders()) : null;\n var responseData = !config.responseType || config.responseType === 'text' ? request.responseText : request.response;\n var response = {\n data: responseData,\n // IE sends 1223 instead of 204 (https://github.com/mzabriskie/axios/issues/201)\n status: request.status === 1223 ? 204 : request.status,\n statusText: request.status === 1223 ? 'No Content' : request.statusText,\n headers: responseHeaders,\n config: config,\n request: request\n };\n\n settle(resolve, reject, response);\n\n // Clean up request\n request = null;\n };\n\n // Handle low level network errors\n request.onerror = function handleError() {\n // Real errors are hidden from us by the browser\n // onerror should only fire if it's a network error\n reject(createError('Network Error', config));\n\n // Clean up request\n request = null;\n };\n\n // Handle timeout\n request.ontimeout = function handleTimeout() {\n reject(createError('timeout of ' + config.timeout + 'ms exceeded', config, 'ECONNABORTED'));\n\n // Clean up request\n request = null;\n };\n\n // Add xsrf header\n // This is only done if running in a standard browser environment.\n // Specifically not if we're in a web worker, or react-native.\n if (utils.isStandardBrowserEnv()) {\n var cookies = require('./../helpers/cookies');\n\n // Add xsrf header\n var xsrfValue = (config.withCredentials || isURLSameOrigin(config.url)) && config.xsrfCookieName ?\n cookies.read(config.xsrfCookieName) :\n undefined;\n\n if (xsrfValue) {\n requestHeaders[config.xsrfHeaderName] = xsrfValue;\n }\n }\n\n // Add headers to the request\n if ('setRequestHeader' in request) {\n utils.forEach(requestHeaders, function setRequestHeader(val, key) {\n if (typeof requestData === 'undefined' && key.toLowerCase() === 'content-type') {\n // Remove Content-Type if data is undefined\n delete requestHeaders[key];\n } else {\n // Otherwise add header to the request\n request.setRequestHeader(key, val);\n }\n });\n }\n\n // Add withCredentials to request if needed\n if (config.withCredentials) {\n request.withCredentials = true;\n }\n\n // Add responseType to request if needed\n if (config.responseType) {\n try {\n request.responseType = config.responseType;\n } catch (e) {\n if (request.responseType !== 'json') {\n throw e;\n }\n }\n }\n\n // Handle progress if needed\n if (typeof config.onDownloadProgress === 'function') {\n request.addEventListener('progress', config.onDownloadProgress);\n }\n\n // Not all browsers support upload events\n if (typeof config.onUploadProgress === 'function' && request.upload) {\n request.upload.addEventListener('progress', config.onUploadProgress);\n }\n\n if (config.cancelToken) {\n // Handle cancellation\n config.cancelToken.promise.then(function onCanceled(cancel) {\n if (!request) {\n return;\n }\n\n request.abort();\n reject(cancel);\n // Clean up request\n request = null;\n });\n }\n\n if (requestData === undefined) {\n requestData = null;\n }\n\n // Send the request\n request.send(requestData);\n });\n};\n","'use strict';\n\nvar utils = require('./utils');\nvar bind = require('./helpers/bind');\nvar Axios = require('./core/Axios');\nvar defaults = require('./defaults');\n\n/**\n * Create an instance of Axios\n *\n * @param {Object} defaultConfig The default config for the instance\n * @return {Axios} A new instance of Axios\n */\nfunction createInstance(defaultConfig) {\n var context = new Axios(defaultConfig);\n var instance = bind(Axios.prototype.request, context);\n\n // Copy axios.prototype to instance\n utils.extend(instance, Axios.prototype, context);\n\n // Copy context to instance\n utils.extend(instance, context);\n\n return instance;\n}\n\n// Create the default instance to be exported\nvar axios = createInstance(defaults);\n\n// Expose Axios class to allow class inheritance\naxios.Axios = Axios;\n\n// Factory for creating new instances\naxios.create = function create(instanceConfig) {\n return createInstance(utils.merge(defaults, instanceConfig));\n};\n\n// Expose Cancel & CancelToken\naxios.Cancel = require('./cancel/Cancel');\naxios.CancelToken = require('./cancel/CancelToken');\naxios.isCancel = require('./cancel/isCancel');\n\n// Expose all/spread\naxios.all = function all(promises) {\n return Promise.all(promises);\n};\naxios.spread = require('./helpers/spread');\n\nmodule.exports = axios;\n\n// Allow use of default import syntax in TypeScript\nmodule.exports.default = axios;\n","'use strict';\n\n/**\n * A `Cancel` is an object that is thrown when an operation is canceled.\n *\n * @class\n * @param {string=} message The message.\n */\nfunction Cancel(message) {\n this.message = message;\n}\n\nCancel.prototype.toString = function toString() {\n return 'Cancel' + (this.message ? ': ' + this.message : '');\n};\n\nCancel.prototype.__CANCEL__ = true;\n\nmodule.exports = Cancel;\n","'use strict';\n\nvar Cancel = require('./Cancel');\n\n/**\n * A `CancelToken` is an object that can be used to request cancellation of an operation.\n *\n * @class\n * @param {Function} executor The executor function.\n */\nfunction CancelToken(executor) {\n if (typeof executor !== 'function') {\n throw new TypeError('executor must be a function.');\n }\n\n var resolvePromise;\n this.promise = new Promise(function promiseExecutor(resolve) {\n resolvePromise = resolve;\n });\n\n var token = this;\n executor(function cancel(message) {\n if (token.reason) {\n // Cancellation has already been requested\n return;\n }\n\n token.reason = new Cancel(message);\n resolvePromise(token.reason);\n });\n}\n\n/**\n * Throws a `Cancel` if cancellation has been requested.\n */\nCancelToken.prototype.throwIfRequested = function throwIfRequested() {\n if (this.reason) {\n throw this.reason;\n }\n};\n\n/**\n * Returns an object that contains a new `CancelToken` and a function that, when called,\n * cancels the `CancelToken`.\n */\nCancelToken.source = function source() {\n var cancel;\n var token = new CancelToken(function executor(c) {\n cancel = c;\n });\n return {\n token: token,\n cancel: cancel\n };\n};\n\nmodule.exports = CancelToken;\n","'use strict';\n\nmodule.exports = function isCancel(value) {\n return !!(value && value.__CANCEL__);\n};\n","'use strict';\n\nvar defaults = require('./../defaults');\nvar utils = require('./../utils');\nvar InterceptorManager = require('./InterceptorManager');\nvar dispatchRequest = require('./dispatchRequest');\nvar isAbsoluteURL = require('./../helpers/isAbsoluteURL');\nvar combineURLs = require('./../helpers/combineURLs');\n\n/**\n * Create a new instance of Axios\n *\n * @param {Object} instanceConfig The default config for the instance\n */\nfunction Axios(instanceConfig) {\n this.defaults = instanceConfig;\n this.interceptors = {\n request: new InterceptorManager(),\n response: new InterceptorManager()\n };\n}\n\n/**\n * Dispatch a request\n *\n * @param {Object} config The config specific for this request (merged with this.defaults)\n */\nAxios.prototype.request = function request(config) {\n /*eslint no-param-reassign:0*/\n // Allow for axios('example/url'[, config]) a la fetch API\n if (typeof config === 'string') {\n config = utils.merge({\n url: arguments[0]\n }, arguments[1]);\n }\n\n config = utils.merge(defaults, this.defaults, { method: 'get' }, config);\n\n // Support baseURL config\n if (config.baseURL && !isAbsoluteURL(config.url)) {\n config.url = combineURLs(config.baseURL, config.url);\n }\n\n // Hook up interceptors middleware\n var chain = [dispatchRequest, undefined];\n var promise = Promise.resolve(config);\n\n this.interceptors.request.forEach(function unshiftRequestInterceptors(interceptor) {\n chain.unshift(interceptor.fulfilled, interceptor.rejected);\n });\n\n this.interceptors.response.forEach(function pushResponseInterceptors(interceptor) {\n chain.push(interceptor.fulfilled, interceptor.rejected);\n });\n\n while (chain.length) {\n promise = promise.then(chain.shift(), chain.shift());\n }\n\n return promise;\n};\n\n// Provide aliases for supported request methods\nutils.forEach(['delete', 'get', 'head'], function forEachMethodNoData(method) {\n /*eslint func-names:0*/\n Axios.prototype[method] = function(url, config) {\n return this.request(utils.merge(config || {}, {\n method: method,\n url: url\n }));\n };\n});\n\nutils.forEach(['post', 'put', 'patch'], function forEachMethodWithData(method) {\n /*eslint func-names:0*/\n Axios.prototype[method] = function(url, data, config) {\n return this.request(utils.merge(config || {}, {\n method: method,\n url: url,\n data: data\n }));\n };\n});\n\nmodule.exports = Axios;\n","'use strict';\n\nvar utils = require('./../utils');\n\nfunction InterceptorManager() {\n this.handlers = [];\n}\n\n/**\n * Add a new interceptor to the stack\n *\n * @param {Function} fulfilled The function to handle `then` for a `Promise`\n * @param {Function} rejected The function to handle `reject` for a `Promise`\n *\n * @return {Number} An ID used to remove interceptor later\n */\nInterceptorManager.prototype.use = function use(fulfilled, rejected) {\n this.handlers.push({\n fulfilled: fulfilled,\n rejected: rejected\n });\n return this.handlers.length - 1;\n};\n\n/**\n * Remove an interceptor from the stack\n *\n * @param {Number} id The ID that was returned by `use`\n */\nInterceptorManager.prototype.eject = function eject(id) {\n if (this.handlers[id]) {\n this.handlers[id] = null;\n }\n};\n\n/**\n * Iterate over all the registered interceptors\n *\n * This method is particularly useful for skipping over any\n * interceptors that may have become `null` calling `eject`.\n *\n * @param {Function} fn The function to call for each interceptor\n */\nInterceptorManager.prototype.forEach = function forEach(fn) {\n utils.forEach(this.handlers, function forEachHandler(h) {\n if (h !== null) {\n fn(h);\n }\n });\n};\n\nmodule.exports = InterceptorManager;\n","'use strict';\n\nvar enhanceError = require('./enhanceError');\n\n/**\n * Create an Error with the specified message, config, error code, and response.\n *\n * @param {string} message The error message.\n * @param {Object} config The config.\n * @param {string} [code] The error code (for example, 'ECONNABORTED').\n @ @param {Object} [response] The response.\n * @returns {Error} The created error.\n */\nmodule.exports = function createError(message, config, code, response) {\n var error = new Error(message);\n return enhanceError(error, config, code, response);\n};\n","'use strict';\n\nvar utils = require('./../utils');\nvar transformData = require('./transformData');\nvar isCancel = require('../cancel/isCancel');\nvar defaults = require('../defaults');\n\n/**\n * Throws a `Cancel` if cancellation has been requested.\n */\nfunction throwIfCancellationRequested(config) {\n if (config.cancelToken) {\n config.cancelToken.throwIfRequested();\n }\n}\n\n/**\n * Dispatch a request to the server using the configured adapter.\n *\n * @param {object} config The config that is to be used for the request\n * @returns {Promise} The Promise to be fulfilled\n */\nmodule.exports = function dispatchRequest(config) {\n throwIfCancellationRequested(config);\n\n // Ensure headers exist\n config.headers = config.headers || {};\n\n // Transform request data\n config.data = transformData(\n config.data,\n config.headers,\n config.transformRequest\n );\n\n // Flatten headers\n config.headers = utils.merge(\n config.headers.common || {},\n config.headers[config.method] || {},\n config.headers || {}\n );\n\n utils.forEach(\n ['delete', 'get', 'head', 'post', 'put', 'patch', 'common'],\n function cleanHeaderConfig(method) {\n delete config.headers[method];\n }\n );\n\n var adapter = config.adapter || defaults.adapter;\n\n return adapter(config).then(function onAdapterResolution(response) {\n throwIfCancellationRequested(config);\n\n // Transform response data\n response.data = transformData(\n response.data,\n response.headers,\n config.transformResponse\n );\n\n return response;\n }, function onAdapterRejection(reason) {\n if (!isCancel(reason)) {\n throwIfCancellationRequested(config);\n\n // Transform response data\n if (reason && reason.response) {\n reason.response.data = transformData(\n reason.response.data,\n reason.response.headers,\n config.transformResponse\n );\n }\n }\n\n return Promise.reject(reason);\n });\n};\n","'use strict';\n\n/**\n * Update an Error with the specified config, error code, and response.\n *\n * @param {Error} error The error to update.\n * @param {Object} config The config.\n * @param {string} [code] The error code (for example, 'ECONNABORTED').\n @ @param {Object} [response] The response.\n * @returns {Error} The error.\n */\nmodule.exports = function enhanceError(error, config, code, response) {\n error.config = config;\n if (code) {\n error.code = code;\n }\n error.response = response;\n return error;\n};\n","'use strict';\n\nvar createError = require('./createError');\n\n/**\n * Resolve or reject a Promise based on response status.\n *\n * @param {Function} resolve A function that resolves the promise.\n * @param {Function} reject A function that rejects the promise.\n * @param {object} response The response.\n */\nmodule.exports = function settle(resolve, reject, response) {\n var validateStatus = response.config.validateStatus;\n // Note: status is not exposed by XDomainRequest\n if (!response.status || !validateStatus || validateStatus(response.status)) {\n resolve(response);\n } else {\n reject(createError(\n 'Request failed with status code ' + response.status,\n response.config,\n null,\n response\n ));\n }\n};\n","'use strict';\n\nvar utils = require('./../utils');\n\n/**\n * Transform the data for a request or a response\n *\n * @param {Object|String} data The data to be transformed\n * @param {Array} headers The headers for the request or response\n * @param {Array|Function} fns A single function or Array of functions\n * @returns {*} The resulting transformed data\n */\nmodule.exports = function transformData(data, headers, fns) {\n /*eslint no-param-reassign:0*/\n utils.forEach(fns, function transform(fn) {\n data = fn(data, headers);\n });\n\n return data;\n};\n","'use strict';\n\nvar utils = require('./utils');\nvar normalizeHeaderName = require('./helpers/normalizeHeaderName');\n\nvar PROTECTION_PREFIX = /^\\)\\]\\}',?\\n/;\nvar DEFAULT_CONTENT_TYPE = {\n 'Content-Type': 'application/x-www-form-urlencoded'\n};\n\nfunction setContentTypeIfUnset(headers, value) {\n if (!utils.isUndefined(headers) && utils.isUndefined(headers['Content-Type'])) {\n headers['Content-Type'] = value;\n }\n}\n\nfunction getDefaultAdapter() {\n var adapter;\n if (typeof XMLHttpRequest !== 'undefined') {\n // For browsers use XHR adapter\n adapter = require('./adapters/xhr');\n } else if (typeof process !== 'undefined') {\n // For node use HTTP adapter\n adapter = require('./adapters/http');\n }\n return adapter;\n}\n\nvar defaults = {\n adapter: getDefaultAdapter(),\n\n transformRequest: [function transformRequest(data, headers) {\n normalizeHeaderName(headers, 'Content-Type');\n if (utils.isFormData(data) ||\n utils.isArrayBuffer(data) ||\n utils.isStream(data) ||\n utils.isFile(data) ||\n utils.isBlob(data)\n ) {\n return data;\n }\n if (utils.isArrayBufferView(data)) {\n return data.buffer;\n }\n if (utils.isURLSearchParams(data)) {\n setContentTypeIfUnset(headers, 'application/x-www-form-urlencoded;charset=utf-8');\n return data.toString();\n }\n if (utils.isObject(data)) {\n setContentTypeIfUnset(headers, 'application/json;charset=utf-8');\n return JSON.stringify(data);\n }\n return data;\n }],\n\n transformResponse: [function transformResponse(data) {\n /*eslint no-param-reassign:0*/\n if (typeof data === 'string') {\n data = data.replace(PROTECTION_PREFIX, '');\n try {\n data = JSON.parse(data);\n } catch (e) { /* Ignore */ }\n }\n return data;\n }],\n\n timeout: 0,\n\n xsrfCookieName: 'XSRF-TOKEN',\n xsrfHeaderName: 'X-XSRF-TOKEN',\n\n maxContentLength: -1,\n\n validateStatus: function validateStatus(status) {\n return status >= 200 && status < 300;\n }\n};\n\ndefaults.headers = {\n common: {\n 'Accept': 'application/json, text/plain, */*'\n }\n};\n\nutils.forEach(['delete', 'get', 'head'], function forEachMehtodNoData(method) {\n defaults.headers[method] = {};\n});\n\nutils.forEach(['post', 'put', 'patch'], function forEachMethodWithData(method) {\n defaults.headers[method] = utils.merge(DEFAULT_CONTENT_TYPE);\n});\n\nmodule.exports = defaults;\n","'use strict';\n\nmodule.exports = function bind(fn, thisArg) {\n return function wrap() {\n var args = new Array(arguments.length);\n for (var i = 0; i < args.length; i++) {\n args[i] = arguments[i];\n }\n return fn.apply(thisArg, args);\n };\n};\n","'use strict';\n\n// btoa polyfill for IE<10 courtesy https://github.com/davidchambers/Base64.js\n\nvar chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=';\n\nfunction E() {\n this.message = 'String contains an invalid character';\n}\nE.prototype = new Error;\nE.prototype.code = 5;\nE.prototype.name = 'InvalidCharacterError';\n\nfunction btoa(input) {\n var str = String(input);\n var output = '';\n for (\n // initialize result and counter\n var block, charCode, idx = 0, map = chars;\n // if the next str index does not exist:\n // change the mapping table to \"=\"\n // check if d has no fractional digits\n str.charAt(idx | 0) || (map = '=', idx % 1);\n // \"8 - idx % 1 * 8\" generates the sequence 2, 4, 6, 8\n output += map.charAt(63 & block >> 8 - idx % 1 * 8)\n ) {\n charCode = str.charCodeAt(idx += 3 / 4);\n if (charCode > 0xFF) {\n throw new E();\n }\n block = block << 8 | charCode;\n }\n return output;\n}\n\nmodule.exports = btoa;\n","'use strict';\n\nvar utils = require('./../utils');\n\nfunction encode(val) {\n return encodeURIComponent(val).\n replace(/%40/gi, '@').\n replace(/%3A/gi, ':').\n replace(/%24/g, '$').\n replace(/%2C/gi, ',').\n replace(/%20/g, '+').\n replace(/%5B/gi, '[').\n replace(/%5D/gi, ']');\n}\n\n/**\n * Build a URL by appending params to the end\n *\n * @param {string} url The base of the url (e.g., http://www.google.com)\n * @param {object} [params] The params to be appended\n * @returns {string} The formatted url\n */\nmodule.exports = function buildURL(url, params, paramsSerializer) {\n /*eslint no-param-reassign:0*/\n if (!params) {\n return url;\n }\n\n var serializedParams;\n if (paramsSerializer) {\n serializedParams = paramsSerializer(params);\n } else if (utils.isURLSearchParams(params)) {\n serializedParams = params.toString();\n } else {\n var parts = [];\n\n utils.forEach(params, function serialize(val, key) {\n if (val === null || typeof val === 'undefined') {\n return;\n }\n\n if (utils.isArray(val)) {\n key = key + '[]';\n }\n\n if (!utils.isArray(val)) {\n val = [val];\n }\n\n utils.forEach(val, function parseValue(v) {\n if (utils.isDate(v)) {\n v = v.toISOString();\n } else if (utils.isObject(v)) {\n v = JSON.stringify(v);\n }\n parts.push(encode(key) + '=' + encode(v));\n });\n });\n\n serializedParams = parts.join('&');\n }\n\n if (serializedParams) {\n url += (url.indexOf('?') === -1 ? '?' : '&') + serializedParams;\n }\n\n return url;\n};\n","'use strict';\n\n/**\n * Creates a new URL by combining the specified URLs\n *\n * @param {string} baseURL The base URL\n * @param {string} relativeURL The relative URL\n * @returns {string} The combined URL\n */\nmodule.exports = function combineURLs(baseURL, relativeURL) {\n return baseURL.replace(/\\/+$/, '') + '/' + relativeURL.replace(/^\\/+/, '');\n};\n","'use strict';\n\nvar utils = require('./../utils');\n\nmodule.exports = (\n utils.isStandardBrowserEnv() ?\n\n // Standard browser envs support document.cookie\n (function standardBrowserEnv() {\n return {\n write: function write(name, value, expires, path, domain, secure) {\n var cookie = [];\n cookie.push(name + '=' + encodeURIComponent(value));\n\n if (utils.isNumber(expires)) {\n cookie.push('expires=' + new Date(expires).toGMTString());\n }\n\n if (utils.isString(path)) {\n cookie.push('path=' + path);\n }\n\n if (utils.isString(domain)) {\n cookie.push('domain=' + domain);\n }\n\n if (secure === true) {\n cookie.push('secure');\n }\n\n document.cookie = cookie.join('; ');\n },\n\n read: function read(name) {\n var match = document.cookie.match(new RegExp('(^|;\\\\s*)(' + name + ')=([^;]*)'));\n return (match ? decodeURIComponent(match[3]) : null);\n },\n\n remove: function remove(name) {\n this.write(name, '', Date.now() - 86400000);\n }\n };\n })() :\n\n // Non standard browser env (web workers, react-native) lack needed support.\n (function nonStandardBrowserEnv() {\n return {\n write: function write() {},\n read: function read() { return null; },\n remove: function remove() {}\n };\n })()\n);\n","'use strict';\n\n/**\n * Determines whether the specified URL is absolute\n *\n * @param {string} url The URL to test\n * @returns {boolean} True if the specified URL is absolute, otherwise false\n */\nmodule.exports = function isAbsoluteURL(url) {\n // A URL is considered absolute if it begins with \"://\" or \"//\" (protocol-relative URL).\n // RFC 3986 defines scheme name as a sequence of characters beginning with a letter and followed\n // by any combination of letters, digits, plus, period, or hyphen.\n return /^([a-z][a-z\\d\\+\\-\\.]*:)?\\/\\//i.test(url);\n};\n","'use strict';\n\nvar utils = require('./../utils');\n\nmodule.exports = (\n utils.isStandardBrowserEnv() ?\n\n // Standard browser envs have full support of the APIs needed to test\n // whether the request URL is of the same origin as current location.\n (function standardBrowserEnv() {\n var msie = /(msie|trident)/i.test(navigator.userAgent);\n var urlParsingNode = document.createElement('a');\n var originURL;\n\n /**\n * Parse a URL to discover it's components\n *\n * @param {String} url The URL to be parsed\n * @returns {Object}\n */\n function resolveURL(url) {\n var href = url;\n\n if (msie) {\n // IE needs attribute set twice to normalize properties\n urlParsingNode.setAttribute('href', href);\n href = urlParsingNode.href;\n }\n\n urlParsingNode.setAttribute('href', href);\n\n // urlParsingNode provides the UrlUtils interface - http://url.spec.whatwg.org/#urlutils\n return {\n href: urlParsingNode.href,\n protocol: urlParsingNode.protocol ? urlParsingNode.protocol.replace(/:$/, '') : '',\n host: urlParsingNode.host,\n search: urlParsingNode.search ? urlParsingNode.search.replace(/^\\?/, '') : '',\n hash: urlParsingNode.hash ? urlParsingNode.hash.replace(/^#/, '') : '',\n hostname: urlParsingNode.hostname,\n port: urlParsingNode.port,\n pathname: (urlParsingNode.pathname.charAt(0) === '/') ?\n urlParsingNode.pathname :\n '/' + urlParsingNode.pathname\n };\n }\n\n originURL = resolveURL(window.location.href);\n\n /**\n * Determine if a URL shares the same origin as the current location\n *\n * @param {String} requestURL The URL to test\n * @returns {boolean} True if URL shares the same origin, otherwise false\n */\n return function isURLSameOrigin(requestURL) {\n var parsed = (utils.isString(requestURL)) ? resolveURL(requestURL) : requestURL;\n return (parsed.protocol === originURL.protocol &&\n parsed.host === originURL.host);\n };\n })() :\n\n // Non standard browser envs (web workers, react-native) lack needed support.\n (function nonStandardBrowserEnv() {\n return function isURLSameOrigin() {\n return true;\n };\n })()\n);\n","'use strict';\n\nvar utils = require('../utils');\n\nmodule.exports = function normalizeHeaderName(headers, normalizedName) {\n utils.forEach(headers, function processHeader(value, name) {\n if (name !== normalizedName && name.toUpperCase() === normalizedName.toUpperCase()) {\n headers[normalizedName] = value;\n delete headers[name];\n }\n });\n};\n","'use strict';\n\nvar utils = require('./../utils');\n\n/**\n * Parse headers into an object\n *\n * ```\n * Date: Wed, 27 Aug 2014 08:58:49 GMT\n * Content-Type: application/json\n * Connection: keep-alive\n * Transfer-Encoding: chunked\n * ```\n *\n * @param {String} headers Headers needing to be parsed\n * @returns {Object} Headers parsed into an object\n */\nmodule.exports = function parseHeaders(headers) {\n var parsed = {};\n var key;\n var val;\n var i;\n\n if (!headers) { return parsed; }\n\n utils.forEach(headers.split('\\n'), function parser(line) {\n i = line.indexOf(':');\n key = utils.trim(line.substr(0, i)).toLowerCase();\n val = utils.trim(line.substr(i + 1));\n\n if (key) {\n parsed[key] = parsed[key] ? parsed[key] + ', ' + val : val;\n }\n });\n\n return parsed;\n};\n","'use strict';\n\n/**\n * Syntactic sugar for invoking a function and expanding an array for arguments.\n *\n * Common use case would be to use `Function.prototype.apply`.\n *\n * ```js\n * function f(x, y, z) {}\n * var args = [1, 2, 3];\n * f.apply(null, args);\n * ```\n *\n * With `spread` this example can be re-written.\n *\n * ```js\n * spread(function(x, y, z) {})([1, 2, 3]);\n * ```\n *\n * @param {Function} callback\n * @returns {Function}\n */\nmodule.exports = function spread(callback) {\n return function wrap(arr) {\n return callback.apply(null, arr);\n };\n};\n","'use strict';\n\nvar bind = require('./helpers/bind');\n\n/*global toString:true*/\n\n// utils is a library of generic helper functions non-specific to axios\n\nvar toString = Object.prototype.toString;\n\n/**\n * Determine if a value is an Array\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if value is an Array, otherwise false\n */\nfunction isArray(val) {\n return toString.call(val) === '[object Array]';\n}\n\n/**\n * Determine if a value is an ArrayBuffer\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if value is an ArrayBuffer, otherwise false\n */\nfunction isArrayBuffer(val) {\n return toString.call(val) === '[object ArrayBuffer]';\n}\n\n/**\n * Determine if a value is a FormData\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if value is an FormData, otherwise false\n */\nfunction isFormData(val) {\n return (typeof FormData !== 'undefined') && (val instanceof FormData);\n}\n\n/**\n * Determine if a value is a view on an ArrayBuffer\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if value is a view on an ArrayBuffer, otherwise false\n */\nfunction isArrayBufferView(val) {\n var result;\n if ((typeof ArrayBuffer !== 'undefined') && (ArrayBuffer.isView)) {\n result = ArrayBuffer.isView(val);\n } else {\n result = (val) && (val.buffer) && (val.buffer instanceof ArrayBuffer);\n }\n return result;\n}\n\n/**\n * Determine if a value is a String\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if value is a String, otherwise false\n */\nfunction isString(val) {\n return typeof val === 'string';\n}\n\n/**\n * Determine if a value is a Number\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if value is a Number, otherwise false\n */\nfunction isNumber(val) {\n return typeof val === 'number';\n}\n\n/**\n * Determine if a value is undefined\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if the value is undefined, otherwise false\n */\nfunction isUndefined(val) {\n return typeof val === 'undefined';\n}\n\n/**\n * Determine if a value is an Object\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if value is an Object, otherwise false\n */\nfunction isObject(val) {\n return val !== null && typeof val === 'object';\n}\n\n/**\n * Determine if a value is a Date\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if value is a Date, otherwise false\n */\nfunction isDate(val) {\n return toString.call(val) === '[object Date]';\n}\n\n/**\n * Determine if a value is a File\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if value is a File, otherwise false\n */\nfunction isFile(val) {\n return toString.call(val) === '[object File]';\n}\n\n/**\n * Determine if a value is a Blob\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if value is a Blob, otherwise false\n */\nfunction isBlob(val) {\n return toString.call(val) === '[object Blob]';\n}\n\n/**\n * Determine if a value is a Function\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if value is a Function, otherwise false\n */\nfunction isFunction(val) {\n return toString.call(val) === '[object Function]';\n}\n\n/**\n * Determine if a value is a Stream\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if value is a Stream, otherwise false\n */\nfunction isStream(val) {\n return isObject(val) && isFunction(val.pipe);\n}\n\n/**\n * Determine if a value is a URLSearchParams object\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if value is a URLSearchParams object, otherwise false\n */\nfunction isURLSearchParams(val) {\n return typeof URLSearchParams !== 'undefined' && val instanceof URLSearchParams;\n}\n\n/**\n * Trim excess whitespace off the beginning and end of a string\n *\n * @param {String} str The String to trim\n * @returns {String} The String freed of excess whitespace\n */\nfunction trim(str) {\n return str.replace(/^\\s*/, '').replace(/\\s*$/, '');\n}\n\n/**\n * Determine if we're running in a standard browser environment\n *\n * This allows axios to run in a web worker, and react-native.\n * Both environments support XMLHttpRequest, but not fully standard globals.\n *\n * web workers:\n * typeof window -> undefined\n * typeof document -> undefined\n *\n * react-native:\n * typeof document.createElement -> undefined\n */\nfunction isStandardBrowserEnv() {\n return (\n typeof window !== 'undefined' &&\n typeof document !== 'undefined' &&\n typeof document.createElement === 'function'\n );\n}\n\n/**\n * Iterate over an Array or an Object invoking a function for each item.\n *\n * If `obj` is an Array callback will be called passing\n * the value, index, and complete array for each item.\n *\n * If 'obj' is an Object callback will be called passing\n * the value, key, and complete object for each property.\n *\n * @param {Object|Array} obj The object to iterate\n * @param {Function} fn The callback to invoke for each item\n */\nfunction forEach(obj, fn) {\n // Don't bother if no value provided\n if (obj === null || typeof obj === 'undefined') {\n return;\n }\n\n // Force an array if not already something iterable\n if (typeof obj !== 'object' && !isArray(obj)) {\n /*eslint no-param-reassign:0*/\n obj = [obj];\n }\n\n if (isArray(obj)) {\n // Iterate over array values\n for (var i = 0, l = obj.length; i < l; i++) {\n fn.call(null, obj[i], i, obj);\n }\n } else {\n // Iterate over object keys\n for (var key in obj) {\n if (Object.prototype.hasOwnProperty.call(obj, key)) {\n fn.call(null, obj[key], key, obj);\n }\n }\n }\n}\n\n/**\n * Accepts varargs expecting each argument to be an object, then\n * immutably merges the properties of each object and returns result.\n *\n * When multiple objects contain the same key the later object in\n * the arguments list will take precedence.\n *\n * Example:\n *\n * ```js\n * var result = merge({foo: 123}, {foo: 456});\n * console.log(result.foo); // outputs 456\n * ```\n *\n * @param {Object} obj1 Object to merge\n * @returns {Object} Result of all merge properties\n */\nfunction merge(/* obj1, obj2, obj3, ... */) {\n var result = {};\n function assignValue(val, key) {\n if (typeof result[key] === 'object' && typeof val === 'object') {\n result[key] = merge(result[key], val);\n } else {\n result[key] = val;\n }\n }\n\n for (var i = 0, l = arguments.length; i < l; i++) {\n forEach(arguments[i], assignValue);\n }\n return result;\n}\n\n/**\n * Extends object a by mutably adding to it the properties of object b.\n *\n * @param {Object} a The object to be extended\n * @param {Object} b The object to copy properties from\n * @param {Object} thisArg The object to bind function to\n * @return {Object} The resulting value of object a\n */\nfunction extend(a, b, thisArg) {\n forEach(b, function assignValue(val, key) {\n if (thisArg && typeof val === 'function') {\n a[key] = bind(val, thisArg);\n } else {\n a[key] = val;\n }\n });\n return a;\n}\n\nmodule.exports = {\n isArray: isArray,\n isArrayBuffer: isArrayBuffer,\n isFormData: isFormData,\n isArrayBufferView: isArrayBufferView,\n isString: isString,\n isNumber: isNumber,\n isObject: isObject,\n isUndefined: isUndefined,\n isDate: isDate,\n isFile: isFile,\n isBlob: isBlob,\n isFunction: isFunction,\n isStream: isStream,\n isURLSearchParams: isURLSearchParams,\n isStandardBrowserEnv: isStandardBrowserEnv,\n forEach: forEach,\n merge: merge,\n extend: extend,\n trim: trim\n};\n","'use strict'\n\nexports.byteLength = byteLength\nexports.toByteArray = toByteArray\nexports.fromByteArray = fromByteArray\n\nvar lookup = []\nvar revLookup = []\nvar Arr = typeof Uint8Array !== 'undefined' ? Uint8Array : Array\n\nvar code = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'\nfor (var i = 0, len = code.length; i < len; ++i) {\n lookup[i] = code[i]\n revLookup[code.charCodeAt(i)] = i\n}\n\nrevLookup['-'.charCodeAt(0)] = 62\nrevLookup['_'.charCodeAt(0)] = 63\n\nfunction placeHoldersCount (b64) {\n var len = b64.length\n if (len % 4 > 0) {\n throw new Error('Invalid string. Length must be a multiple of 4')\n }\n\n // the number of equal signs (place holders)\n // if there are two placeholders, than the two characters before it\n // represent one byte\n // if there is only one, then the three characters before it represent 2 bytes\n // this is just a cheap hack to not do indexOf twice\n return b64[len - 2] === '=' ? 2 : b64[len - 1] === '=' ? 1 : 0\n}\n\nfunction byteLength (b64) {\n // base64 is 4/3 + up to two characters of the original data\n return b64.length * 3 / 4 - placeHoldersCount(b64)\n}\n\nfunction toByteArray (b64) {\n var i, j, l, tmp, placeHolders, arr\n var len = b64.length\n placeHolders = placeHoldersCount(b64)\n\n arr = new Arr(len * 3 / 4 - placeHolders)\n\n // if there are placeholders, only get up to the last complete 4 chars\n l = placeHolders > 0 ? len - 4 : len\n\n var L = 0\n\n for (i = 0, j = 0; i < l; i += 4, j += 3) {\n tmp = (revLookup[b64.charCodeAt(i)] << 18) | (revLookup[b64.charCodeAt(i + 1)] << 12) | (revLookup[b64.charCodeAt(i + 2)] << 6) | revLookup[b64.charCodeAt(i + 3)]\n arr[L++] = (tmp >> 16) & 0xFF\n arr[L++] = (tmp >> 8) & 0xFF\n arr[L++] = tmp & 0xFF\n }\n\n if (placeHolders === 2) {\n tmp = (revLookup[b64.charCodeAt(i)] << 2) | (revLookup[b64.charCodeAt(i + 1)] >> 4)\n arr[L++] = tmp & 0xFF\n } else if (placeHolders === 1) {\n tmp = (revLookup[b64.charCodeAt(i)] << 10) | (revLookup[b64.charCodeAt(i + 1)] << 4) | (revLookup[b64.charCodeAt(i + 2)] >> 2)\n arr[L++] = (tmp >> 8) & 0xFF\n arr[L++] = tmp & 0xFF\n }\n\n return arr\n}\n\nfunction tripletToBase64 (num) {\n return lookup[num >> 18 & 0x3F] + lookup[num >> 12 & 0x3F] + lookup[num >> 6 & 0x3F] + lookup[num & 0x3F]\n}\n\nfunction encodeChunk (uint8, start, end) {\n var tmp\n var output = []\n for (var i = start; i < end; i += 3) {\n tmp = (uint8[i] << 16) + (uint8[i + 1] << 8) + (uint8[i + 2])\n output.push(tripletToBase64(tmp))\n }\n return output.join('')\n}\n\nfunction fromByteArray (uint8) {\n var tmp\n var len = uint8.length\n var extraBytes = len % 3 // if we have 1 byte left, pad 2 bytes\n var output = ''\n var parts = []\n var maxChunkLength = 16383 // must be multiple of 3\n\n // go through the array every three bytes, we'll deal with trailing stuff later\n for (var i = 0, len2 = len - extraBytes; i < len2; i += maxChunkLength) {\n parts.push(encodeChunk(uint8, i, (i + maxChunkLength) > len2 ? len2 : (i + maxChunkLength)))\n }\n\n // pad the end with zeros, but make sure to not forget the extra bytes\n if (extraBytes === 1) {\n tmp = uint8[len - 1]\n output += lookup[tmp >> 2]\n output += lookup[(tmp << 4) & 0x3F]\n output += '=='\n } else if (extraBytes === 2) {\n tmp = (uint8[len - 2] << 8) + (uint8[len - 1])\n output += lookup[tmp >> 10]\n output += lookup[(tmp >> 4) & 0x3F]\n output += lookup[(tmp << 2) & 0x3F]\n output += '='\n }\n\n parts.push(output)\n\n return parts.join('')\n}\n","/*!\n * The buffer module from node.js, for the browser.\n *\n * @author Feross Aboukhadijeh \n * @license MIT\n */\n/* eslint-disable no-proto */\n\n'use strict'\n\nvar base64 = require('base64-js')\nvar ieee754 = require('ieee754')\nvar isArray = require('isarray')\n\nexports.Buffer = Buffer\nexports.SlowBuffer = SlowBuffer\nexports.INSPECT_MAX_BYTES = 50\n\n/**\n * If `Buffer.TYPED_ARRAY_SUPPORT`:\n * === true Use Uint8Array implementation (fastest)\n * === false Use Object implementation (most compatible, even IE6)\n *\n * Browsers that support typed arrays are IE 10+, Firefox 4+, Chrome 7+, Safari 5.1+,\n * Opera 11.6+, iOS 4.2+.\n *\n * Due to various browser bugs, sometimes the Object implementation will be used even\n * when the browser supports typed arrays.\n *\n * Note:\n *\n * - Firefox 4-29 lacks support for adding new properties to `Uint8Array` instances,\n * See: https://bugzilla.mozilla.org/show_bug.cgi?id=695438.\n *\n * - Chrome 9-10 is missing the `TypedArray.prototype.subarray` function.\n *\n * - IE10 has a broken `TypedArray.prototype.subarray` function which returns arrays of\n * incorrect length in some situations.\n\n * We detect these buggy browsers and set `Buffer.TYPED_ARRAY_SUPPORT` to `false` so they\n * get the Object implementation, which is slower but behaves correctly.\n */\nBuffer.TYPED_ARRAY_SUPPORT = global.TYPED_ARRAY_SUPPORT !== undefined\n ? global.TYPED_ARRAY_SUPPORT\n : typedArraySupport()\n\n/*\n * Export kMaxLength after typed array support is determined.\n */\nexports.kMaxLength = kMaxLength()\n\nfunction typedArraySupport () {\n try {\n var arr = new Uint8Array(1)\n arr.__proto__ = {__proto__: Uint8Array.prototype, foo: function () { return 42 }}\n return arr.foo() === 42 && // typed array instances can be augmented\n typeof arr.subarray === 'function' && // chrome 9-10 lack `subarray`\n arr.subarray(1, 1).byteLength === 0 // ie10 has broken `subarray`\n } catch (e) {\n return false\n }\n}\n\nfunction kMaxLength () {\n return Buffer.TYPED_ARRAY_SUPPORT\n ? 0x7fffffff\n : 0x3fffffff\n}\n\nfunction createBuffer (that, length) {\n if (kMaxLength() < length) {\n throw new RangeError('Invalid typed array length')\n }\n if (Buffer.TYPED_ARRAY_SUPPORT) {\n // Return an augmented `Uint8Array` instance, for best performance\n that = new Uint8Array(length)\n that.__proto__ = Buffer.prototype\n } else {\n // Fallback: Return an object instance of the Buffer class\n if (that === null) {\n that = new Buffer(length)\n }\n that.length = length\n }\n\n return that\n}\n\n/**\n * The Buffer constructor returns instances of `Uint8Array` that have their\n * prototype changed to `Buffer.prototype`. Furthermore, `Buffer` is a subclass of\n * `Uint8Array`, so the returned instances will have all the node `Buffer` methods\n * and the `Uint8Array` methods. Square bracket notation works as expected -- it\n * returns a single octet.\n *\n * The `Uint8Array` prototype remains unmodified.\n */\n\nfunction Buffer (arg, encodingOrOffset, length) {\n if (!Buffer.TYPED_ARRAY_SUPPORT && !(this instanceof Buffer)) {\n return new Buffer(arg, encodingOrOffset, length)\n }\n\n // Common case.\n if (typeof arg === 'number') {\n if (typeof encodingOrOffset === 'string') {\n throw new Error(\n 'If encoding is specified then the first argument must be a string'\n )\n }\n return allocUnsafe(this, arg)\n }\n return from(this, arg, encodingOrOffset, length)\n}\n\nBuffer.poolSize = 8192 // not used by this implementation\n\n// TODO: Legacy, not needed anymore. Remove in next major version.\nBuffer._augment = function (arr) {\n arr.__proto__ = Buffer.prototype\n return arr\n}\n\nfunction from (that, value, encodingOrOffset, length) {\n if (typeof value === 'number') {\n throw new TypeError('\"value\" argument must not be a number')\n }\n\n if (typeof ArrayBuffer !== 'undefined' && value instanceof ArrayBuffer) {\n return fromArrayBuffer(that, value, encodingOrOffset, length)\n }\n\n if (typeof value === 'string') {\n return fromString(that, value, encodingOrOffset)\n }\n\n return fromObject(that, value)\n}\n\n/**\n * Functionally equivalent to Buffer(arg, encoding) but throws a TypeError\n * if value is a number.\n * Buffer.from(str[, encoding])\n * Buffer.from(array)\n * Buffer.from(buffer)\n * Buffer.from(arrayBuffer[, byteOffset[, length]])\n **/\nBuffer.from = function (value, encodingOrOffset, length) {\n return from(null, value, encodingOrOffset, length)\n}\n\nif (Buffer.TYPED_ARRAY_SUPPORT) {\n Buffer.prototype.__proto__ = Uint8Array.prototype\n Buffer.__proto__ = Uint8Array\n if (typeof Symbol !== 'undefined' && Symbol.species &&\n Buffer[Symbol.species] === Buffer) {\n // Fix subarray() in ES2016. See: https://github.com/feross/buffer/pull/97\n Object.defineProperty(Buffer, Symbol.species, {\n value: null,\n configurable: true\n })\n }\n}\n\nfunction assertSize (size) {\n if (typeof size !== 'number') {\n throw new TypeError('\"size\" argument must be a number')\n } else if (size < 0) {\n throw new RangeError('\"size\" argument must not be negative')\n }\n}\n\nfunction alloc (that, size, fill, encoding) {\n assertSize(size)\n if (size <= 0) {\n return createBuffer(that, size)\n }\n if (fill !== undefined) {\n // Only pay attention to encoding if it's a string. This\n // prevents accidentally sending in a number that would\n // be interpretted as a start offset.\n return typeof encoding === 'string'\n ? createBuffer(that, size).fill(fill, encoding)\n : createBuffer(that, size).fill(fill)\n }\n return createBuffer(that, size)\n}\n\n/**\n * Creates a new filled Buffer instance.\n * alloc(size[, fill[, encoding]])\n **/\nBuffer.alloc = function (size, fill, encoding) {\n return alloc(null, size, fill, encoding)\n}\n\nfunction allocUnsafe (that, size) {\n assertSize(size)\n that = createBuffer(that, size < 0 ? 0 : checked(size) | 0)\n if (!Buffer.TYPED_ARRAY_SUPPORT) {\n for (var i = 0; i < size; ++i) {\n that[i] = 0\n }\n }\n return that\n}\n\n/**\n * Equivalent to Buffer(num), by default creates a non-zero-filled Buffer instance.\n * */\nBuffer.allocUnsafe = function (size) {\n return allocUnsafe(null, size)\n}\n/**\n * Equivalent to SlowBuffer(num), by default creates a non-zero-filled Buffer instance.\n */\nBuffer.allocUnsafeSlow = function (size) {\n return allocUnsafe(null, size)\n}\n\nfunction fromString (that, string, encoding) {\n if (typeof encoding !== 'string' || encoding === '') {\n encoding = 'utf8'\n }\n\n if (!Buffer.isEncoding(encoding)) {\n throw new TypeError('\"encoding\" must be a valid string encoding')\n }\n\n var length = byteLength(string, encoding) | 0\n that = createBuffer(that, length)\n\n var actual = that.write(string, encoding)\n\n if (actual !== length) {\n // Writing a hex string, for example, that contains invalid characters will\n // cause everything after the first invalid character to be ignored. (e.g.\n // 'abxxcd' will be treated as 'ab')\n that = that.slice(0, actual)\n }\n\n return that\n}\n\nfunction fromArrayLike (that, array) {\n var length = array.length < 0 ? 0 : checked(array.length) | 0\n that = createBuffer(that, length)\n for (var i = 0; i < length; i += 1) {\n that[i] = array[i] & 255\n }\n return that\n}\n\nfunction fromArrayBuffer (that, array, byteOffset, length) {\n array.byteLength // this throws if `array` is not a valid ArrayBuffer\n\n if (byteOffset < 0 || array.byteLength < byteOffset) {\n throw new RangeError('\\'offset\\' is out of bounds')\n }\n\n if (array.byteLength < byteOffset + (length || 0)) {\n throw new RangeError('\\'length\\' is out of bounds')\n }\n\n if (byteOffset === undefined && length === undefined) {\n array = new Uint8Array(array)\n } else if (length === undefined) {\n array = new Uint8Array(array, byteOffset)\n } else {\n array = new Uint8Array(array, byteOffset, length)\n }\n\n if (Buffer.TYPED_ARRAY_SUPPORT) {\n // Return an augmented `Uint8Array` instance, for best performance\n that = array\n that.__proto__ = Buffer.prototype\n } else {\n // Fallback: Return an object instance of the Buffer class\n that = fromArrayLike(that, array)\n }\n return that\n}\n\nfunction fromObject (that, obj) {\n if (Buffer.isBuffer(obj)) {\n var len = checked(obj.length) | 0\n that = createBuffer(that, len)\n\n if (that.length === 0) {\n return that\n }\n\n obj.copy(that, 0, 0, len)\n return that\n }\n\n if (obj) {\n if ((typeof ArrayBuffer !== 'undefined' &&\n obj.buffer instanceof ArrayBuffer) || 'length' in obj) {\n if (typeof obj.length !== 'number' || isnan(obj.length)) {\n return createBuffer(that, 0)\n }\n return fromArrayLike(that, obj)\n }\n\n if (obj.type === 'Buffer' && isArray(obj.data)) {\n return fromArrayLike(that, obj.data)\n }\n }\n\n throw new TypeError('First argument must be a string, Buffer, ArrayBuffer, Array, or array-like object.')\n}\n\nfunction checked (length) {\n // Note: cannot use `length < kMaxLength()` here because that fails when\n // length is NaN (which is otherwise coerced to zero.)\n if (length >= kMaxLength()) {\n throw new RangeError('Attempt to allocate Buffer larger than maximum ' +\n 'size: 0x' + kMaxLength().toString(16) + ' bytes')\n }\n return length | 0\n}\n\nfunction SlowBuffer (length) {\n if (+length != length) { // eslint-disable-line eqeqeq\n length = 0\n }\n return Buffer.alloc(+length)\n}\n\nBuffer.isBuffer = function isBuffer (b) {\n return !!(b != null && b._isBuffer)\n}\n\nBuffer.compare = function compare (a, b) {\n if (!Buffer.isBuffer(a) || !Buffer.isBuffer(b)) {\n throw new TypeError('Arguments must be Buffers')\n }\n\n if (a === b) return 0\n\n var x = a.length\n var y = b.length\n\n for (var i = 0, len = Math.min(x, y); i < len; ++i) {\n if (a[i] !== b[i]) {\n x = a[i]\n y = b[i]\n break\n }\n }\n\n if (x < y) return -1\n if (y < x) return 1\n return 0\n}\n\nBuffer.isEncoding = function isEncoding (encoding) {\n switch (String(encoding).toLowerCase()) {\n case 'hex':\n case 'utf8':\n case 'utf-8':\n case 'ascii':\n case 'latin1':\n case 'binary':\n case 'base64':\n case 'ucs2':\n case 'ucs-2':\n case 'utf16le':\n case 'utf-16le':\n return true\n default:\n return false\n }\n}\n\nBuffer.concat = function concat (list, length) {\n if (!isArray(list)) {\n throw new TypeError('\"list\" argument must be an Array of Buffers')\n }\n\n if (list.length === 0) {\n return Buffer.alloc(0)\n }\n\n var i\n if (length === undefined) {\n length = 0\n for (i = 0; i < list.length; ++i) {\n length += list[i].length\n }\n }\n\n var buffer = Buffer.allocUnsafe(length)\n var pos = 0\n for (i = 0; i < list.length; ++i) {\n var buf = list[i]\n if (!Buffer.isBuffer(buf)) {\n throw new TypeError('\"list\" argument must be an Array of Buffers')\n }\n buf.copy(buffer, pos)\n pos += buf.length\n }\n return buffer\n}\n\nfunction byteLength (string, encoding) {\n if (Buffer.isBuffer(string)) {\n return string.length\n }\n if (typeof ArrayBuffer !== 'undefined' && typeof ArrayBuffer.isView === 'function' &&\n (ArrayBuffer.isView(string) || string instanceof ArrayBuffer)) {\n return string.byteLength\n }\n if (typeof string !== 'string') {\n string = '' + string\n }\n\n var len = string.length\n if (len === 0) return 0\n\n // Use a for loop to avoid recursion\n var loweredCase = false\n for (;;) {\n switch (encoding) {\n case 'ascii':\n case 'latin1':\n case 'binary':\n return len\n case 'utf8':\n case 'utf-8':\n case undefined:\n return utf8ToBytes(string).length\n case 'ucs2':\n case 'ucs-2':\n case 'utf16le':\n case 'utf-16le':\n return len * 2\n case 'hex':\n return len >>> 1\n case 'base64':\n return base64ToBytes(string).length\n default:\n if (loweredCase) return utf8ToBytes(string).length // assume utf8\n encoding = ('' + encoding).toLowerCase()\n loweredCase = true\n }\n }\n}\nBuffer.byteLength = byteLength\n\nfunction slowToString (encoding, start, end) {\n var loweredCase = false\n\n // No need to verify that \"this.length <= MAX_UINT32\" since it's a read-only\n // property of a typed array.\n\n // This behaves neither like String nor Uint8Array in that we set start/end\n // to their upper/lower bounds if the value passed is out of range.\n // undefined is handled specially as per ECMA-262 6th Edition,\n // Section 13.3.3.7 Runtime Semantics: KeyedBindingInitialization.\n if (start === undefined || start < 0) {\n start = 0\n }\n // Return early if start > this.length. Done here to prevent potential uint32\n // coercion fail below.\n if (start > this.length) {\n return ''\n }\n\n if (end === undefined || end > this.length) {\n end = this.length\n }\n\n if (end <= 0) {\n return ''\n }\n\n // Force coersion to uint32. This will also coerce falsey/NaN values to 0.\n end >>>= 0\n start >>>= 0\n\n if (end <= start) {\n return ''\n }\n\n if (!encoding) encoding = 'utf8'\n\n while (true) {\n switch (encoding) {\n case 'hex':\n return hexSlice(this, start, end)\n\n case 'utf8':\n case 'utf-8':\n return utf8Slice(this, start, end)\n\n case 'ascii':\n return asciiSlice(this, start, end)\n\n case 'latin1':\n case 'binary':\n return latin1Slice(this, start, end)\n\n case 'base64':\n return base64Slice(this, start, end)\n\n case 'ucs2':\n case 'ucs-2':\n case 'utf16le':\n case 'utf-16le':\n return utf16leSlice(this, start, end)\n\n default:\n if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)\n encoding = (encoding + '').toLowerCase()\n loweredCase = true\n }\n }\n}\n\n// The property is used by `Buffer.isBuffer` and `is-buffer` (in Safari 5-7) to detect\n// Buffer instances.\nBuffer.prototype._isBuffer = true\n\nfunction swap (b, n, m) {\n var i = b[n]\n b[n] = b[m]\n b[m] = i\n}\n\nBuffer.prototype.swap16 = function swap16 () {\n var len = this.length\n if (len % 2 !== 0) {\n throw new RangeError('Buffer size must be a multiple of 16-bits')\n }\n for (var i = 0; i < len; i += 2) {\n swap(this, i, i + 1)\n }\n return this\n}\n\nBuffer.prototype.swap32 = function swap32 () {\n var len = this.length\n if (len % 4 !== 0) {\n throw new RangeError('Buffer size must be a multiple of 32-bits')\n }\n for (var i = 0; i < len; i += 4) {\n swap(this, i, i + 3)\n swap(this, i + 1, i + 2)\n }\n return this\n}\n\nBuffer.prototype.swap64 = function swap64 () {\n var len = this.length\n if (len % 8 !== 0) {\n throw new RangeError('Buffer size must be a multiple of 64-bits')\n }\n for (var i = 0; i < len; i += 8) {\n swap(this, i, i + 7)\n swap(this, i + 1, i + 6)\n swap(this, i + 2, i + 5)\n swap(this, i + 3, i + 4)\n }\n return this\n}\n\nBuffer.prototype.toString = function toString () {\n var length = this.length | 0\n if (length === 0) return ''\n if (arguments.length === 0) return utf8Slice(this, 0, length)\n return slowToString.apply(this, arguments)\n}\n\nBuffer.prototype.equals = function equals (b) {\n if (!Buffer.isBuffer(b)) throw new TypeError('Argument must be a Buffer')\n if (this === b) return true\n return Buffer.compare(this, b) === 0\n}\n\nBuffer.prototype.inspect = function inspect () {\n var str = ''\n var max = exports.INSPECT_MAX_BYTES\n if (this.length > 0) {\n str = this.toString('hex', 0, max).match(/.{2}/g).join(' ')\n if (this.length > max) str += ' ... '\n }\n return ''\n}\n\nBuffer.prototype.compare = function compare (target, start, end, thisStart, thisEnd) {\n if (!Buffer.isBuffer(target)) {\n throw new TypeError('Argument must be a Buffer')\n }\n\n if (start === undefined) {\n start = 0\n }\n if (end === undefined) {\n end = target ? target.length : 0\n }\n if (thisStart === undefined) {\n thisStart = 0\n }\n if (thisEnd === undefined) {\n thisEnd = this.length\n }\n\n if (start < 0 || end > target.length || thisStart < 0 || thisEnd > this.length) {\n throw new RangeError('out of range index')\n }\n\n if (thisStart >= thisEnd && start >= end) {\n return 0\n }\n if (thisStart >= thisEnd) {\n return -1\n }\n if (start >= end) {\n return 1\n }\n\n start >>>= 0\n end >>>= 0\n thisStart >>>= 0\n thisEnd >>>= 0\n\n if (this === target) return 0\n\n var x = thisEnd - thisStart\n var y = end - start\n var len = Math.min(x, y)\n\n var thisCopy = this.slice(thisStart, thisEnd)\n var targetCopy = target.slice(start, end)\n\n for (var i = 0; i < len; ++i) {\n if (thisCopy[i] !== targetCopy[i]) {\n x = thisCopy[i]\n y = targetCopy[i]\n break\n }\n }\n\n if (x < y) return -1\n if (y < x) return 1\n return 0\n}\n\n// Finds either the first index of `val` in `buffer` at offset >= `byteOffset`,\n// OR the last index of `val` in `buffer` at offset <= `byteOffset`.\n//\n// Arguments:\n// - buffer - a Buffer to search\n// - val - a string, Buffer, or number\n// - byteOffset - an index into `buffer`; will be clamped to an int32\n// - encoding - an optional encoding, relevant is val is a string\n// - dir - true for indexOf, false for lastIndexOf\nfunction bidirectionalIndexOf (buffer, val, byteOffset, encoding, dir) {\n // Empty buffer means no match\n if (buffer.length === 0) return -1\n\n // Normalize byteOffset\n if (typeof byteOffset === 'string') {\n encoding = byteOffset\n byteOffset = 0\n } else if (byteOffset > 0x7fffffff) {\n byteOffset = 0x7fffffff\n } else if (byteOffset < -0x80000000) {\n byteOffset = -0x80000000\n }\n byteOffset = +byteOffset // Coerce to Number.\n if (isNaN(byteOffset)) {\n // byteOffset: it it's undefined, null, NaN, \"foo\", etc, search whole buffer\n byteOffset = dir ? 0 : (buffer.length - 1)\n }\n\n // Normalize byteOffset: negative offsets start from the end of the buffer\n if (byteOffset < 0) byteOffset = buffer.length + byteOffset\n if (byteOffset >= buffer.length) {\n if (dir) return -1\n else byteOffset = buffer.length - 1\n } else if (byteOffset < 0) {\n if (dir) byteOffset = 0\n else return -1\n }\n\n // Normalize val\n if (typeof val === 'string') {\n val = Buffer.from(val, encoding)\n }\n\n // Finally, search either indexOf (if dir is true) or lastIndexOf\n if (Buffer.isBuffer(val)) {\n // Special case: looking for empty string/buffer always fails\n if (val.length === 0) {\n return -1\n }\n return arrayIndexOf(buffer, val, byteOffset, encoding, dir)\n } else if (typeof val === 'number') {\n val = val & 0xFF // Search for a byte value [0-255]\n if (Buffer.TYPED_ARRAY_SUPPORT &&\n typeof Uint8Array.prototype.indexOf === 'function') {\n if (dir) {\n return Uint8Array.prototype.indexOf.call(buffer, val, byteOffset)\n } else {\n return Uint8Array.prototype.lastIndexOf.call(buffer, val, byteOffset)\n }\n }\n return arrayIndexOf(buffer, [ val ], byteOffset, encoding, dir)\n }\n\n throw new TypeError('val must be string, number or Buffer')\n}\n\nfunction arrayIndexOf (arr, val, byteOffset, encoding, dir) {\n var indexSize = 1\n var arrLength = arr.length\n var valLength = val.length\n\n if (encoding !== undefined) {\n encoding = String(encoding).toLowerCase()\n if (encoding === 'ucs2' || encoding === 'ucs-2' ||\n encoding === 'utf16le' || encoding === 'utf-16le') {\n if (arr.length < 2 || val.length < 2) {\n return -1\n }\n indexSize = 2\n arrLength /= 2\n valLength /= 2\n byteOffset /= 2\n }\n }\n\n function read (buf, i) {\n if (indexSize === 1) {\n return buf[i]\n } else {\n return buf.readUInt16BE(i * indexSize)\n }\n }\n\n var i\n if (dir) {\n var foundIndex = -1\n for (i = byteOffset; i < arrLength; i++) {\n if (read(arr, i) === read(val, foundIndex === -1 ? 0 : i - foundIndex)) {\n if (foundIndex === -1) foundIndex = i\n if (i - foundIndex + 1 === valLength) return foundIndex * indexSize\n } else {\n if (foundIndex !== -1) i -= i - foundIndex\n foundIndex = -1\n }\n }\n } else {\n if (byteOffset + valLength > arrLength) byteOffset = arrLength - valLength\n for (i = byteOffset; i >= 0; i--) {\n var found = true\n for (var j = 0; j < valLength; j++) {\n if (read(arr, i + j) !== read(val, j)) {\n found = false\n break\n }\n }\n if (found) return i\n }\n }\n\n return -1\n}\n\nBuffer.prototype.includes = function includes (val, byteOffset, encoding) {\n return this.indexOf(val, byteOffset, encoding) !== -1\n}\n\nBuffer.prototype.indexOf = function indexOf (val, byteOffset, encoding) {\n return bidirectionalIndexOf(this, val, byteOffset, encoding, true)\n}\n\nBuffer.prototype.lastIndexOf = function lastIndexOf (val, byteOffset, encoding) {\n return bidirectionalIndexOf(this, val, byteOffset, encoding, false)\n}\n\nfunction hexWrite (buf, string, offset, length) {\n offset = Number(offset) || 0\n var remaining = buf.length - offset\n if (!length) {\n length = remaining\n } else {\n length = Number(length)\n if (length > remaining) {\n length = remaining\n }\n }\n\n // must be an even number of digits\n var strLen = string.length\n if (strLen % 2 !== 0) throw new TypeError('Invalid hex string')\n\n if (length > strLen / 2) {\n length = strLen / 2\n }\n for (var i = 0; i < length; ++i) {\n var parsed = parseInt(string.substr(i * 2, 2), 16)\n if (isNaN(parsed)) return i\n buf[offset + i] = parsed\n }\n return i\n}\n\nfunction utf8Write (buf, string, offset, length) {\n return blitBuffer(utf8ToBytes(string, buf.length - offset), buf, offset, length)\n}\n\nfunction asciiWrite (buf, string, offset, length) {\n return blitBuffer(asciiToBytes(string), buf, offset, length)\n}\n\nfunction latin1Write (buf, string, offset, length) {\n return asciiWrite(buf, string, offset, length)\n}\n\nfunction base64Write (buf, string, offset, length) {\n return blitBuffer(base64ToBytes(string), buf, offset, length)\n}\n\nfunction ucs2Write (buf, string, offset, length) {\n return blitBuffer(utf16leToBytes(string, buf.length - offset), buf, offset, length)\n}\n\nBuffer.prototype.write = function write (string, offset, length, encoding) {\n // Buffer#write(string)\n if (offset === undefined) {\n encoding = 'utf8'\n length = this.length\n offset = 0\n // Buffer#write(string, encoding)\n } else if (length === undefined && typeof offset === 'string') {\n encoding = offset\n length = this.length\n offset = 0\n // Buffer#write(string, offset[, length][, encoding])\n } else if (isFinite(offset)) {\n offset = offset | 0\n if (isFinite(length)) {\n length = length | 0\n if (encoding === undefined) encoding = 'utf8'\n } else {\n encoding = length\n length = undefined\n }\n // legacy write(string, encoding, offset, length) - remove in v0.13\n } else {\n throw new Error(\n 'Buffer.write(string, encoding, offset[, length]) is no longer supported'\n )\n }\n\n var remaining = this.length - offset\n if (length === undefined || length > remaining) length = remaining\n\n if ((string.length > 0 && (length < 0 || offset < 0)) || offset > this.length) {\n throw new RangeError('Attempt to write outside buffer bounds')\n }\n\n if (!encoding) encoding = 'utf8'\n\n var loweredCase = false\n for (;;) {\n switch (encoding) {\n case 'hex':\n return hexWrite(this, string, offset, length)\n\n case 'utf8':\n case 'utf-8':\n return utf8Write(this, string, offset, length)\n\n case 'ascii':\n return asciiWrite(this, string, offset, length)\n\n case 'latin1':\n case 'binary':\n return latin1Write(this, string, offset, length)\n\n case 'base64':\n // Warning: maxLength not taken into account in base64Write\n return base64Write(this, string, offset, length)\n\n case 'ucs2':\n case 'ucs-2':\n case 'utf16le':\n case 'utf-16le':\n return ucs2Write(this, string, offset, length)\n\n default:\n if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)\n encoding = ('' + encoding).toLowerCase()\n loweredCase = true\n }\n }\n}\n\nBuffer.prototype.toJSON = function toJSON () {\n return {\n type: 'Buffer',\n data: Array.prototype.slice.call(this._arr || this, 0)\n }\n}\n\nfunction base64Slice (buf, start, end) {\n if (start === 0 && end === buf.length) {\n return base64.fromByteArray(buf)\n } else {\n return base64.fromByteArray(buf.slice(start, end))\n }\n}\n\nfunction utf8Slice (buf, start, end) {\n end = Math.min(buf.length, end)\n var res = []\n\n var i = start\n while (i < end) {\n var firstByte = buf[i]\n var codePoint = null\n var bytesPerSequence = (firstByte > 0xEF) ? 4\n : (firstByte > 0xDF) ? 3\n : (firstByte > 0xBF) ? 2\n : 1\n\n if (i + bytesPerSequence <= end) {\n var secondByte, thirdByte, fourthByte, tempCodePoint\n\n switch (bytesPerSequence) {\n case 1:\n if (firstByte < 0x80) {\n codePoint = firstByte\n }\n break\n case 2:\n secondByte = buf[i + 1]\n if ((secondByte & 0xC0) === 0x80) {\n tempCodePoint = (firstByte & 0x1F) << 0x6 | (secondByte & 0x3F)\n if (tempCodePoint > 0x7F) {\n codePoint = tempCodePoint\n }\n }\n break\n case 3:\n secondByte = buf[i + 1]\n thirdByte = buf[i + 2]\n if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80) {\n tempCodePoint = (firstByte & 0xF) << 0xC | (secondByte & 0x3F) << 0x6 | (thirdByte & 0x3F)\n if (tempCodePoint > 0x7FF && (tempCodePoint < 0xD800 || tempCodePoint > 0xDFFF)) {\n codePoint = tempCodePoint\n }\n }\n break\n case 4:\n secondByte = buf[i + 1]\n thirdByte = buf[i + 2]\n fourthByte = buf[i + 3]\n if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80 && (fourthByte & 0xC0) === 0x80) {\n tempCodePoint = (firstByte & 0xF) << 0x12 | (secondByte & 0x3F) << 0xC | (thirdByte & 0x3F) << 0x6 | (fourthByte & 0x3F)\n if (tempCodePoint > 0xFFFF && tempCodePoint < 0x110000) {\n codePoint = tempCodePoint\n }\n }\n }\n }\n\n if (codePoint === null) {\n // we did not generate a valid codePoint so insert a\n // replacement char (U+FFFD) and advance only 1 byte\n codePoint = 0xFFFD\n bytesPerSequence = 1\n } else if (codePoint > 0xFFFF) {\n // encode to utf16 (surrogate pair dance)\n codePoint -= 0x10000\n res.push(codePoint >>> 10 & 0x3FF | 0xD800)\n codePoint = 0xDC00 | codePoint & 0x3FF\n }\n\n res.push(codePoint)\n i += bytesPerSequence\n }\n\n return decodeCodePointsArray(res)\n}\n\n// Based on http://stackoverflow.com/a/22747272/680742, the browser with\n// the lowest limit is Chrome, with 0x10000 args.\n// We go 1 magnitude less, for safety\nvar MAX_ARGUMENTS_LENGTH = 0x1000\n\nfunction decodeCodePointsArray (codePoints) {\n var len = codePoints.length\n if (len <= MAX_ARGUMENTS_LENGTH) {\n return String.fromCharCode.apply(String, codePoints) // avoid extra slice()\n }\n\n // Decode in chunks to avoid \"call stack size exceeded\".\n var res = ''\n var i = 0\n while (i < len) {\n res += String.fromCharCode.apply(\n String,\n codePoints.slice(i, i += MAX_ARGUMENTS_LENGTH)\n )\n }\n return res\n}\n\nfunction asciiSlice (buf, start, end) {\n var ret = ''\n end = Math.min(buf.length, end)\n\n for (var i = start; i < end; ++i) {\n ret += String.fromCharCode(buf[i] & 0x7F)\n }\n return ret\n}\n\nfunction latin1Slice (buf, start, end) {\n var ret = ''\n end = Math.min(buf.length, end)\n\n for (var i = start; i < end; ++i) {\n ret += String.fromCharCode(buf[i])\n }\n return ret\n}\n\nfunction hexSlice (buf, start, end) {\n var len = buf.length\n\n if (!start || start < 0) start = 0\n if (!end || end < 0 || end > len) end = len\n\n var out = ''\n for (var i = start; i < end; ++i) {\n out += toHex(buf[i])\n }\n return out\n}\n\nfunction utf16leSlice (buf, start, end) {\n var bytes = buf.slice(start, end)\n var res = ''\n for (var i = 0; i < bytes.length; i += 2) {\n res += String.fromCharCode(bytes[i] + bytes[i + 1] * 256)\n }\n return res\n}\n\nBuffer.prototype.slice = function slice (start, end) {\n var len = this.length\n start = ~~start\n end = end === undefined ? len : ~~end\n\n if (start < 0) {\n start += len\n if (start < 0) start = 0\n } else if (start > len) {\n start = len\n }\n\n if (end < 0) {\n end += len\n if (end < 0) end = 0\n } else if (end > len) {\n end = len\n }\n\n if (end < start) end = start\n\n var newBuf\n if (Buffer.TYPED_ARRAY_SUPPORT) {\n newBuf = this.subarray(start, end)\n newBuf.__proto__ = Buffer.prototype\n } else {\n var sliceLen = end - start\n newBuf = new Buffer(sliceLen, undefined)\n for (var i = 0; i < sliceLen; ++i) {\n newBuf[i] = this[i + start]\n }\n }\n\n return newBuf\n}\n\n/*\n * Need to make sure that buffer isn't trying to write out of bounds.\n */\nfunction checkOffset (offset, ext, length) {\n if ((offset % 1) !== 0 || offset < 0) throw new RangeError('offset is not uint')\n if (offset + ext > length) throw new RangeError('Trying to access beyond buffer length')\n}\n\nBuffer.prototype.readUIntLE = function readUIntLE (offset, byteLength, noAssert) {\n offset = offset | 0\n byteLength = byteLength | 0\n if (!noAssert) checkOffset(offset, byteLength, this.length)\n\n var val = this[offset]\n var mul = 1\n var i = 0\n while (++i < byteLength && (mul *= 0x100)) {\n val += this[offset + i] * mul\n }\n\n return val\n}\n\nBuffer.prototype.readUIntBE = function readUIntBE (offset, byteLength, noAssert) {\n offset = offset | 0\n byteLength = byteLength | 0\n if (!noAssert) {\n checkOffset(offset, byteLength, this.length)\n }\n\n var val = this[offset + --byteLength]\n var mul = 1\n while (byteLength > 0 && (mul *= 0x100)) {\n val += this[offset + --byteLength] * mul\n }\n\n return val\n}\n\nBuffer.prototype.readUInt8 = function readUInt8 (offset, noAssert) {\n if (!noAssert) checkOffset(offset, 1, this.length)\n return this[offset]\n}\n\nBuffer.prototype.readUInt16LE = function readUInt16LE (offset, noAssert) {\n if (!noAssert) checkOffset(offset, 2, this.length)\n return this[offset] | (this[offset + 1] << 8)\n}\n\nBuffer.prototype.readUInt16BE = function readUInt16BE (offset, noAssert) {\n if (!noAssert) checkOffset(offset, 2, this.length)\n return (this[offset] << 8) | this[offset + 1]\n}\n\nBuffer.prototype.readUInt32LE = function readUInt32LE (offset, noAssert) {\n if (!noAssert) checkOffset(offset, 4, this.length)\n\n return ((this[offset]) |\n (this[offset + 1] << 8) |\n (this[offset + 2] << 16)) +\n (this[offset + 3] * 0x1000000)\n}\n\nBuffer.prototype.readUInt32BE = function readUInt32BE (offset, noAssert) {\n if (!noAssert) checkOffset(offset, 4, this.length)\n\n return (this[offset] * 0x1000000) +\n ((this[offset + 1] << 16) |\n (this[offset + 2] << 8) |\n this[offset + 3])\n}\n\nBuffer.prototype.readIntLE = function readIntLE (offset, byteLength, noAssert) {\n offset = offset | 0\n byteLength = byteLength | 0\n if (!noAssert) checkOffset(offset, byteLength, this.length)\n\n var val = this[offset]\n var mul = 1\n var i = 0\n while (++i < byteLength && (mul *= 0x100)) {\n val += this[offset + i] * mul\n }\n mul *= 0x80\n\n if (val >= mul) val -= Math.pow(2, 8 * byteLength)\n\n return val\n}\n\nBuffer.prototype.readIntBE = function readIntBE (offset, byteLength, noAssert) {\n offset = offset | 0\n byteLength = byteLength | 0\n if (!noAssert) checkOffset(offset, byteLength, this.length)\n\n var i = byteLength\n var mul = 1\n var val = this[offset + --i]\n while (i > 0 && (mul *= 0x100)) {\n val += this[offset + --i] * mul\n }\n mul *= 0x80\n\n if (val >= mul) val -= Math.pow(2, 8 * byteLength)\n\n return val\n}\n\nBuffer.prototype.readInt8 = function readInt8 (offset, noAssert) {\n if (!noAssert) checkOffset(offset, 1, this.length)\n if (!(this[offset] & 0x80)) return (this[offset])\n return ((0xff - this[offset] + 1) * -1)\n}\n\nBuffer.prototype.readInt16LE = function readInt16LE (offset, noAssert) {\n if (!noAssert) checkOffset(offset, 2, this.length)\n var val = this[offset] | (this[offset + 1] << 8)\n return (val & 0x8000) ? val | 0xFFFF0000 : val\n}\n\nBuffer.prototype.readInt16BE = function readInt16BE (offset, noAssert) {\n if (!noAssert) checkOffset(offset, 2, this.length)\n var val = this[offset + 1] | (this[offset] << 8)\n return (val & 0x8000) ? val | 0xFFFF0000 : val\n}\n\nBuffer.prototype.readInt32LE = function readInt32LE (offset, noAssert) {\n if (!noAssert) checkOffset(offset, 4, this.length)\n\n return (this[offset]) |\n (this[offset + 1] << 8) |\n (this[offset + 2] << 16) |\n (this[offset + 3] << 24)\n}\n\nBuffer.prototype.readInt32BE = function readInt32BE (offset, noAssert) {\n if (!noAssert) checkOffset(offset, 4, this.length)\n\n return (this[offset] << 24) |\n (this[offset + 1] << 16) |\n (this[offset + 2] << 8) |\n (this[offset + 3])\n}\n\nBuffer.prototype.readFloatLE = function readFloatLE (offset, noAssert) {\n if (!noAssert) checkOffset(offset, 4, this.length)\n return ieee754.read(this, offset, true, 23, 4)\n}\n\nBuffer.prototype.readFloatBE = function readFloatBE (offset, noAssert) {\n if (!noAssert) checkOffset(offset, 4, this.length)\n return ieee754.read(this, offset, false, 23, 4)\n}\n\nBuffer.prototype.readDoubleLE = function readDoubleLE (offset, noAssert) {\n if (!noAssert) checkOffset(offset, 8, this.length)\n return ieee754.read(this, offset, true, 52, 8)\n}\n\nBuffer.prototype.readDoubleBE = function readDoubleBE (offset, noAssert) {\n if (!noAssert) checkOffset(offset, 8, this.length)\n return ieee754.read(this, offset, false, 52, 8)\n}\n\nfunction checkInt (buf, value, offset, ext, max, min) {\n if (!Buffer.isBuffer(buf)) throw new TypeError('\"buffer\" argument must be a Buffer instance')\n if (value > max || value < min) throw new RangeError('\"value\" argument is out of bounds')\n if (offset + ext > buf.length) throw new RangeError('Index out of range')\n}\n\nBuffer.prototype.writeUIntLE = function writeUIntLE (value, offset, byteLength, noAssert) {\n value = +value\n offset = offset | 0\n byteLength = byteLength | 0\n if (!noAssert) {\n var maxBytes = Math.pow(2, 8 * byteLength) - 1\n checkInt(this, value, offset, byteLength, maxBytes, 0)\n }\n\n var mul = 1\n var i = 0\n this[offset] = value & 0xFF\n while (++i < byteLength && (mul *= 0x100)) {\n this[offset + i] = (value / mul) & 0xFF\n }\n\n return offset + byteLength\n}\n\nBuffer.prototype.writeUIntBE = function writeUIntBE (value, offset, byteLength, noAssert) {\n value = +value\n offset = offset | 0\n byteLength = byteLength | 0\n if (!noAssert) {\n var maxBytes = Math.pow(2, 8 * byteLength) - 1\n checkInt(this, value, offset, byteLength, maxBytes, 0)\n }\n\n var i = byteLength - 1\n var mul = 1\n this[offset + i] = value & 0xFF\n while (--i >= 0 && (mul *= 0x100)) {\n this[offset + i] = (value / mul) & 0xFF\n }\n\n return offset + byteLength\n}\n\nBuffer.prototype.writeUInt8 = function writeUInt8 (value, offset, noAssert) {\n value = +value\n offset = offset | 0\n if (!noAssert) checkInt(this, value, offset, 1, 0xff, 0)\n if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value)\n this[offset] = (value & 0xff)\n return offset + 1\n}\n\nfunction objectWriteUInt16 (buf, value, offset, littleEndian) {\n if (value < 0) value = 0xffff + value + 1\n for (var i = 0, j = Math.min(buf.length - offset, 2); i < j; ++i) {\n buf[offset + i] = (value & (0xff << (8 * (littleEndian ? i : 1 - i)))) >>>\n (littleEndian ? i : 1 - i) * 8\n }\n}\n\nBuffer.prototype.writeUInt16LE = function writeUInt16LE (value, offset, noAssert) {\n value = +value\n offset = offset | 0\n if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)\n if (Buffer.TYPED_ARRAY_SUPPORT) {\n this[offset] = (value & 0xff)\n this[offset + 1] = (value >>> 8)\n } else {\n objectWriteUInt16(this, value, offset, true)\n }\n return offset + 2\n}\n\nBuffer.prototype.writeUInt16BE = function writeUInt16BE (value, offset, noAssert) {\n value = +value\n offset = offset | 0\n if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)\n if (Buffer.TYPED_ARRAY_SUPPORT) {\n this[offset] = (value >>> 8)\n this[offset + 1] = (value & 0xff)\n } else {\n objectWriteUInt16(this, value, offset, false)\n }\n return offset + 2\n}\n\nfunction objectWriteUInt32 (buf, value, offset, littleEndian) {\n if (value < 0) value = 0xffffffff + value + 1\n for (var i = 0, j = Math.min(buf.length - offset, 4); i < j; ++i) {\n buf[offset + i] = (value >>> (littleEndian ? i : 3 - i) * 8) & 0xff\n }\n}\n\nBuffer.prototype.writeUInt32LE = function writeUInt32LE (value, offset, noAssert) {\n value = +value\n offset = offset | 0\n if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)\n if (Buffer.TYPED_ARRAY_SUPPORT) {\n this[offset + 3] = (value >>> 24)\n this[offset + 2] = (value >>> 16)\n this[offset + 1] = (value >>> 8)\n this[offset] = (value & 0xff)\n } else {\n objectWriteUInt32(this, value, offset, true)\n }\n return offset + 4\n}\n\nBuffer.prototype.writeUInt32BE = function writeUInt32BE (value, offset, noAssert) {\n value = +value\n offset = offset | 0\n if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)\n if (Buffer.TYPED_ARRAY_SUPPORT) {\n this[offset] = (value >>> 24)\n this[offset + 1] = (value >>> 16)\n this[offset + 2] = (value >>> 8)\n this[offset + 3] = (value & 0xff)\n } else {\n objectWriteUInt32(this, value, offset, false)\n }\n return offset + 4\n}\n\nBuffer.prototype.writeIntLE = function writeIntLE (value, offset, byteLength, noAssert) {\n value = +value\n offset = offset | 0\n if (!noAssert) {\n var limit = Math.pow(2, 8 * byteLength - 1)\n\n checkInt(this, value, offset, byteLength, limit - 1, -limit)\n }\n\n var i = 0\n var mul = 1\n var sub = 0\n this[offset] = value & 0xFF\n while (++i < byteLength && (mul *= 0x100)) {\n if (value < 0 && sub === 0 && this[offset + i - 1] !== 0) {\n sub = 1\n }\n this[offset + i] = ((value / mul) >> 0) - sub & 0xFF\n }\n\n return offset + byteLength\n}\n\nBuffer.prototype.writeIntBE = function writeIntBE (value, offset, byteLength, noAssert) {\n value = +value\n offset = offset | 0\n if (!noAssert) {\n var limit = Math.pow(2, 8 * byteLength - 1)\n\n checkInt(this, value, offset, byteLength, limit - 1, -limit)\n }\n\n var i = byteLength - 1\n var mul = 1\n var sub = 0\n this[offset + i] = value & 0xFF\n while (--i >= 0 && (mul *= 0x100)) {\n if (value < 0 && sub === 0 && this[offset + i + 1] !== 0) {\n sub = 1\n }\n this[offset + i] = ((value / mul) >> 0) - sub & 0xFF\n }\n\n return offset + byteLength\n}\n\nBuffer.prototype.writeInt8 = function writeInt8 (value, offset, noAssert) {\n value = +value\n offset = offset | 0\n if (!noAssert) checkInt(this, value, offset, 1, 0x7f, -0x80)\n if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value)\n if (value < 0) value = 0xff + value + 1\n this[offset] = (value & 0xff)\n return offset + 1\n}\n\nBuffer.prototype.writeInt16LE = function writeInt16LE (value, offset, noAssert) {\n value = +value\n offset = offset | 0\n if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000)\n if (Buffer.TYPED_ARRAY_SUPPORT) {\n this[offset] = (value & 0xff)\n this[offset + 1] = (value >>> 8)\n } else {\n objectWriteUInt16(this, value, offset, true)\n }\n return offset + 2\n}\n\nBuffer.prototype.writeInt16BE = function writeInt16BE (value, offset, noAssert) {\n value = +value\n offset = offset | 0\n if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000)\n if (Buffer.TYPED_ARRAY_SUPPORT) {\n this[offset] = (value >>> 8)\n this[offset + 1] = (value & 0xff)\n } else {\n objectWriteUInt16(this, value, offset, false)\n }\n return offset + 2\n}\n\nBuffer.prototype.writeInt32LE = function writeInt32LE (value, offset, noAssert) {\n value = +value\n offset = offset | 0\n if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)\n if (Buffer.TYPED_ARRAY_SUPPORT) {\n this[offset] = (value & 0xff)\n this[offset + 1] = (value >>> 8)\n this[offset + 2] = (value >>> 16)\n this[offset + 3] = (value >>> 24)\n } else {\n objectWriteUInt32(this, value, offset, true)\n }\n return offset + 4\n}\n\nBuffer.prototype.writeInt32BE = function writeInt32BE (value, offset, noAssert) {\n value = +value\n offset = offset | 0\n if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)\n if (value < 0) value = 0xffffffff + value + 1\n if (Buffer.TYPED_ARRAY_SUPPORT) {\n this[offset] = (value >>> 24)\n this[offset + 1] = (value >>> 16)\n this[offset + 2] = (value >>> 8)\n this[offset + 3] = (value & 0xff)\n } else {\n objectWriteUInt32(this, value, offset, false)\n }\n return offset + 4\n}\n\nfunction checkIEEE754 (buf, value, offset, ext, max, min) {\n if (offset + ext > buf.length) throw new RangeError('Index out of range')\n if (offset < 0) throw new RangeError('Index out of range')\n}\n\nfunction writeFloat (buf, value, offset, littleEndian, noAssert) {\n if (!noAssert) {\n checkIEEE754(buf, value, offset, 4, 3.4028234663852886e+38, -3.4028234663852886e+38)\n }\n ieee754.write(buf, value, offset, littleEndian, 23, 4)\n return offset + 4\n}\n\nBuffer.prototype.writeFloatLE = function writeFloatLE (value, offset, noAssert) {\n return writeFloat(this, value, offset, true, noAssert)\n}\n\nBuffer.prototype.writeFloatBE = function writeFloatBE (value, offset, noAssert) {\n return writeFloat(this, value, offset, false, noAssert)\n}\n\nfunction writeDouble (buf, value, offset, littleEndian, noAssert) {\n if (!noAssert) {\n checkIEEE754(buf, value, offset, 8, 1.7976931348623157E+308, -1.7976931348623157E+308)\n }\n ieee754.write(buf, value, offset, littleEndian, 52, 8)\n return offset + 8\n}\n\nBuffer.prototype.writeDoubleLE = function writeDoubleLE (value, offset, noAssert) {\n return writeDouble(this, value, offset, true, noAssert)\n}\n\nBuffer.prototype.writeDoubleBE = function writeDoubleBE (value, offset, noAssert) {\n return writeDouble(this, value, offset, false, noAssert)\n}\n\n// copy(targetBuffer, targetStart=0, sourceStart=0, sourceEnd=buffer.length)\nBuffer.prototype.copy = function copy (target, targetStart, start, end) {\n if (!start) start = 0\n if (!end && end !== 0) end = this.length\n if (targetStart >= target.length) targetStart = target.length\n if (!targetStart) targetStart = 0\n if (end > 0 && end < start) end = start\n\n // Copy 0 bytes; we're done\n if (end === start) return 0\n if (target.length === 0 || this.length === 0) return 0\n\n // Fatal error conditions\n if (targetStart < 0) {\n throw new RangeError('targetStart out of bounds')\n }\n if (start < 0 || start >= this.length) throw new RangeError('sourceStart out of bounds')\n if (end < 0) throw new RangeError('sourceEnd out of bounds')\n\n // Are we oob?\n if (end > this.length) end = this.length\n if (target.length - targetStart < end - start) {\n end = target.length - targetStart + start\n }\n\n var len = end - start\n var i\n\n if (this === target && start < targetStart && targetStart < end) {\n // descending copy from end\n for (i = len - 1; i >= 0; --i) {\n target[i + targetStart] = this[i + start]\n }\n } else if (len < 1000 || !Buffer.TYPED_ARRAY_SUPPORT) {\n // ascending copy from start\n for (i = 0; i < len; ++i) {\n target[i + targetStart] = this[i + start]\n }\n } else {\n Uint8Array.prototype.set.call(\n target,\n this.subarray(start, start + len),\n targetStart\n )\n }\n\n return len\n}\n\n// Usage:\n// buffer.fill(number[, offset[, end]])\n// buffer.fill(buffer[, offset[, end]])\n// buffer.fill(string[, offset[, end]][, encoding])\nBuffer.prototype.fill = function fill (val, start, end, encoding) {\n // Handle string cases:\n if (typeof val === 'string') {\n if (typeof start === 'string') {\n encoding = start\n start = 0\n end = this.length\n } else if (typeof end === 'string') {\n encoding = end\n end = this.length\n }\n if (val.length === 1) {\n var code = val.charCodeAt(0)\n if (code < 256) {\n val = code\n }\n }\n if (encoding !== undefined && typeof encoding !== 'string') {\n throw new TypeError('encoding must be a string')\n }\n if (typeof encoding === 'string' && !Buffer.isEncoding(encoding)) {\n throw new TypeError('Unknown encoding: ' + encoding)\n }\n } else if (typeof val === 'number') {\n val = val & 255\n }\n\n // Invalid ranges are not set to a default, so can range check early.\n if (start < 0 || this.length < start || this.length < end) {\n throw new RangeError('Out of range index')\n }\n\n if (end <= start) {\n return this\n }\n\n start = start >>> 0\n end = end === undefined ? this.length : end >>> 0\n\n if (!val) val = 0\n\n var i\n if (typeof val === 'number') {\n for (i = start; i < end; ++i) {\n this[i] = val\n }\n } else {\n var bytes = Buffer.isBuffer(val)\n ? val\n : utf8ToBytes(new Buffer(val, encoding).toString())\n var len = bytes.length\n for (i = 0; i < end - start; ++i) {\n this[i + start] = bytes[i % len]\n }\n }\n\n return this\n}\n\n// HELPER FUNCTIONS\n// ================\n\nvar INVALID_BASE64_RE = /[^+\\/0-9A-Za-z-_]/g\n\nfunction base64clean (str) {\n // Node strips out invalid characters like \\n and \\t from the string, base64-js does not\n str = stringtrim(str).replace(INVALID_BASE64_RE, '')\n // Node converts strings with length < 2 to ''\n if (str.length < 2) return ''\n // Node allows for non-padded base64 strings (missing trailing ===), base64-js does not\n while (str.length % 4 !== 0) {\n str = str + '='\n }\n return str\n}\n\nfunction stringtrim (str) {\n if (str.trim) return str.trim()\n return str.replace(/^\\s+|\\s+$/g, '')\n}\n\nfunction toHex (n) {\n if (n < 16) return '0' + n.toString(16)\n return n.toString(16)\n}\n\nfunction utf8ToBytes (string, units) {\n units = units || Infinity\n var codePoint\n var length = string.length\n var leadSurrogate = null\n var bytes = []\n\n for (var i = 0; i < length; ++i) {\n codePoint = string.charCodeAt(i)\n\n // is surrogate component\n if (codePoint > 0xD7FF && codePoint < 0xE000) {\n // last char was a lead\n if (!leadSurrogate) {\n // no lead yet\n if (codePoint > 0xDBFF) {\n // unexpected trail\n if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n continue\n } else if (i + 1 === length) {\n // unpaired lead\n if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n continue\n }\n\n // valid lead\n leadSurrogate = codePoint\n\n continue\n }\n\n // 2 leads in a row\n if (codePoint < 0xDC00) {\n if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n leadSurrogate = codePoint\n continue\n }\n\n // valid surrogate pair\n codePoint = (leadSurrogate - 0xD800 << 10 | codePoint - 0xDC00) + 0x10000\n } else if (leadSurrogate) {\n // valid bmp char, but last char was a lead\n if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n }\n\n leadSurrogate = null\n\n // encode utf8\n if (codePoint < 0x80) {\n if ((units -= 1) < 0) break\n bytes.push(codePoint)\n } else if (codePoint < 0x800) {\n if ((units -= 2) < 0) break\n bytes.push(\n codePoint >> 0x6 | 0xC0,\n codePoint & 0x3F | 0x80\n )\n } else if (codePoint < 0x10000) {\n if ((units -= 3) < 0) break\n bytes.push(\n codePoint >> 0xC | 0xE0,\n codePoint >> 0x6 & 0x3F | 0x80,\n codePoint & 0x3F | 0x80\n )\n } else if (codePoint < 0x110000) {\n if ((units -= 4) < 0) break\n bytes.push(\n codePoint >> 0x12 | 0xF0,\n codePoint >> 0xC & 0x3F | 0x80,\n codePoint >> 0x6 & 0x3F | 0x80,\n codePoint & 0x3F | 0x80\n )\n } else {\n throw new Error('Invalid code point')\n }\n }\n\n return bytes\n}\n\nfunction asciiToBytes (str) {\n var byteArray = []\n for (var i = 0; i < str.length; ++i) {\n // Node's code seems to be doing this and not & 0x7F..\n byteArray.push(str.charCodeAt(i) & 0xFF)\n }\n return byteArray\n}\n\nfunction utf16leToBytes (str, units) {\n var c, hi, lo\n var byteArray = []\n for (var i = 0; i < str.length; ++i) {\n if ((units -= 2) < 0) break\n\n c = str.charCodeAt(i)\n hi = c >> 8\n lo = c % 256\n byteArray.push(lo)\n byteArray.push(hi)\n }\n\n return byteArray\n}\n\nfunction base64ToBytes (str) {\n return base64.toByteArray(base64clean(str))\n}\n\nfunction blitBuffer (src, dst, offset, length) {\n for (var i = 0; i < length; ++i) {\n if ((i + offset >= dst.length) || (i >= src.length)) break\n dst[i + offset] = src[i]\n }\n return i\n}\n\nfunction isnan (val) {\n return val !== val // eslint-disable-line no-self-compare\n}\n","/**\n * This is the web browser implementation of `debug()`.\n *\n * Expose `debug()` as the module.\n */\n\nexports = module.exports = require('./debug');\nexports.log = log;\nexports.formatArgs = formatArgs;\nexports.save = save;\nexports.load = load;\nexports.useColors = useColors;\nexports.storage = 'undefined' != typeof chrome\n && 'undefined' != typeof chrome.storage\n ? chrome.storage.local\n : localstorage();\n\n/**\n * Colors.\n */\n\nexports.colors = [\n 'lightseagreen',\n 'forestgreen',\n 'goldenrod',\n 'dodgerblue',\n 'darkorchid',\n 'crimson'\n];\n\n/**\n * Currently only WebKit-based Web Inspectors, Firefox >= v31,\n * and the Firebug extension (any Firefox version) are known\n * to support \"%c\" CSS customizations.\n *\n * TODO: add a `localStorage` variable to explicitly enable/disable colors\n */\n\nfunction useColors() {\n // NB: In an Electron preload script, document will be defined but not fully\n // initialized. Since we know we're in Chrome, we'll just detect this case\n // explicitly\n if (typeof window !== 'undefined' && window && typeof window.process !== 'undefined' && window.process.type === 'renderer') {\n return true;\n }\n\n // is webkit? http://stackoverflow.com/a/16459606/376773\n // document is undefined in react-native: https://github.com/facebook/react-native/pull/1632\n return (typeof document !== 'undefined' && document && 'WebkitAppearance' in document.documentElement.style) ||\n // is firebug? http://stackoverflow.com/a/398120/376773\n (typeof window !== 'undefined' && window && window.console && (console.firebug || (console.exception && console.table))) ||\n // is firefox >= v31?\n // https://developer.mozilla.org/en-US/docs/Tools/Web_Console#Styling_messages\n (typeof navigator !== 'undefined' && navigator && navigator.userAgent && navigator.userAgent.toLowerCase().match(/firefox\\/(\\d+)/) && parseInt(RegExp.$1, 10) >= 31) ||\n // double check webkit in userAgent just in case we are in a worker\n (typeof navigator !== 'undefined' && navigator && navigator.userAgent && navigator.userAgent.toLowerCase().match(/applewebkit\\/(\\d+)/));\n}\n\n/**\n * Map %j to `JSON.stringify()`, since no Web Inspectors do that by default.\n */\n\nexports.formatters.j = function(v) {\n try {\n return JSON.stringify(v);\n } catch (err) {\n return '[UnexpectedJSONParseError]: ' + err.message;\n }\n};\n\n\n/**\n * Colorize log arguments if enabled.\n *\n * @api public\n */\n\nfunction formatArgs(args) {\n var useColors = this.useColors;\n\n args[0] = (useColors ? '%c' : '')\n + this.namespace\n + (useColors ? ' %c' : ' ')\n + args[0]\n + (useColors ? '%c ' : ' ')\n + '+' + exports.humanize(this.diff);\n\n if (!useColors) return;\n\n var c = 'color: ' + this.color;\n args.splice(1, 0, c, 'color: inherit')\n\n // the final \"%c\" is somewhat tricky, because there could be other\n // arguments passed either before or after the %c, so we need to\n // figure out the correct index to insert the CSS into\n var index = 0;\n var lastC = 0;\n args[0].replace(/%[a-zA-Z%]/g, function(match) {\n if ('%%' === match) return;\n index++;\n if ('%c' === match) {\n // we only are interested in the *last* %c\n // (the user may have provided their own)\n lastC = index;\n }\n });\n\n args.splice(lastC, 0, c);\n}\n\n/**\n * Invokes `console.log()` when available.\n * No-op when `console.log` is not a \"function\".\n *\n * @api public\n */\n\nfunction log() {\n // this hackery is required for IE8/9, where\n // the `console.log` function doesn't have 'apply'\n return 'object' === typeof console\n && console.log\n && Function.prototype.apply.call(console.log, console, arguments);\n}\n\n/**\n * Save `namespaces`.\n *\n * @param {String} namespaces\n * @api private\n */\n\nfunction save(namespaces) {\n try {\n if (null == namespaces) {\n exports.storage.removeItem('debug');\n } else {\n exports.storage.debug = namespaces;\n }\n } catch(e) {}\n}\n\n/**\n * Load `namespaces`.\n *\n * @return {String} returns the previously persisted debug modes\n * @api private\n */\n\nfunction load() {\n try {\n return exports.storage.debug;\n } catch(e) {}\n\n // If debug isn't set in LS, and we're in Electron, try to load $DEBUG\n if (typeof process !== 'undefined' && 'env' in process) {\n return process.env.DEBUG;\n }\n}\n\n/**\n * Enable namespaces listed in `localStorage.debug` initially.\n */\n\nexports.enable(load());\n\n/**\n * Localstorage attempts to return the localstorage.\n *\n * This is necessary because safari throws\n * when a user disables cookies/localstorage\n * and you attempt to access it.\n *\n * @return {LocalStorage}\n * @api private\n */\n\nfunction localstorage() {\n try {\n return window.localStorage;\n } catch (e) {}\n}\n","\n/**\n * This is the common logic for both the Node.js and web browser\n * implementations of `debug()`.\n *\n * Expose `debug()` as the module.\n */\n\nexports = module.exports = createDebug.debug = createDebug.default = createDebug;\nexports.coerce = coerce;\nexports.disable = disable;\nexports.enable = enable;\nexports.enabled = enabled;\nexports.humanize = require('ms');\n\n/**\n * The currently active debug mode names, and names to skip.\n */\n\nexports.names = [];\nexports.skips = [];\n\n/**\n * Map of special \"%n\" handling functions, for the debug \"format\" argument.\n *\n * Valid key names are a single, lower or upper-case letter, i.e. \"n\" and \"N\".\n */\n\nexports.formatters = {};\n\n/**\n * Previous log timestamp.\n */\n\nvar prevTime;\n\n/**\n * Select a color.\n * @param {String} namespace\n * @return {Number}\n * @api private\n */\n\nfunction selectColor(namespace) {\n var hash = 0, i;\n\n for (i in namespace) {\n hash = ((hash << 5) - hash) + namespace.charCodeAt(i);\n hash |= 0; // Convert to 32bit integer\n }\n\n return exports.colors[Math.abs(hash) % exports.colors.length];\n}\n\n/**\n * Create a debugger with the given `namespace`.\n *\n * @param {String} namespace\n * @return {Function}\n * @api public\n */\n\nfunction createDebug(namespace) {\n\n function debug() {\n // disabled?\n if (!debug.enabled) return;\n\n var self = debug;\n\n // set `diff` timestamp\n var curr = +new Date();\n var ms = curr - (prevTime || curr);\n self.diff = ms;\n self.prev = prevTime;\n self.curr = curr;\n prevTime = curr;\n\n // turn the `arguments` into a proper Array\n var args = new Array(arguments.length);\n for (var i = 0; i < args.length; i++) {\n args[i] = arguments[i];\n }\n\n args[0] = exports.coerce(args[0]);\n\n if ('string' !== typeof args[0]) {\n // anything else let's inspect with %O\n args.unshift('%O');\n }\n\n // apply any `formatters` transformations\n var index = 0;\n args[0] = args[0].replace(/%([a-zA-Z%])/g, function(match, format) {\n // if we encounter an escaped % then don't increase the array index\n if (match === '%%') return match;\n index++;\n var formatter = exports.formatters[format];\n if ('function' === typeof formatter) {\n var val = args[index];\n match = formatter.call(self, val);\n\n // now we need to remove `args[index]` since it's inlined in the `format`\n args.splice(index, 1);\n index--;\n }\n return match;\n });\n\n // apply env-specific formatting (colors, etc.)\n exports.formatArgs.call(self, args);\n\n var logFn = debug.log || exports.log || console.log.bind(console);\n logFn.apply(self, args);\n }\n\n debug.namespace = namespace;\n debug.enabled = exports.enabled(namespace);\n debug.useColors = exports.useColors();\n debug.color = selectColor(namespace);\n\n // env-specific initialization logic for debug instances\n if ('function' === typeof exports.init) {\n exports.init(debug);\n }\n\n return debug;\n}\n\n/**\n * Enables a debug mode by namespaces. This can include modes\n * separated by a colon and wildcards.\n *\n * @param {String} namespaces\n * @api public\n */\n\nfunction enable(namespaces) {\n exports.save(namespaces);\n\n var split = (namespaces || '').split(/[\\s,]+/);\n var len = split.length;\n\n for (var i = 0; i < len; i++) {\n if (!split[i]) continue; // ignore empty strings\n namespaces = split[i].replace(/\\*/g, '.*?');\n if (namespaces[0] === '-') {\n exports.skips.push(new RegExp('^' + namespaces.substr(1) + '$'));\n } else {\n exports.names.push(new RegExp('^' + namespaces + '$'));\n }\n }\n}\n\n/**\n * Disable debug output.\n *\n * @api public\n */\n\nfunction disable() {\n exports.enable('');\n}\n\n/**\n * Returns true if the given mode name is enabled, false otherwise.\n *\n * @param {String} name\n * @return {Boolean}\n * @api public\n */\n\nfunction enabled(name) {\n var i, len;\n for (i = 0, len = exports.skips.length; i < len; i++) {\n if (exports.skips[i].test(name)) {\n return false;\n }\n }\n for (i = 0, len = exports.names.length; i < len; i++) {\n if (exports.names[i].test(name)) {\n return true;\n }\n }\n return false;\n}\n\n/**\n * Coerce `val`.\n *\n * @param {Mixed} val\n * @return {Mixed}\n * @api private\n */\n\nfunction coerce(val) {\n if (val instanceof Error) return val.stack || val.message;\n return val;\n}\n","exports.read = function (buffer, offset, isLE, mLen, nBytes) {\n var e, m\n var eLen = nBytes * 8 - mLen - 1\n var eMax = (1 << eLen) - 1\n var eBias = eMax >> 1\n var nBits = -7\n var i = isLE ? (nBytes - 1) : 0\n var d = isLE ? -1 : 1\n var s = buffer[offset + i]\n\n i += d\n\n e = s & ((1 << (-nBits)) - 1)\n s >>= (-nBits)\n nBits += eLen\n for (; nBits > 0; e = e * 256 + buffer[offset + i], i += d, nBits -= 8) {}\n\n m = e & ((1 << (-nBits)) - 1)\n e >>= (-nBits)\n nBits += mLen\n for (; nBits > 0; m = m * 256 + buffer[offset + i], i += d, nBits -= 8) {}\n\n if (e === 0) {\n e = 1 - eBias\n } else if (e === eMax) {\n return m ? NaN : ((s ? -1 : 1) * Infinity)\n } else {\n m = m + Math.pow(2, mLen)\n e = e - eBias\n }\n return (s ? -1 : 1) * m * Math.pow(2, e - mLen)\n}\n\nexports.write = function (buffer, value, offset, isLE, mLen, nBytes) {\n var e, m, c\n var eLen = nBytes * 8 - mLen - 1\n var eMax = (1 << eLen) - 1\n var eBias = eMax >> 1\n var rt = (mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0)\n var i = isLE ? 0 : (nBytes - 1)\n var d = isLE ? 1 : -1\n var s = value < 0 || (value === 0 && 1 / value < 0) ? 1 : 0\n\n value = Math.abs(value)\n\n if (isNaN(value) || value === Infinity) {\n m = isNaN(value) ? 1 : 0\n e = eMax\n } else {\n e = Math.floor(Math.log(value) / Math.LN2)\n if (value * (c = Math.pow(2, -e)) < 1) {\n e--\n c *= 2\n }\n if (e + eBias >= 1) {\n value += rt / c\n } else {\n value += rt * Math.pow(2, 1 - eBias)\n }\n if (value * c >= 2) {\n e++\n c /= 2\n }\n\n if (e + eBias >= eMax) {\n m = 0\n e = eMax\n } else if (e + eBias >= 1) {\n m = (value * c - 1) * Math.pow(2, mLen)\n e = e + eBias\n } else {\n m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen)\n e = 0\n }\n }\n\n for (; mLen >= 8; buffer[offset + i] = m & 0xff, i += d, m /= 256, mLen -= 8) {}\n\n e = (e << mLen) | m\n eLen += mLen\n for (; eLen > 0; buffer[offset + i] = e & 0xff, i += d, e /= 256, eLen -= 8) {}\n\n buffer[offset + i - d] |= s * 128\n}\n","var toString = {}.toString;\n\nmodule.exports = Array.isArray || function (arr) {\n return toString.call(arr) == '[object Array]';\n};\n","/*\n * $Id: base64.js,v 2.15 2014/04/05 12:58:57 dankogai Exp dankogai $\n *\n * Licensed under the MIT license.\n * http://opensource.org/licenses/mit-license\n *\n * References:\n * http://en.wikipedia.org/wiki/Base64\n */\n\n(function(global) {\n 'use strict';\n // existing version for noConflict()\n var _Base64 = global.Base64;\n var version = \"2.1.9\";\n // if node.js, we use Buffer\n var buffer;\n if (typeof module !== 'undefined' && module.exports) {\n try {\n buffer = require('buffer').Buffer;\n } catch (err) {}\n }\n // constants\n var b64chars\n = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';\n var b64tab = function(bin) {\n var t = {};\n for (var i = 0, l = bin.length; i < l; i++) t[bin.charAt(i)] = i;\n return t;\n }(b64chars);\n var fromCharCode = String.fromCharCode;\n // encoder stuff\n var cb_utob = function(c) {\n if (c.length < 2) {\n var cc = c.charCodeAt(0);\n return cc < 0x80 ? c\n : cc < 0x800 ? (fromCharCode(0xc0 | (cc >>> 6))\n + fromCharCode(0x80 | (cc & 0x3f)))\n : (fromCharCode(0xe0 | ((cc >>> 12) & 0x0f))\n + fromCharCode(0x80 | ((cc >>> 6) & 0x3f))\n + fromCharCode(0x80 | ( cc & 0x3f)));\n } else {\n var cc = 0x10000\n + (c.charCodeAt(0) - 0xD800) * 0x400\n + (c.charCodeAt(1) - 0xDC00);\n return (fromCharCode(0xf0 | ((cc >>> 18) & 0x07))\n + fromCharCode(0x80 | ((cc >>> 12) & 0x3f))\n + fromCharCode(0x80 | ((cc >>> 6) & 0x3f))\n + fromCharCode(0x80 | ( cc & 0x3f)));\n }\n };\n var re_utob = /[\\uD800-\\uDBFF][\\uDC00-\\uDFFFF]|[^\\x00-\\x7F]/g;\n var utob = function(u) {\n return u.replace(re_utob, cb_utob);\n };\n var cb_encode = function(ccc) {\n var padlen = [0, 2, 1][ccc.length % 3],\n ord = ccc.charCodeAt(0) << 16\n | ((ccc.length > 1 ? ccc.charCodeAt(1) : 0) << 8)\n | ((ccc.length > 2 ? ccc.charCodeAt(2) : 0)),\n chars = [\n b64chars.charAt( ord >>> 18),\n b64chars.charAt((ord >>> 12) & 63),\n padlen >= 2 ? '=' : b64chars.charAt((ord >>> 6) & 63),\n padlen >= 1 ? '=' : b64chars.charAt(ord & 63)\n ];\n return chars.join('');\n };\n var btoa = global.btoa ? function(b) {\n return global.btoa(b);\n } : function(b) {\n return b.replace(/[\\s\\S]{1,3}/g, cb_encode);\n };\n var _encode = buffer ? function (u) {\n return (u.constructor === buffer.constructor ? u : new buffer(u))\n .toString('base64')\n }\n : function (u) { return btoa(utob(u)) }\n ;\n var encode = function(u, urisafe) {\n return !urisafe\n ? _encode(String(u))\n : _encode(String(u)).replace(/[+\\/]/g, function(m0) {\n return m0 == '+' ? '-' : '_';\n }).replace(/=/g, '');\n };\n var encodeURI = function(u) { return encode(u, true) };\n // decoder stuff\n var re_btou = new RegExp([\n '[\\xC0-\\xDF][\\x80-\\xBF]',\n '[\\xE0-\\xEF][\\x80-\\xBF]{2}',\n '[\\xF0-\\xF7][\\x80-\\xBF]{3}'\n ].join('|'), 'g');\n var cb_btou = function(cccc) {\n switch(cccc.length) {\n case 4:\n var cp = ((0x07 & cccc.charCodeAt(0)) << 18)\n | ((0x3f & cccc.charCodeAt(1)) << 12)\n | ((0x3f & cccc.charCodeAt(2)) << 6)\n | (0x3f & cccc.charCodeAt(3)),\n offset = cp - 0x10000;\n return (fromCharCode((offset >>> 10) + 0xD800)\n + fromCharCode((offset & 0x3FF) + 0xDC00));\n case 3:\n return fromCharCode(\n ((0x0f & cccc.charCodeAt(0)) << 12)\n | ((0x3f & cccc.charCodeAt(1)) << 6)\n | (0x3f & cccc.charCodeAt(2))\n );\n default:\n return fromCharCode(\n ((0x1f & cccc.charCodeAt(0)) << 6)\n | (0x3f & cccc.charCodeAt(1))\n );\n }\n };\n var btou = function(b) {\n return b.replace(re_btou, cb_btou);\n };\n var cb_decode = function(cccc) {\n var len = cccc.length,\n padlen = len % 4,\n n = (len > 0 ? b64tab[cccc.charAt(0)] << 18 : 0)\n | (len > 1 ? b64tab[cccc.charAt(1)] << 12 : 0)\n | (len > 2 ? b64tab[cccc.charAt(2)] << 6 : 0)\n | (len > 3 ? b64tab[cccc.charAt(3)] : 0),\n chars = [\n fromCharCode( n >>> 16),\n fromCharCode((n >>> 8) & 0xff),\n fromCharCode( n & 0xff)\n ];\n chars.length -= [0, 0, 2, 1][padlen];\n return chars.join('');\n };\n var atob = global.atob ? function(a) {\n return global.atob(a);\n } : function(a){\n return a.replace(/[\\s\\S]{1,4}/g, cb_decode);\n };\n var _decode = buffer ? function(a) {\n return (a.constructor === buffer.constructor\n ? a : new buffer(a, 'base64')).toString();\n }\n : function(a) { return btou(atob(a)) };\n var decode = function(a){\n return _decode(\n String(a).replace(/[-_]/g, function(m0) { return m0 == '-' ? '+' : '/' })\n .replace(/[^A-Za-z0-9\\+\\/]/g, '')\n );\n };\n var noConflict = function() {\n var Base64 = global.Base64;\n global.Base64 = _Base64;\n return Base64;\n };\n // export Base64\n global.Base64 = {\n VERSION: version,\n atob: atob,\n btoa: btoa,\n fromBase64: decode,\n toBase64: encode,\n utob: utob,\n encode: encode,\n encodeURI: encodeURI,\n btou: btou,\n decode: decode,\n noConflict: noConflict\n };\n // if ES5 is available, make Base64.extendString() available\n if (typeof Object.defineProperty === 'function') {\n var noEnum = function(v){\n return {value:v,enumerable:false,writable:true,configurable:true};\n };\n global.Base64.extendString = function () {\n Object.defineProperty(\n String.prototype, 'fromBase64', noEnum(function () {\n return decode(this)\n }));\n Object.defineProperty(\n String.prototype, 'toBase64', noEnum(function (urisafe) {\n return encode(this, urisafe)\n }));\n Object.defineProperty(\n String.prototype, 'toBase64URI', noEnum(function () {\n return encode(this, true)\n }));\n };\n }\n // that's it!\n if (global['Meteor']) {\n Base64 = global.Base64; // for normal export in Meteor.js\n }\n})(this);\n","/**\n * Helpers.\n */\n\nvar s = 1000\nvar m = s * 60\nvar h = m * 60\nvar d = h * 24\nvar y = d * 365.25\n\n/**\n * Parse or format the given `val`.\n *\n * Options:\n *\n * - `long` verbose formatting [false]\n *\n * @param {String|Number} val\n * @param {Object} options\n * @throws {Error} throw an error if val is not a non-empty string or a number\n * @return {String|Number}\n * @api public\n */\n\nmodule.exports = function (val, options) {\n options = options || {}\n var type = typeof val\n if (type === 'string' && val.length > 0) {\n return parse(val)\n } else if (type === 'number' && isNaN(val) === false) {\n return options.long ?\n\t\t\tfmtLong(val) :\n\t\t\tfmtShort(val)\n }\n throw new Error('val is not a non-empty string or a valid number. val=' + JSON.stringify(val))\n}\n\n/**\n * Parse the given `str` and return milliseconds.\n *\n * @param {String} str\n * @return {Number}\n * @api private\n */\n\nfunction parse(str) {\n str = String(str)\n if (str.length > 10000) {\n return\n }\n var match = /^((?:\\d+)?\\.?\\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|years?|yrs?|y)?$/i.exec(str)\n if (!match) {\n return\n }\n var n = parseFloat(match[1])\n var type = (match[2] || 'ms').toLowerCase()\n switch (type) {\n case 'years':\n case 'year':\n case 'yrs':\n case 'yr':\n case 'y':\n return n * y\n case 'days':\n case 'day':\n case 'd':\n return n * d\n case 'hours':\n case 'hour':\n case 'hrs':\n case 'hr':\n case 'h':\n return n * h\n case 'minutes':\n case 'minute':\n case 'mins':\n case 'min':\n case 'm':\n return n * m\n case 'seconds':\n case 'second':\n case 'secs':\n case 'sec':\n case 's':\n return n * s\n case 'milliseconds':\n case 'millisecond':\n case 'msecs':\n case 'msec':\n case 'ms':\n return n\n default:\n return undefined\n }\n}\n\n/**\n * Short format for `ms`.\n *\n * @param {Number} ms\n * @return {String}\n * @api private\n */\n\nfunction fmtShort(ms) {\n if (ms >= d) {\n return Math.round(ms / d) + 'd'\n }\n if (ms >= h) {\n return Math.round(ms / h) + 'h'\n }\n if (ms >= m) {\n return Math.round(ms / m) + 'm'\n }\n if (ms >= s) {\n return Math.round(ms / s) + 's'\n }\n return ms + 'ms'\n}\n\n/**\n * Long format for `ms`.\n *\n * @param {Number} ms\n * @return {String}\n * @api private\n */\n\nfunction fmtLong(ms) {\n return plural(ms, d, 'day') ||\n plural(ms, h, 'hour') ||\n plural(ms, m, 'minute') ||\n plural(ms, s, 'second') ||\n ms + ' ms'\n}\n\n/**\n * Pluralization helper.\n */\n\nfunction plural(ms, n, name) {\n if (ms < n) {\n return\n }\n if (ms < n * 1.5) {\n return Math.floor(ms / n) + ' ' + name\n }\n return Math.ceil(ms / n) + ' ' + name + 's'\n}\n","// shim for using process in browser\nvar process = module.exports = {};\n\n// cached from whatever global is present so that test runners that stub it\n// don't break things. But we need to wrap it in a try catch in case it is\n// wrapped in strict mode code which doesn't define any globals. It's inside a\n// function because try/catches deoptimize in certain engines.\n\nvar cachedSetTimeout;\nvar cachedClearTimeout;\n\nfunction defaultSetTimout() {\n throw new Error('setTimeout has not been defined');\n}\nfunction defaultClearTimeout () {\n throw new Error('clearTimeout has not been defined');\n}\n(function () {\n try {\n if (typeof setTimeout === 'function') {\n cachedSetTimeout = setTimeout;\n } else {\n cachedSetTimeout = defaultSetTimout;\n }\n } catch (e) {\n cachedSetTimeout = defaultSetTimout;\n }\n try {\n if (typeof clearTimeout === 'function') {\n cachedClearTimeout = clearTimeout;\n } else {\n cachedClearTimeout = defaultClearTimeout;\n }\n } catch (e) {\n cachedClearTimeout = defaultClearTimeout;\n }\n} ())\nfunction runTimeout(fun) {\n if (cachedSetTimeout === setTimeout) {\n //normal enviroments in sane situations\n return setTimeout(fun, 0);\n }\n // if setTimeout wasn't available but was latter defined\n if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {\n cachedSetTimeout = setTimeout;\n return setTimeout(fun, 0);\n }\n try {\n // when when somebody has screwed with setTimeout but no I.E. maddness\n return cachedSetTimeout(fun, 0);\n } catch(e){\n try {\n // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally\n return cachedSetTimeout.call(null, fun, 0);\n } catch(e){\n // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error\n return cachedSetTimeout.call(this, fun, 0);\n }\n }\n\n\n}\nfunction runClearTimeout(marker) {\n if (cachedClearTimeout === clearTimeout) {\n //normal enviroments in sane situations\n return clearTimeout(marker);\n }\n // if clearTimeout wasn't available but was latter defined\n if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {\n cachedClearTimeout = clearTimeout;\n return clearTimeout(marker);\n }\n try {\n // when when somebody has screwed with setTimeout but no I.E. maddness\n return cachedClearTimeout(marker);\n } catch (e){\n try {\n // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally\n return cachedClearTimeout.call(null, marker);\n } catch (e){\n // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error.\n // Some versions of I.E. have different rules for clearTimeout vs setTimeout\n return cachedClearTimeout.call(this, marker);\n }\n }\n\n\n\n}\nvar queue = [];\nvar draining = false;\nvar currentQueue;\nvar queueIndex = -1;\n\nfunction cleanUpNextTick() {\n if (!draining || !currentQueue) {\n return;\n }\n draining = false;\n if (currentQueue.length) {\n queue = currentQueue.concat(queue);\n } else {\n queueIndex = -1;\n }\n if (queue.length) {\n drainQueue();\n }\n}\n\nfunction drainQueue() {\n if (draining) {\n return;\n }\n var timeout = runTimeout(cleanUpNextTick);\n draining = true;\n\n var len = queue.length;\n while(len) {\n currentQueue = queue;\n queue = [];\n while (++queueIndex < len) {\n if (currentQueue) {\n currentQueue[queueIndex].run();\n }\n }\n queueIndex = -1;\n len = queue.length;\n }\n currentQueue = null;\n draining = false;\n runClearTimeout(timeout);\n}\n\nprocess.nextTick = function (fun) {\n var args = new Array(arguments.length - 1);\n if (arguments.length > 1) {\n for (var i = 1; i < arguments.length; i++) {\n args[i - 1] = arguments[i];\n }\n }\n queue.push(new Item(fun, args));\n if (queue.length === 1 && !draining) {\n runTimeout(drainQueue);\n }\n};\n\n// v8 likes predictible objects\nfunction Item(fun, array) {\n this.fun = fun;\n this.array = array;\n}\nItem.prototype.run = function () {\n this.fun.apply(null, this.array);\n};\nprocess.title = 'browser';\nprocess.browser = true;\nprocess.env = {};\nprocess.argv = [];\nprocess.version = ''; // empty string to avoid regexp issues\nprocess.versions = {};\n\nfunction noop() {}\n\nprocess.on = noop;\nprocess.addListener = noop;\nprocess.once = noop;\nprocess.off = noop;\nprocess.removeListener = noop;\nprocess.removeAllListeners = noop;\nprocess.emit = noop;\n\nprocess.binding = function (name) {\n throw new Error('process.binding is not supported');\n};\n\nprocess.cwd = function () { return '/' };\nprocess.chdir = function (dir) {\n throw new Error('process.chdir is not supported');\n};\nprocess.umask = function() { return 0; };\n","/*! https://mths.be/utf8js v2.1.2 by @mathias */\n;(function(root) {\n\n\t// Detect free variables `exports`\n\tvar freeExports = typeof exports == 'object' && exports;\n\n\t// Detect free variable `module`\n\tvar freeModule = typeof module == 'object' && module &&\n\t\tmodule.exports == freeExports && module;\n\n\t// Detect free variable `global`, from Node.js or Browserified code,\n\t// and use it as `root`\n\tvar freeGlobal = typeof global == 'object' && global;\n\tif (freeGlobal.global === freeGlobal || freeGlobal.window === freeGlobal) {\n\t\troot = freeGlobal;\n\t}\n\n\t/*--------------------------------------------------------------------------*/\n\n\tvar stringFromCharCode = String.fromCharCode;\n\n\t// Taken from https://mths.be/punycode\n\tfunction ucs2decode(string) {\n\t\tvar output = [];\n\t\tvar counter = 0;\n\t\tvar length = string.length;\n\t\tvar value;\n\t\tvar extra;\n\t\twhile (counter < length) {\n\t\t\tvalue = string.charCodeAt(counter++);\n\t\t\tif (value >= 0xD800 && value <= 0xDBFF && counter < length) {\n\t\t\t\t// high surrogate, and there is a next character\n\t\t\t\textra = string.charCodeAt(counter++);\n\t\t\t\tif ((extra & 0xFC00) == 0xDC00) { // low surrogate\n\t\t\t\t\toutput.push(((value & 0x3FF) << 10) + (extra & 0x3FF) + 0x10000);\n\t\t\t\t} else {\n\t\t\t\t\t// unmatched surrogate; only append this code unit, in case the next\n\t\t\t\t\t// code unit is the high surrogate of a surrogate pair\n\t\t\t\t\toutput.push(value);\n\t\t\t\t\tcounter--;\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\toutput.push(value);\n\t\t\t}\n\t\t}\n\t\treturn output;\n\t}\n\n\t// Taken from https://mths.be/punycode\n\tfunction ucs2encode(array) {\n\t\tvar length = array.length;\n\t\tvar index = -1;\n\t\tvar value;\n\t\tvar output = '';\n\t\twhile (++index < length) {\n\t\t\tvalue = array[index];\n\t\t\tif (value > 0xFFFF) {\n\t\t\t\tvalue -= 0x10000;\n\t\t\t\toutput += stringFromCharCode(value >>> 10 & 0x3FF | 0xD800);\n\t\t\t\tvalue = 0xDC00 | value & 0x3FF;\n\t\t\t}\n\t\t\toutput += stringFromCharCode(value);\n\t\t}\n\t\treturn output;\n\t}\n\n\tfunction checkScalarValue(codePoint) {\n\t\tif (codePoint >= 0xD800 && codePoint <= 0xDFFF) {\n\t\t\tthrow Error(\n\t\t\t\t'Lone surrogate U+' + codePoint.toString(16).toUpperCase() +\n\t\t\t\t' is not a scalar value'\n\t\t\t);\n\t\t}\n\t}\n\t/*--------------------------------------------------------------------------*/\n\n\tfunction createByte(codePoint, shift) {\n\t\treturn stringFromCharCode(((codePoint >> shift) & 0x3F) | 0x80);\n\t}\n\n\tfunction encodeCodePoint(codePoint) {\n\t\tif ((codePoint & 0xFFFFFF80) == 0) { // 1-byte sequence\n\t\t\treturn stringFromCharCode(codePoint);\n\t\t}\n\t\tvar symbol = '';\n\t\tif ((codePoint & 0xFFFFF800) == 0) { // 2-byte sequence\n\t\t\tsymbol = stringFromCharCode(((codePoint >> 6) & 0x1F) | 0xC0);\n\t\t}\n\t\telse if ((codePoint & 0xFFFF0000) == 0) { // 3-byte sequence\n\t\t\tcheckScalarValue(codePoint);\n\t\t\tsymbol = stringFromCharCode(((codePoint >> 12) & 0x0F) | 0xE0);\n\t\t\tsymbol += createByte(codePoint, 6);\n\t\t}\n\t\telse if ((codePoint & 0xFFE00000) == 0) { // 4-byte sequence\n\t\t\tsymbol = stringFromCharCode(((codePoint >> 18) & 0x07) | 0xF0);\n\t\t\tsymbol += createByte(codePoint, 12);\n\t\t\tsymbol += createByte(codePoint, 6);\n\t\t}\n\t\tsymbol += stringFromCharCode((codePoint & 0x3F) | 0x80);\n\t\treturn symbol;\n\t}\n\n\tfunction utf8encode(string) {\n\t\tvar codePoints = ucs2decode(string);\n\t\tvar length = codePoints.length;\n\t\tvar index = -1;\n\t\tvar codePoint;\n\t\tvar byteString = '';\n\t\twhile (++index < length) {\n\t\t\tcodePoint = codePoints[index];\n\t\t\tbyteString += encodeCodePoint(codePoint);\n\t\t}\n\t\treturn byteString;\n\t}\n\n\t/*--------------------------------------------------------------------------*/\n\n\tfunction readContinuationByte() {\n\t\tif (byteIndex >= byteCount) {\n\t\t\tthrow Error('Invalid byte index');\n\t\t}\n\n\t\tvar continuationByte = byteArray[byteIndex] & 0xFF;\n\t\tbyteIndex++;\n\n\t\tif ((continuationByte & 0xC0) == 0x80) {\n\t\t\treturn continuationByte & 0x3F;\n\t\t}\n\n\t\t// If we end up here, it’s not a continuation byte\n\t\tthrow Error('Invalid continuation byte');\n\t}\n\n\tfunction decodeSymbol() {\n\t\tvar byte1;\n\t\tvar byte2;\n\t\tvar byte3;\n\t\tvar byte4;\n\t\tvar codePoint;\n\n\t\tif (byteIndex > byteCount) {\n\t\t\tthrow Error('Invalid byte index');\n\t\t}\n\n\t\tif (byteIndex == byteCount) {\n\t\t\treturn false;\n\t\t}\n\n\t\t// Read first byte\n\t\tbyte1 = byteArray[byteIndex] & 0xFF;\n\t\tbyteIndex++;\n\n\t\t// 1-byte sequence (no continuation bytes)\n\t\tif ((byte1 & 0x80) == 0) {\n\t\t\treturn byte1;\n\t\t}\n\n\t\t// 2-byte sequence\n\t\tif ((byte1 & 0xE0) == 0xC0) {\n\t\t\tbyte2 = readContinuationByte();\n\t\t\tcodePoint = ((byte1 & 0x1F) << 6) | byte2;\n\t\t\tif (codePoint >= 0x80) {\n\t\t\t\treturn codePoint;\n\t\t\t} else {\n\t\t\t\tthrow Error('Invalid continuation byte');\n\t\t\t}\n\t\t}\n\n\t\t// 3-byte sequence (may include unpaired surrogates)\n\t\tif ((byte1 & 0xF0) == 0xE0) {\n\t\t\tbyte2 = readContinuationByte();\n\t\t\tbyte3 = readContinuationByte();\n\t\t\tcodePoint = ((byte1 & 0x0F) << 12) | (byte2 << 6) | byte3;\n\t\t\tif (codePoint >= 0x0800) {\n\t\t\t\tcheckScalarValue(codePoint);\n\t\t\t\treturn codePoint;\n\t\t\t} else {\n\t\t\t\tthrow Error('Invalid continuation byte');\n\t\t\t}\n\t\t}\n\n\t\t// 4-byte sequence\n\t\tif ((byte1 & 0xF8) == 0xF0) {\n\t\t\tbyte2 = readContinuationByte();\n\t\t\tbyte3 = readContinuationByte();\n\t\t\tbyte4 = readContinuationByte();\n\t\t\tcodePoint = ((byte1 & 0x07) << 0x12) | (byte2 << 0x0C) |\n\t\t\t\t(byte3 << 0x06) | byte4;\n\t\t\tif (codePoint >= 0x010000 && codePoint <= 0x10FFFF) {\n\t\t\t\treturn codePoint;\n\t\t\t}\n\t\t}\n\n\t\tthrow Error('Invalid UTF-8 detected');\n\t}\n\n\tvar byteArray;\n\tvar byteCount;\n\tvar byteIndex;\n\tfunction utf8decode(byteString) {\n\t\tbyteArray = ucs2decode(byteString);\n\t\tbyteCount = byteArray.length;\n\t\tbyteIndex = 0;\n\t\tvar codePoints = [];\n\t\tvar tmp;\n\t\twhile ((tmp = decodeSymbol()) !== false) {\n\t\t\tcodePoints.push(tmp);\n\t\t}\n\t\treturn ucs2encode(codePoints);\n\t}\n\n\t/*--------------------------------------------------------------------------*/\n\n\tvar utf8 = {\n\t\t'version': '2.1.2',\n\t\t'encode': utf8encode,\n\t\t'decode': utf8decode\n\t};\n\n\t// Some AMD build optimizers, like r.js, check for specific condition patterns\n\t// like the following:\n\tif (\n\t\ttypeof define == 'function' &&\n\t\ttypeof define.amd == 'object' &&\n\t\tdefine.amd\n\t) {\n\t\tdefine(function() {\n\t\t\treturn utf8;\n\t\t});\n\t}\telse if (freeExports && !freeExports.nodeType) {\n\t\tif (freeModule) { // in Node.js or RingoJS v0.8.0+\n\t\t\tfreeModule.exports = utf8;\n\t\t} else { // in Narwhal or RingoJS v0.7.0-\n\t\t\tvar object = {};\n\t\t\tvar hasOwnProperty = object.hasOwnProperty;\n\t\t\tfor (var key in utf8) {\n\t\t\t\thasOwnProperty.call(utf8, key) && (freeExports[key] = utf8[key]);\n\t\t\t}\n\t\t}\n\t} else { // in Rhino or a web browser\n\t\troot.utf8 = utf8;\n\t}\n\n}(this));\n"]} \ No newline at end of file +{"version":3,"sources":["node_modules/browser-pack/_prelude.js","lib/Gist.js","lib/GitHub.js","lib/Issue.js","lib/Markdown.js","lib/Organization.js","lib/Project.js","lib/RateLimit.js","lib/Repository.js","lib/Requestable.js","lib/Search.js","lib/Team.js","lib/User.js","node_modules/axios/index.js","node_modules/axios/lib/adapters/xhr.js","node_modules/axios/lib/axios.js","node_modules/axios/lib/cancel/Cancel.js","node_modules/axios/lib/cancel/CancelToken.js","node_modules/axios/lib/cancel/isCancel.js","node_modules/axios/lib/core/Axios.js","node_modules/axios/lib/core/InterceptorManager.js","node_modules/axios/lib/core/createError.js","node_modules/axios/lib/core/dispatchRequest.js","node_modules/axios/lib/core/enhanceError.js","node_modules/axios/lib/core/settle.js","node_modules/axios/lib/core/transformData.js","node_modules/axios/lib/defaults.js","node_modules/axios/lib/helpers/bind.js","node_modules/axios/lib/helpers/btoa.js","node_modules/axios/lib/helpers/buildURL.js","node_modules/axios/lib/helpers/combineURLs.js","node_modules/axios/lib/helpers/cookies.js","node_modules/axios/lib/helpers/isAbsoluteURL.js","node_modules/axios/lib/helpers/isURLSameOrigin.js","node_modules/axios/lib/helpers/normalizeHeaderName.js","node_modules/axios/lib/helpers/parseHeaders.js","node_modules/axios/lib/helpers/spread.js","node_modules/axios/lib/utils.js","node_modules/base64-js/index.js","node_modules/buffer/index.js","node_modules/debug/src/browser.js","node_modules/debug/src/debug.js","node_modules/ieee754/index.js","node_modules/isarray/index.js","node_modules/js-base64/base64.js","node_modules/ms/index.js","node_modules/process/browser.js","node_modules/utf8/utf8.js"],"names":["f","exports","module","define","amd","g","window","global","self","this","GitHub","e","t","n","r","s","o","u","a","require","i","Error","code","l","call","length","1","_Requestable2","Gist","id","auth","apiBase","_classCallCheck","_this","_possibleConstructorReturn","__proto__","Object","getPrototypeOf","__id","cb","_request","gist","_this2","then","response","data","_request204or404","_requestAllPages","revision","comment","body","_Gist","_User","_Issue","_Search","_RateLimit","_Repository","_Organization","_Team","_Markdown","_Project","arguments","undefined","__apiBase","__auth","_Gist2","default","user","_User2","organization","_Organization2","teamId","_Team2","repo","_Repository2","_getFullName","_Issue2","query","_Search2","_RateLimit2","_Markdown2","_Project2","fullname","Issue","repository","__repository","issueData","options","issue","milestone","milestoneData","labelData","label","Markdown","Organization","__name","requestOptions","_getOptionsWithDefaults","direction","username","AcceptHeader","Project","colId","position","listProjectColumns","_ref","Promise","all","map","column","cardsInColumns","cards","reduce","prev","_ref2","push","apply","_toConsumableArray","catch","err","cardId","column_id","RateLimit","_utf","_jsBase","_debug","log","_debug2","Repository","__fullname","__currentTree","branch","sha","ref","number","base","head","since","_dateToISO","until","path","treeSHA","content","postBody","_getContentObject","_utf2","encode","encoding","Buffer","toString","Blob","Base64","_typeof","JSON","stringify","baseTreeSHA","blobSHA","newTree","base_tree","tree","mode","type","baseSHA","parent","message","parents","commitSHA","force","raw","encodeURI","oldBranch","newBranch","_this3","getRef","object","createRef","_this4","getSha","deleteCommit","oldPath","newPath","_this5","oldSha","getTree","_ref2$data","createTree","_ref3","commit","_ref4","updateHead","_this6","filePath","shouldEncode","author","committer","methodHasNoBody","method","METHODS_WITH_NO_BODY","indexOf","getNextPage","linksHeader","links","split","nextUrl","link","search","match","callbackErrorOrThrow","error","hasOwnProperty","_object$response","status","statusText","_object$config","config","url","ResponseError","_axios","request","Requestable","token","password","__AcceptHeader","__authorizationHeader","newCacheBuster","Date","getTime","replace","headers","Content-Type","Accept","Authorization","visibility","affiliation","sort","per_page","date","toISOString","__getURL","__getRequestHeaders","queryParams","shouldUseDataAsParams","params","responseType","requestPromise","_axios2","keys","results","_results","thisGroup","Array","items","page","Search","defaults","__defaults","withOptions","forEach","prop","_search","Team","__teamId","owner","User","__user","endpoint","__getScopedUrl","before","utils","settle","buildURL","parseHeaders","isURLSameOrigin","createError","btoa","bind","resolve","reject","requestData","requestHeaders","isFormData","XMLHttpRequest","loadEvent","xDomain","process","env","NODE_ENV","XDomainRequest","onprogress","ontimeout","open","toUpperCase","paramsSerializer","timeout","readyState","responseURL","responseHeaders","getAllResponseHeaders","responseData","responseText","onerror","isStandardBrowserEnv","cookies","xsrfValue","withCredentials","xsrfCookieName","read","xsrfHeaderName","val","key","toLowerCase","setRequestHeader","onDownloadProgress","addEventListener","onUploadProgress","upload","cancelToken","promise","cancel","abort","send","createInstance","defaultConfig","context","Axios","instance","prototype","extend","axios","create","instanceConfig","merge","Cancel","CancelToken","isCancel","promises","spread","__CANCEL__","executor","TypeError","resolvePromise","reason","throwIfRequested","source","c","value","interceptors","InterceptorManager","dispatchRequest","isAbsoluteURL","combineURLs","baseURL","chain","interceptor","unshift","fulfilled","rejected","shift","handlers","use","eject","fn","h","enhanceError","throwIfCancellationRequested","transformData","transformRequest","common","adapter","transformResponse","validateStatus","fns","setContentTypeIfUnset","isUndefined","getDefaultAdapter","normalizeHeaderName","PROTECTION_PREFIX","DEFAULT_CONTENT_TYPE","isArrayBuffer","isStream","isFile","isBlob","isArrayBufferView","buffer","isURLSearchParams","isObject","parse","maxContentLength","thisArg","args","E","input","block","charCode","str","String","output","idx","chars","charAt","charCodeAt","name","encodeURIComponent","serializedParams","parts","isArray","v","isDate","join","relativeURL","write","expires","domain","secure","cookie","isNumber","toGMTString","isString","document","RegExp","decodeURIComponent","remove","now","test","resolveURL","href","msie","urlParsingNode","setAttribute","protocol","host","hash","hostname","port","pathname","originURL","navigator","userAgent","createElement","location","requestURL","parsed","normalizedName","line","trim","substr","callback","arr","FormData","result","ArrayBuffer","isView","isFunction","pipe","URLSearchParams","obj","assignValue","b","placeHoldersCount","b64","len","byteLength","toByteArray","j","tmp","placeHolders","Arr","L","revLookup","tripletToBase64","num","lookup","encodeChunk","uint8","start","end","fromByteArray","extraBytes","maxChunkLength","len2","Uint8Array","typedArraySupport","foo","subarray","kMaxLength","TYPED_ARRAY_SUPPORT","createBuffer","that","RangeError","arg","encodingOrOffset","allocUnsafe","from","fromArrayBuffer","fromString","fromObject","assertSize","size","alloc","fill","checked","string","isEncoding","actual","slice","fromArrayLike","array","byteOffset","isBuffer","copy","isnan","SlowBuffer","loweredCase","utf8ToBytes","base64ToBytes","slowToString","hexSlice","utf8Slice","asciiSlice","latin1Slice","base64Slice","utf16leSlice","swap","m","bidirectionalIndexOf","dir","isNaN","arrayIndexOf","lastIndexOf","buf","indexSize","readUInt16BE","arrLength","valLength","foundIndex","found","hexWrite","offset","Number","remaining","strLen","parseInt","utf8Write","blitBuffer","asciiWrite","asciiToBytes","latin1Write","base64Write","ucs2Write","utf16leToBytes","base64","Math","min","res","firstByte","codePoint","bytesPerSequence","secondByte","thirdByte","fourthByte","tempCodePoint","decodeCodePointsArray","codePoints","MAX_ARGUMENTS_LENGTH","fromCharCode","ret","out","toHex","bytes","checkOffset","ext","checkInt","max","objectWriteUInt16","littleEndian","objectWriteUInt32","checkIEEE754","writeFloat","noAssert","ieee754","writeDouble","base64clean","stringtrim","INVALID_BASE64_RE","units","Infinity","leadSurrogate","byteArray","hi","lo","src","dst","INSPECT_MAX_BYTES","poolSize","_augment","Symbol","species","defineProperty","configurable","allocUnsafeSlow","_isBuffer","compare","x","y","concat","list","pos","swap16","swap32","swap64","equals","inspect","target","thisStart","thisEnd","thisCopy","targetCopy","includes","isFinite","toJSON","_arr","newBuf","sliceLen","readUIntLE","mul","readUIntBE","readUInt8","readUInt16LE","readUInt32LE","readUInt32BE","readIntLE","pow","readIntBE","readInt8","readInt16LE","readInt16BE","readInt32LE","readInt32BE","readFloatLE","readFloatBE","readDoubleLE","readDoubleBE","writeUIntLE","maxBytes","writeUIntBE","writeUInt8","floor","writeUInt16LE","writeUInt16BE","writeUInt32LE","writeUInt32BE","writeIntLE","limit","sub","writeIntBE","writeInt8","writeInt16LE","writeInt16BE","writeInt32LE","writeInt32BE","writeFloatLE","writeFloatBE","writeDoubleLE","writeDoubleBE","targetStart","set","useColors","documentElement","style","console","firebug","exception","table","$1","formatArgs","namespace","humanize","diff","color","splice","index","lastC","Function","save","namespaces","storage","removeItem","debug","load","DEBUG","localstorage","localStorage","chrome","local","colors","formatters","enable","selectColor","abs","createDebug","enabled","curr","ms","prevTime","coerce","format","formatter","logFn","init","skips","names","disable","stack","isLE","mLen","nBytes","eLen","eMax","eBias","nBits","d","NaN","rt","LN2","_Base64","version","b64chars","b64tab","bin","cb_utob","cc","re_utob","utob","cb_encode","ccc","padlen","ord","_encode","constructor","urisafe","m0","re_btou","cb_btou","cccc","cp","btou","cb_decode","atob","_decode","decode","noConflict","VERSION","fromBase64","toBase64","noEnum","enumerable","writable","extendString","exec","parseFloat","fmtShort","round","fmtLong","plural","ceil","long","defaultSetTimout","defaultClearTimeout","runTimeout","fun","cachedSetTimeout","setTimeout","runClearTimeout","marker","cachedClearTimeout","clearTimeout","cleanUpNextTick","draining","currentQueue","queue","queueIndex","drainQueue","run","Item","noop","nextTick","title","browser","argv","versions","on","addListener","once","off","removeListener","removeAllListeners","emit","binding","cwd","chdir","umask","root","ucs2decode","extra","counter","ucs2encode","stringFromCharCode","checkScalarValue","createByte","encodeCodePoint","symbol","utf8encode","byteString","readContinuationByte","byteIndex","byteCount","continuationByte","decodeSymbol","byte1","byte2","byte3","byte4","utf8decode","freeExports","freeModule","freeGlobal","utf8","nodeType"],"mappings":"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","file":"GitHub.bundle.min.js","sourcesContent":["(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require==\"function\"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error(\"Cannot find module '\"+o+\"'\");throw f.code=\"MODULE_NOT_FOUND\",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require==\"function\"&&require;for(var o=0;o {\n this.__id = response.data.id;\n return response;\n });\n }\n\n /**\n * Delete a gist.\n * @see https://developer.github.com/v3/gists/#delete-a-gist\n * @param {Requestable.callback} [cb] - will receive true if the request succeeds\n * @return {Promise} - the Promise for the http request\n */\n delete(cb) {\n return this._request('DELETE', `/gists/${this.__id}`, null, cb);\n }\n\n /**\n * Fork a gist.\n * @see https://developer.github.com/v3/gists/#fork-a-gist\n * @param {Requestable.callback} [cb] - the function that will receive the gist\n * @return {Promise} - the Promise for the http request\n */\n fork(cb) {\n return this._request('POST', `/gists/${this.__id}/forks`, null, cb);\n }\n\n /**\n * Update a gist.\n * @see https://developer.github.com/v3/gists/#edit-a-gist\n * @param {Object} gist - the new data for the gist\n * @param {Requestable.callback} [cb] - the function that receives the API result\n * @return {Promise} - the Promise for the http request\n */\n update(gist, cb) {\n return this._request('PATCH', `/gists/${this.__id}`, gist, cb);\n }\n\n /**\n * Star a gist.\n * @see https://developer.github.com/v3/gists/#star-a-gist\n * @param {Requestable.callback} [cb] - will receive true if the request is successful\n * @return {Promise} - the Promise for the http request\n */\n star(cb) {\n return this._request('PUT', `/gists/${this.__id}/star`, null, cb);\n }\n\n /**\n * Unstar a gist.\n * @see https://developer.github.com/v3/gists/#unstar-a-gist\n * @param {Requestable.callback} [cb] - will receive true if the request is successful\n * @return {Promise} - the Promise for the http request\n */\n unstar(cb) {\n return this._request('DELETE', `/gists/${this.__id}/star`, null, cb);\n }\n\n /**\n * Check if a gist is starred by the user.\n * @see https://developer.github.com/v3/gists/#check-if-a-gist-is-starred\n * @param {Requestable.callback} [cb] - will receive true if the gist is starred and false if the gist is not starred\n * @return {Promise} - the Promise for the http request\n */\n isStarred(cb) {\n return this._request204or404(`/gists/${this.__id}/star`, null, cb);\n }\n\n /**\n * List the gist's commits\n * @see https://developer.github.com/v3/gists/#list-gist-commits\n * @param {Requestable.callback} [cb] - will receive the array of commits\n * @return {Promise} - the Promise for the http request\n */\n listCommits(cb) {\n return this._requestAllPages(`/gists/${this.__id}/commits`, null, cb);\n }\n\n /**\n * Fetch one of the gist's revision.\n * @see https://developer.github.com/v3/gists/#get-a-specific-revision-of-a-gist\n * @param {string} revision - the id of the revision\n * @param {Requestable.callback} [cb] - will receive the revision\n * @return {Promise} - the Promise for the http request\n */\n getRevision(revision, cb) {\n return this._request('GET', `/gists/${this.__id}/${revision}`, null, cb);\n }\n\n /**\n * List the gist's comments\n * @see https://developer.github.com/v3/gists/comments/#list-comments-on-a-gist\n * @param {Requestable.callback} [cb] - will receive the array of comments\n * @return {Promise} - the promise for the http request\n */\n listComments(cb) {\n return this._requestAllPages(`/gists/${this.__id}/comments`, null, cb);\n }\n\n /**\n * Fetch one of the gist's comments\n * @see https://developer.github.com/v3/gists/comments/#get-a-single-comment\n * @param {number} comment - the id of the comment\n * @param {Requestable.callback} [cb] - will receive the comment\n * @return {Promise} - the Promise for the http request\n */\n getComment(comment, cb) {\n return this._request('GET', `/gists/${this.__id}/comments/${comment}`, null, cb);\n }\n\n /**\n * Comment on a gist\n * @see https://developer.github.com/v3/gists/comments/#create-a-comment\n * @param {string} comment - the comment to add\n * @param {Requestable.callback} [cb] - the function that receives the API result\n * @return {Promise} - the Promise for the http request\n */\n createComment(comment, cb) {\n return this._request('POST', `/gists/${this.__id}/comments`, {body: comment}, cb);\n }\n\n /**\n * Edit a comment on the gist\n * @see https://developer.github.com/v3/gists/comments/#edit-a-comment\n * @param {number} comment - the id of the comment\n * @param {string} body - the new comment\n * @param {Requestable.callback} [cb] - will receive the modified comment\n * @return {Promise} - the promise for the http request\n */\n editComment(comment, body, cb) {\n return this._request('PATCH', `/gists/${this.__id}/comments/${comment}`, {body: body}, cb);\n }\n\n /**\n * Delete a comment on the gist.\n * @see https://developer.github.com/v3/gists/comments/#delete-a-comment\n * @param {number} comment - the id of the comment\n * @param {Requestable.callback} [cb] - will receive true if the request succeeds\n * @return {Promise} - the Promise for the http request\n */\n deleteComment(comment, cb) {\n return this._request('DELETE', `/gists/${this.__id}/comments/${comment}`, null, cb);\n }\n}\n\nmodule.exports = Gist;\n","/**\n * @file\n * @copyright 2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n * Github.js is freely distributable.\n */\n/* eslint valid-jsdoc: [\"error\", {\"requireReturnDescription\": false}] */\n\nimport Gist from './Gist';\nimport User from './User';\nimport Issue from './Issue';\nimport Search from './Search';\nimport RateLimit from './RateLimit';\nimport Repository from './Repository';\nimport Organization from './Organization';\nimport Team from './Team';\nimport Markdown from './Markdown';\nimport Project from './Project';\n\n/**\n * GitHub encapsulates the functionality to create various API wrapper objects.\n */\nclass GitHub {\n /**\n * Create a new GitHub.\n * @param {Requestable.auth} [auth] - the credentials to authenticate to Github. If auth is\n * not provided requests will be made unauthenticated\n * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n */\n constructor(auth, apiBase = 'https://api.github.com') {\n this.__apiBase = apiBase;\n this.__auth = auth || {};\n }\n\n /**\n * Create a new Gist wrapper\n * @param {number} [id] - the id for the gist, leave undefined when creating a new gist\n * @return {Gist}\n */\n getGist(id) {\n return new Gist(id, this.__auth, this.__apiBase);\n }\n\n /**\n * Create a new User wrapper\n * @param {string} [user] - the name of the user to get information about\n * leave undefined for the authenticated user\n * @return {User}\n */\n getUser(user) {\n return new User(user, this.__auth, this.__apiBase);\n }\n\n /**\n * Create a new Organization wrapper\n * @param {string} organization - the name of the organization\n * @return {Organization}\n */\n getOrganization(organization) {\n return new Organization(organization, this.__auth, this.__apiBase);\n }\n\n /**\n * create a new Team wrapper\n * @param {string} teamId - the name of the team\n * @return {team}\n */\n getTeam(teamId) {\n return new Team(teamId, this.__auth, this.__apiBase);\n }\n\n /**\n * Create a new Repository wrapper\n * @param {string} user - the user who owns the respository\n * @param {string} repo - the name of the repository\n * @return {Repository}\n */\n getRepo(user, repo) {\n return new Repository(this._getFullName(user, repo), this.__auth, this.__apiBase);\n }\n\n /**\n * Create a new Issue wrapper\n * @param {string} user - the user who owns the respository\n * @param {string} repo - the name of the repository\n * @return {Issue}\n */\n getIssues(user, repo) {\n return new Issue(this._getFullName(user, repo), this.__auth, this.__apiBase);\n }\n\n /**\n * Create a new Search wrapper\n * @param {string} query - the query to search for\n * @return {Search}\n */\n search(query) {\n return new Search(query, this.__auth, this.__apiBase);\n }\n\n /**\n * Create a new RateLimit wrapper\n * @return {RateLimit}\n */\n getRateLimit() {\n return new RateLimit(this.__auth, this.__apiBase);\n }\n\n /**\n * Create a new Markdown wrapper\n * @return {Markdown}\n */\n getMarkdown() {\n return new Markdown(this.__auth, this.__apiBase);\n }\n\n /**\n * Create a new Project wrapper\n * @param {string} id - the id of the project\n * @return {Markdown}\n */\n getProject(id) {\n return new Project(id, this.__auth, this.__apiBase);\n }\n\n /**\n * Computes the full repository name\n * @param {string} user - the username (or the full name)\n * @param {string} repo - the repository name, must not be passed if `user` is the full name\n * @return {string} the repository's full name\n */\n _getFullName(user, repo) {\n let fullname = user;\n\n if (repo) {\n fullname = `${user}/${repo}`;\n }\n\n return fullname;\n }\n}\n\nmodule.exports = GitHub;\n","/**\n * @file\n * @copyright 2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n * Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\n\n/**\n * Issue wraps the functionality to get issues for repositories\n */\nclass Issue extends Requestable {\n /**\n * Create a new Issue\n * @param {string} repository - the full name of the repository (`:user/:repo`) to get issues for\n * @param {Requestable.auth} [auth] - information required to authenticate to Github\n * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n */\n constructor(repository, auth, apiBase) {\n super(auth, apiBase);\n this.__repository = repository;\n }\n\n /**\n * Create a new issue\n * @see https://developer.github.com/v3/issues/#create-an-issue\n * @param {Object} issueData - the issue to create\n * @param {Requestable.callback} [cb] - will receive the created issue\n * @return {Promise} - the promise for the http request\n */\n createIssue(issueData, cb) {\n return this._request('POST', `/repos/${this.__repository}/issues`, issueData, cb);\n }\n\n /**\n * List the issues for the repository\n * @see https://developer.github.com/v3/issues/#list-issues-for-a-repository\n * @param {Object} options - filtering options\n * @param {Requestable.callback} [cb] - will receive the array of issues\n * @return {Promise} - the promise for the http request\n */\n listIssues(options, cb) {\n return this._requestAllPages(`/repos/${this.__repository}/issues`, options, cb);\n }\n\n /**\n * List the events for an issue\n * @see https://developer.github.com/v3/issues/events/#list-events-for-an-issue\n * @param {number} issue - the issue to get events for\n * @param {Requestable.callback} [cb] - will receive the list of events\n * @return {Promise} - the promise for the http request\n */\n listIssueEvents(issue, cb) {\n return this._request('GET', `/repos/${this.__repository}/issues/${issue}/events`, null, cb);\n }\n\n /**\n * List comments on an issue\n * @see https://developer.github.com/v3/issues/comments/#list-comments-on-an-issue\n * @param {number} issue - the id of the issue to get comments from\n * @param {Requestable.callback} [cb] - will receive the comments\n * @return {Promise} - the promise for the http request\n */\n listIssueComments(issue, cb) {\n return this._request('GET', `/repos/${this.__repository}/issues/${issue}/comments`, null, cb);\n }\n\n /**\n * Get a single comment on an issue\n * @see https://developer.github.com/v3/issues/comments/#get-a-single-comment\n * @param {number} id - the comment id to get\n * @param {Requestable.callback} [cb] - will receive the comment\n * @return {Promise} - the promise for the http request\n */\n getIssueComment(id, cb) {\n return this._request('GET', `/repos/${this.__repository}/issues/comments/${id}`, null, cb);\n }\n\n /**\n * Comment on an issue\n * @see https://developer.github.com/v3/issues/comments/#create-a-comment\n * @param {number} issue - the id of the issue to comment on\n * @param {string} comment - the comment to add\n * @param {Requestable.callback} [cb] - will receive the created comment\n * @return {Promise} - the promise for the http request\n */\n createIssueComment(issue, comment, cb) {\n return this._request('POST', `/repos/${this.__repository}/issues/${issue}/comments`, {body: comment}, cb);\n }\n\n /**\n * Edit a comment on an issue\n * @see https://developer.github.com/v3/issues/comments/#edit-a-comment\n * @param {number} id - the comment id to edit\n * @param {string} comment - the comment to edit\n * @param {Requestable.callback} [cb] - will receive the edited comment\n * @return {Promise} - the promise for the http request\n */\n editIssueComment(id, comment, cb) {\n return this._request('PATCH', `/repos/${this.__repository}/issues/comments/${id}`, {body: comment}, cb);\n }\n\n /**\n * Delete a comment on an issue\n * @see https://developer.github.com/v3/issues/comments/#delete-a-comment\n * @param {number} id - the comment id to delete\n * @param {Requestable.callback} [cb] - will receive true if the request is successful\n * @return {Promise} - the promise for the http request\n */\n deleteIssueComment(id, cb) {\n return this._request('DELETE', `/repos/${this.__repository}/issues/comments/${id}`, null, cb);\n }\n\n /**\n * Edit an issue\n * @see https://developer.github.com/v3/issues/#edit-an-issue\n * @param {number} issue - the issue number to edit\n * @param {Object} issueData - the new issue data\n * @param {Requestable.callback} [cb] - will receive the modified issue\n * @return {Promise} - the promise for the http request\n */\n editIssue(issue, issueData, cb) {\n return this._request('PATCH', `/repos/${this.__repository}/issues/${issue}`, issueData, cb);\n }\n\n /**\n * Get a particular issue\n * @see https://developer.github.com/v3/issues/#get-a-single-issue\n * @param {number} issue - the issue number to fetch\n * @param {Requestable.callback} [cb] - will receive the issue\n * @return {Promise} - the promise for the http request\n */\n getIssue(issue, cb) {\n return this._request('GET', `/repos/${this.__repository}/issues/${issue}`, null, cb);\n }\n\n /**\n * List the milestones for the repository\n * @see https://developer.github.com/v3/issues/milestones/#list-milestones-for-a-repository\n * @param {Object} options - filtering options\n * @param {Requestable.callback} [cb] - will receive the array of milestones\n * @return {Promise} - the promise for the http request\n */\n listMilestones(options, cb) {\n return this._request('GET', `/repos/${this.__repository}/milestones`, options, cb);\n }\n\n /**\n * Get a milestone\n * @see https://developer.github.com/v3/issues/milestones/#get-a-single-milestone\n * @param {string} milestone - the id of the milestone to fetch\n * @param {Requestable.callback} [cb] - will receive the milestone\n * @return {Promise} - the promise for the http request\n */\n getMilestone(milestone, cb) {\n return this._request('GET', `/repos/${this.__repository}/milestones/${milestone}`, null, cb);\n }\n\n /**\n * Create a new milestone\n * @see https://developer.github.com/v3/issues/milestones/#create-a-milestone\n * @param {Object} milestoneData - the milestone definition\n * @param {Requestable.callback} [cb] - will receive the milestone\n * @return {Promise} - the promise for the http request\n */\n createMilestone(milestoneData, cb) {\n return this._request('POST', `/repos/${this.__repository}/milestones`, milestoneData, cb);\n }\n\n /**\n * Edit a milestone\n * @see https://developer.github.com/v3/issues/milestones/#update-a-milestone\n * @param {string} milestone - the id of the milestone to edit\n * @param {Object} milestoneData - the updates to make to the milestone\n * @param {Requestable.callback} [cb] - will receive the updated milestone\n * @return {Promise} - the promise for the http request\n */\n editMilestone(milestone, milestoneData, cb) {\n return this._request('PATCH', `/repos/${this.__repository}/milestones/${milestone}`, milestoneData, cb);\n }\n\n /**\n * Delete a milestone (this is distinct from closing a milestone)\n * @see https://developer.github.com/v3/issues/milestones/#delete-a-milestone\n * @param {string} milestone - the id of the milestone to delete\n * @param {Requestable.callback} [cb] - will receive the status\n * @return {Promise} - the promise for the http request\n */\n deleteMilestone(milestone, cb) {\n return this._request('DELETE', `/repos/${this.__repository}/milestones/${milestone}`, null, cb);\n }\n\n /**\n * Create a new label\n * @see https://developer.github.com/v3/issues/labels/#create-a-label\n * @param {Object} labelData - the label definition\n * @param {Requestable.callback} [cb] - will receive the object representing the label\n * @return {Promise} - the promise for the http request\n */\n createLabel(labelData, cb) {\n return this._request('POST', `/repos/${this.__repository}/labels`, labelData, cb);\n }\n\n /**\n * List the labels for the repository\n * @see https://developer.github.com/v3/issues/labels/#list-all-labels-for-this-repository\n * @param {Object} options - filtering options\n * @param {Requestable.callback} [cb] - will receive the array of labels\n * @return {Promise} - the promise for the http request\n */\n listLabels(options, cb) {\n return this._request('GET', `/repos/${this.__repository}/labels`, options, cb);\n }\n\n /**\n * Get a label\n * @see https://developer.github.com/v3/issues/labels/#get-a-single-label\n * @param {string} label - the name of the label to fetch\n * @param {Requestable.callback} [cb] - will receive the label\n * @return {Promise} - the promise for the http request\n */\n getLabel(label, cb) {\n return this._request('GET', `/repos/${this.__repository}/labels/${label}`, null, cb);\n }\n\n /**\n * Edit a label\n * @see https://developer.github.com/v3/issues/labels/#update-a-label\n * @param {string} label - the name of the label to edit\n * @param {Object} labelData - the updates to make to the label\n * @param {Requestable.callback} [cb] - will receive the updated label\n * @return {Promise} - the promise for the http request\n */\n editLabel(label, labelData, cb) {\n return this._request('PATCH', `/repos/${this.__repository}/labels/${label}`, labelData, cb);\n }\n\n /**\n * Delete a label\n * @see https://developer.github.com/v3/issues/labels/#delete-a-label\n * @param {string} label - the name of the label to delete\n * @param {Requestable.callback} [cb] - will receive the status\n * @return {Promise} - the promise for the http request\n */\n deleteLabel(label, cb) {\n return this._request('DELETE', `/repos/${this.__repository}/labels/${label}`, null, cb);\n }\n}\n\nmodule.exports = Issue;\n","/**\n * @file\n * @copyright 2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n * Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\n\n/**\n * Renders html from Markdown text\n */\nclass Markdown extends Requestable {\n /**\n * construct a Markdown\n * @param {Requestable.auth} auth - the credentials to authenticate to GitHub\n * @param {string} [apiBase] - the base Github API URL\n * @return {Promise} - the promise for the http request\n */\n constructor(auth, apiBase) {\n super(auth, apiBase);\n }\n\n /**\n * Render html from Markdown text.\n * @see https://developer.github.com/v3/markdown/#render-an-arbitrary-markdown-document\n * @param {Object} options - conversion options\n * @param {string} [options.text] - the markdown text to convert\n * @param {string} [options.mode=markdown] - can be either `markdown` or `gfm`\n * @param {string} [options.context] - repository name if mode is gfm\n * @param {Requestable.callback} [cb] - will receive the converted html\n * @return {Promise} - the promise for the http request\n */\n render(options, cb) {\n return this._request('POST', '/markdown', options, cb);\n }\n}\n\nmodule.exports = Markdown;\n","/**\n * @file\n * @copyright 2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n * Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\n\n/**\n * Organization encapsulates the functionality to create repositories in organizations\n */\nclass Organization extends Requestable {\n /**\n * Create a new Organization\n * @param {string} organization - the name of the organization\n * @param {Requestable.auth} [auth] - information required to authenticate to Github\n * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n */\n constructor(organization, auth, apiBase) {\n super(auth, apiBase);\n this.__name = organization;\n }\n\n /**\n * Create a repository in an organization\n * @see https://developer.github.com/v3/repos/#create\n * @param {Object} options - the repository definition\n * @param {Requestable.callback} [cb] - will receive the created repository\n * @return {Promise} - the promise for the http request\n */\n createRepo(options, cb) {\n return this._request('POST', `/orgs/${this.__name}/repos`, options, cb);\n }\n\n /**\n * List the repositories in an organization\n * @see https://developer.github.com/v3/repos/#list-organization-repositories\n * @param {Requestable.callback} [cb] - will receive the list of repositories\n * @return {Promise} - the promise for the http request\n */\n getRepos(cb) {\n let requestOptions = this._getOptionsWithDefaults({direction: 'desc'});\n\n return this._requestAllPages(`/orgs/${this.__name}/repos`, requestOptions, cb);\n }\n\n /**\n * Query if the user is a member or not\n * @param {string} username - the user in question\n * @param {Requestable.callback} [cb] - will receive true if the user is a member\n * @return {Promise} - the promise for the http request\n */\n isMember(username, cb) {\n return this._request204or404(`/orgs/${this.__name}/members/${username}`, null, cb);\n }\n\n /**\n * List the users who are members of the company\n * @see https://developer.github.com/v3/orgs/members/#members-list\n * @param {object} options - filtering options\n * @param {string} [options.filter=all] - can be either `2fa_disabled` or `all`\n * @param {string} [options.role=all] - can be one of: `all`, `admin`, or `member`\n * @param {Requestable.callback} [cb] - will receive the list of users\n * @return {Promise} - the promise for the http request\n */\n listMembers(options, cb) {\n return this._request('GET', `/orgs/${this.__name}/members`, options, cb);\n }\n\n /**\n * List the Teams in the Organization\n * @see https://developer.github.com/v3/orgs/teams/#list-teams\n * @param {Requestable.callback} [cb] - will receive the list of teams\n * @return {Promise} - the promise for the http request\n */\n getTeams(cb) {\n return this._requestAllPages(`/orgs/${this.__name}/teams`, undefined, cb);\n }\n\n /**\n * Create a team\n * @see https://developer.github.com/v3/orgs/teams/#create-team\n * @param {object} options - Team creation parameters\n * @param {string} options.name - The name of the team\n * @param {string} [options.description] - Team description\n * @param {string} [options.repo_names] - Repos to add the team to\n * @param {string} [options.privacy=secret] - The level of privacy the team should have. Can be either one\n * of: `secret`, or `closed`\n * @param {Requestable.callback} [cb] - will receive the created team\n * @return {Promise} - the promise for the http request\n */\n createTeam(options, cb) {\n return this._request('POST', `/orgs/${this.__name}/teams`, options, cb);\n }\n\n /**\n * Get information about all projects\n * @see https://developer.github.com/v3/projects/#list-organization-projects\n * @param {Requestable.callback} [cb] - will receive the list of projects\n * @return {Promise} - the promise for the http request\n */\n listProjects(cb) {\n return this._requestAllPages(`/orgs/${this.__name}/projects`, {AcceptHeader: 'inertia-preview'}, cb);\n }\n\n /**\n * Create a new project\n * @see https://developer.github.com/v3/repos/projects/#create-a-project\n * @param {Object} options - the description of the project\n * @param {Requestable.callback} cb - will receive the newly created project\n * @return {Promise} - the promise for the http request\n */\n createProject(options, cb) {\n options = options || {};\n options.AcceptHeader = 'inertia-preview';\n return this._request('POST', `/orgs/${this.__name}/projects`, options, cb);\n }\n}\n\nmodule.exports = Organization;\n","/**\n * @file\n * @copyright 2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n * Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\n\n/**\n * Project encapsulates the functionality to create, query, and modify cards and columns.\n */\nclass Project extends Requestable {\n /**\n * Create a Project.\n * @param {string} id - the id of the project\n * @param {Requestable.auth} [auth] - information required to authenticate to Github\n * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n */\n constructor(id, auth, apiBase) {\n super(auth, apiBase, 'inertia-preview');\n this.__id = id;\n }\n\n /**\n * Get information about a project\n * @see https://developer.github.com/v3/projects/#get-a-project\n * @param {Requestable.callback} cb - will receive the project information\n * @return {Promise} - the promise for the http request\n */\n getProject(cb) {\n return this._request('GET', `/projects/${this.__id}`, null, cb);\n }\n\n /**\n * Edit a project\n * @see https://developer.github.com/v3/projects/#update-a-project\n * @param {Object} options - the description of the project\n * @param {Requestable.callback} cb - will receive the modified project\n * @return {Promise} - the promise for the http request\n */\n updateProject(options, cb) {\n return this._request('PATCH', `/projects/${this.__id}`, options, cb);\n }\n\n /**\n * Delete a project\n * @see https://developer.github.com/v3/projects/#delete-a-project\n * @param {Requestable.callback} cb - will receive true if the operation is successful\n * @return {Promise} - the promise for the http request\n */\n deleteProject(cb) {\n return this._request('DELETE', `/projects/${this.__id}`, null, cb);\n }\n\n /**\n * Get information about all columns of a project\n * @see https://developer.github.com/v3/projects/columns/#list-project-columns\n * @param {Requestable.callback} [cb] - will receive the list of columns\n * @return {Promise} - the promise for the http request\n */\n listProjectColumns(cb) {\n return this._requestAllPages(`/projects/${this.__id}/columns`, null, cb);\n }\n\n /**\n * Get information about a column\n * @see https://developer.github.com/v3/projects/columns/#get-a-project-column\n * @param {string} colId - the id of the column\n * @param {Requestable.callback} cb - will receive the column information\n * @return {Promise} - the promise for the http request\n */\n getProjectColumn(colId, cb) {\n return this._request('GET', `/projects/columns/${colId}`, null, cb);\n }\n\n /**\n * Create a new column\n * @see https://developer.github.com/v3/projects/columns/#create-a-project-column\n * @param {Object} options - the description of the column\n * @param {Requestable.callback} cb - will receive the newly created column\n * @return {Promise} - the promise for the http request\n */\n createProjectColumn(options, cb) {\n return this._request('POST', `/projects/${this.__id}/columns`, options, cb);\n }\n\n /**\n * Edit a column\n * @see https://developer.github.com/v3/projects/columns/#update-a-project-column\n * @param {string} colId - the column id\n * @param {Object} options - the description of the column\n * @param {Requestable.callback} cb - will receive the modified column\n * @return {Promise} - the promise for the http request\n */\n updateProjectColumn(colId, options, cb) {\n return this._request('PATCH', `/projects/columns/${colId}`, options, cb);\n }\n\n /**\n * Delete a column\n * @see https://developer.github.com/v3/projects/columns/#delete-a-project-column\n * @param {string} colId - the column to be deleted\n * @param {Requestable.callback} cb - will receive true if the operation is successful\n * @return {Promise} - the promise for the http request\n */\n deleteProjectColumn(colId, cb) {\n return this._request('DELETE', `/projects/columns/${colId}`, null, cb);\n }\n\n /**\n * Move a column\n * @see https://developer.github.com/v3/projects/columns/#move-a-project-column\n * @param {string} colId - the column to be moved\n * @param {string} position - can be one of first, last, or after:,\n * where is the id value of a column in the same project.\n * @param {Requestable.callback} cb - will receive true if the operation is successful\n * @return {Promise} - the promise for the http request\n */\n moveProjectColumn(colId, position, cb) {\n return this._request(\n 'POST',\n `/projects/columns/${colId}/moves`,\n {position: position},\n cb\n );\n }\n\n /**\n * Get information about all cards of a project\n * @see https://developer.github.com/v3/projects/cards/#list-project-cards\n * @param {Requestable.callback} [cb] - will receive the list of cards\n * @return {Promise} - the promise for the http request\n */\n listProjectCards(cb) {\n return this.listProjectColumns()\n .then(({data}) => {\n return Promise.all(data.map((column) => {\n return this._requestAllPages(`/projects/columns/${column.id}/cards`, null);\n }));\n }).then((cardsInColumns) => {\n const cards = cardsInColumns.reduce((prev, {data}) => {\n prev.push(...data);\n return prev;\n }, []);\n if (cb) {\n cb(null, cards);\n }\n return cards;\n }).catch((err) => {\n if (cb) {\n cb(err);\n return;\n }\n throw err;\n });\n }\n\n /**\n * Get information about all cards of a column\n * @see https://developer.github.com/v3/projects/cards/#list-project-cards\n * @param {string} colId - the id of the column\n * @param {Requestable.callback} [cb] - will receive the list of cards\n * @return {Promise} - the promise for the http request\n */\n listColumnCards(colId, cb) {\n return this._requestAllPages(`/projects/columns/${colId}/cards`, null, cb);\n }\n\n /**\n * Get information about a card\n * @see https://developer.github.com/v3/projects/cards/#get-a-project-card\n * @param {string} cardId - the id of the card\n * @param {Requestable.callback} cb - will receive the card information\n * @return {Promise} - the promise for the http request\n */\n getProjectCard(cardId, cb) {\n return this._request('GET', `/projects/columns/cards/${cardId}`, null, cb);\n }\n\n /**\n * Create a new card\n * @see https://developer.github.com/v3/projects/cards/#create-a-project-card\n * @param {string} colId - the column id\n * @param {Object} options - the description of the card\n * @param {Requestable.callback} cb - will receive the newly created card\n * @return {Promise} - the promise for the http request\n */\n createProjectCard(colId, options, cb) {\n return this._request('POST', `/projects/columns/${colId}/cards`, options, cb);\n }\n\n /**\n * Edit a card\n * @see https://developer.github.com/v3/projects/cards/#update-a-project-card\n * @param {string} cardId - the card id\n * @param {Object} options - the description of the card\n * @param {Requestable.callback} cb - will receive the modified card\n * @return {Promise} - the promise for the http request\n */\n updateProjectCard(cardId, options, cb) {\n return this._request('PATCH', `/projects/columns/cards/${cardId}`, options, cb);\n }\n\n /**\n * Delete a card\n * @see https://developer.github.com/v3/projects/cards/#delete-a-project-card\n * @param {string} cardId - the card to be deleted\n * @param {Requestable.callback} cb - will receive true if the operation is successful\n * @return {Promise} - the promise for the http request\n */\n deleteProjectCard(cardId, cb) {\n return this._request('DELETE', `/projects/columns/cards/${cardId}`, null, cb);\n }\n\n /**\n * Move a card\n * @see https://developer.github.com/v3/projects/cards/#move-a-project-card\n * @param {string} cardId - the card to be moved\n * @param {string} position - can be one of top, bottom, or after:,\n * where is the id value of a card in the same project.\n * @param {string} colId - the id value of a column in the same project.\n * @param {Requestable.callback} cb - will receive true if the operation is successful\n * @return {Promise} - the promise for the http request\n */\n moveProjectCard(cardId, position, colId, cb) {\n return this._request(\n 'POST',\n `/projects/columns/cards/${cardId}/moves`,\n {position: position, column_id: colId}, // eslint-disable-line camelcase\n cb\n );\n }\n}\n\nmodule.exports = Project;\n","/**\n * @file\n * @copyright 2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n * Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\n\n/**\n * RateLimit allows users to query their rate-limit status\n */\nclass RateLimit extends Requestable {\n /**\n * construct a RateLimit\n * @param {Requestable.auth} auth - the credentials to authenticate to GitHub\n * @param {string} [apiBase] - the base Github API URL\n * @return {Promise} - the promise for the http request\n */\n constructor(auth, apiBase) {\n super(auth, apiBase);\n }\n\n /**\n * Query the current rate limit\n * @see https://developer.github.com/v3/rate_limit/\n * @param {Requestable.callback} [cb] - will receive the rate-limit data\n * @return {Promise} - the promise for the http request\n */\n getRateLimit(cb) {\n return this._request('GET', '/rate_limit', null, cb);\n }\n}\n\nmodule.exports = RateLimit;\n","/**\n * @file\n * @copyright 2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n * Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\nimport Utf8 from 'utf8';\nimport {\n Base64,\n} from 'js-base64';\nimport debug from 'debug';\nconst log = debug('github:repository');\n\n/**\n * Respository encapsulates the functionality to create, query, and modify files.\n */\nclass Repository extends Requestable {\n /**\n * Create a Repository.\n * @param {string} fullname - the full name of the repository\n * @param {Requestable.auth} [auth] - information required to authenticate to Github\n * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n */\n constructor(fullname, auth, apiBase) {\n super(auth, apiBase);\n this.__fullname = fullname;\n this.__currentTree = {\n branch: null,\n sha: null,\n };\n }\n\n /**\n * Get a reference\n * @see https://developer.github.com/v3/git/refs/#get-a-reference\n * @param {string} ref - the reference to get\n * @param {Requestable.callback} [cb] - will receive the reference's refSpec or a list of refSpecs that match `ref`\n * @return {Promise} - the promise for the http request\n */\n getRef(ref, cb) {\n return this._request('GET', `/repos/${this.__fullname}/git/refs/${ref}`, null, cb);\n }\n\n /**\n * Create a reference\n * @see https://developer.github.com/v3/git/refs/#create-a-reference\n * @param {Object} options - the object describing the ref\n * @param {Requestable.callback} [cb] - will receive the ref\n * @return {Promise} - the promise for the http request\n */\n createRef(options, cb) {\n return this._request('POST', `/repos/${this.__fullname}/git/refs`, options, cb);\n }\n\n /**\n * Delete a reference\n * @see https://developer.github.com/v3/git/refs/#delete-a-reference\n * @param {string} ref - the name of the ref to delte\n * @param {Requestable.callback} [cb] - will receive true if the request is successful\n * @return {Promise} - the promise for the http request\n */\n deleteRef(ref, cb) {\n return this._request('DELETE', `/repos/${this.__fullname}/git/refs/${ref}`, null, cb);\n }\n\n /**\n * Delete a repository\n * @see https://developer.github.com/v3/repos/#delete-a-repository\n * @param {Requestable.callback} [cb] - will receive true if the request is successful\n * @return {Promise} - the promise for the http request\n */\n deleteRepo(cb) {\n return this._request('DELETE', `/repos/${this.__fullname}`, null, cb);\n }\n\n /**\n * List the tags on a repository\n * @see https://developer.github.com/v3/repos/#list-tags\n * @param {Requestable.callback} [cb] - will receive the tag data\n * @return {Promise} - the promise for the http request\n */\n listTags(cb) {\n return this._request('GET', `/repos/${this.__fullname}/tags`, null, cb);\n }\n\n /**\n * List the open pull requests on the repository\n * @see https://developer.github.com/v3/pulls/#list-pull-requests\n * @param {Object} options - options to filter the search\n * @param {Requestable.callback} [cb] - will receive the list of PRs\n * @return {Promise} - the promise for the http request\n */\n listPullRequests(options, cb) {\n options = options || {};\n return this._request('GET', `/repos/${this.__fullname}/pulls`, options, cb);\n }\n\n /**\n * Get information about a specific pull request\n * @see https://developer.github.com/v3/pulls/#get-a-single-pull-request\n * @param {number} number - the PR you wish to fetch\n * @param {Requestable.callback} [cb] - will receive the PR from the API\n * @return {Promise} - the promise for the http request\n */\n getPullRequest(number, cb) {\n return this._request('GET', `/repos/${this.__fullname}/pulls/${number}`, null, cb);\n }\n\n /**\n * List the files of a specific pull request\n * @see https://developer.github.com/v3/pulls/#list-pull-requests-files\n * @param {number|string} number - the PR you wish to fetch\n * @param {Requestable.callback} [cb] - will receive the list of files from the API\n * @return {Promise} - the promise for the http request\n */\n listPullRequestFiles(number, cb) {\n return this._request('GET', `/repos/${this.__fullname}/pulls/${number}/files`, null, cb);\n }\n\n /**\n * Compare two branches/commits/repositories\n * @see https://developer.github.com/v3/repos/commits/#compare-two-commits\n * @param {string} base - the base commit\n * @param {string} head - the head commit\n * @param {Requestable.callback} cb - will receive the comparison\n * @return {Promise} - the promise for the http request\n */\n compareBranches(base, head, cb) {\n return this._request('GET', `/repos/${this.__fullname}/compare/${base}...${head}`, null, cb);\n }\n\n /**\n * List all the branches for the repository\n * @see https://developer.github.com/v3/repos/#list-branches\n * @param {Requestable.callback} cb - will receive the list of branches\n * @return {Promise} - the promise for the http request\n */\n listBranches(cb) {\n return this._request('GET', `/repos/${this.__fullname}/branches`, null, cb);\n }\n\n /**\n * Get a raw blob from the repository\n * @see https://developer.github.com/v3/git/blobs/#get-a-blob\n * @param {string} sha - the sha of the blob to fetch\n * @param {Requestable.callback} cb - will receive the blob from the API\n * @return {Promise} - the promise for the http request\n */\n getBlob(sha, cb) {\n return this._request('GET', `/repos/${this.__fullname}/git/blobs/${sha}`, null, cb, 'raw');\n }\n\n /**\n * Get a single branch\n * @see https://developer.github.com/v3/repos/branches/#get-branch\n * @param {string} branch - the name of the branch to fetch\n * @param {Requestable.callback} cb - will receive the branch from the API\n * @returns {Promise} - the promise for the http request\n */\n getBranch(branch, cb) {\n return this._request('GET', `/repos/${this.__fullname}/branches/${branch}`, null, cb);\n }\n\n /**\n * Get a commit from the repository\n * @see https://developer.github.com/v3/repos/commits/#get-a-single-commit\n * @param {string} sha - the sha for the commit to fetch\n * @param {Requestable.callback} cb - will receive the commit data\n * @return {Promise} - the promise for the http request\n */\n getCommit(sha, cb) {\n return this._request('GET', `/repos/${this.__fullname}/git/commits/${sha}`, null, cb);\n }\n\n /**\n * List the commits on a repository, optionally filtering by path, author or time range\n * @see https://developer.github.com/v3/repos/commits/#list-commits-on-a-repository\n * @param {Object} [options] - the filtering options for commits\n * @param {string} [options.sha] - the SHA or branch to start from\n * @param {string} [options.path] - the path to search on\n * @param {string} [options.author] - the commit author\n * @param {(Date|string)} [options.since] - only commits after this date will be returned\n * @param {(Date|string)} [options.until] - only commits before this date will be returned\n * @param {Requestable.callback} cb - will receive the list of commits found matching the criteria\n * @return {Promise} - the promise for the http request\n */\n listCommits(options, cb) {\n options = options || {};\n\n options.since = this._dateToISO(options.since);\n options.until = this._dateToISO(options.until);\n\n return this._request('GET', `/repos/${this.__fullname}/commits`, options, cb);\n }\n\n /**\n * Gets a single commit information for a repository\n * @see https://developer.github.com/v3/repos/commits/#get-a-single-commit\n * @param {string} ref - the reference for the commit-ish\n * @param {Requestable.callback} cb - will receive the commit information\n * @return {Promise} - the promise for the http request\n */\n getSingleCommit(ref, cb) {\n ref = ref || '';\n return this._request('GET', `/repos/${this.__fullname}/commits/${ref}`, null, cb);\n }\n\n /**\n * Get tha sha for a particular object in the repository. This is a convenience function\n * @see https://developer.github.com/v3/repos/contents/#get-contents\n * @param {string} [branch] - the branch to look in, or the repository's default branch if omitted\n * @param {string} path - the path of the file or directory\n * @param {Requestable.callback} cb - will receive a description of the requested object, including a `SHA` property\n * @return {Promise} - the promise for the http request\n */\n getSha(branch, path, cb) {\n branch = branch ? `?ref=${branch}` : '';\n return this._request('GET', `/repos/${this.__fullname}/contents/${path}${branch}`, null, cb);\n }\n\n /**\n * List the commit statuses for a particular sha, branch, or tag\n * @see https://developer.github.com/v3/repos/statuses/#list-statuses-for-a-specific-ref\n * @param {string} sha - the sha, branch, or tag to get statuses for\n * @param {Requestable.callback} cb - will receive the list of statuses\n * @return {Promise} - the promise for the http request\n */\n listStatuses(sha, cb) {\n return this._request('GET', `/repos/${this.__fullname}/commits/${sha}/statuses`, null, cb);\n }\n\n /**\n * Get a description of a git tree\n * @see https://developer.github.com/v3/git/trees/#get-a-tree\n * @param {string} treeSHA - the SHA of the tree to fetch\n * @param {Requestable.callback} cb - will receive the callback data\n * @return {Promise} - the promise for the http request\n */\n getTree(treeSHA, cb) {\n return this._request('GET', `/repos/${this.__fullname}/git/trees/${treeSHA}`, null, cb);\n }\n\n /**\n * Create a blob\n * @see https://developer.github.com/v3/git/blobs/#create-a-blob\n * @param {(string|Buffer|Blob)} content - the content to add to the repository\n * @param {Requestable.callback} cb - will receive the details of the created blob\n * @return {Promise} - the promise for the http request\n */\n createBlob(content, cb) {\n let postBody = this._getContentObject(content);\n\n log('sending content', postBody);\n return this._request('POST', `/repos/${this.__fullname}/git/blobs`, postBody, cb);\n }\n\n /**\n * Get the object that represents the provided content\n * @param {string|Buffer|Blob} content - the content to send to the server\n * @return {Object} the representation of `content` for the GitHub API\n */\n _getContentObject(content) {\n if (typeof content === 'string') {\n log('contet is a string');\n return {\n content: Utf8.encode(content),\n encoding: 'utf-8',\n };\n\n } else if (typeof Buffer !== 'undefined' && content instanceof Buffer) {\n log('We appear to be in Node');\n return {\n content: content.toString('base64'),\n encoding: 'base64',\n };\n\n } else if (typeof Blob !== 'undefined' && content instanceof Blob) {\n log('We appear to be in the browser');\n return {\n content: Base64.encode(content),\n encoding: 'base64',\n };\n\n } else { // eslint-disable-line\n log(`Not sure what this content is: ${typeof content}, ${JSON.stringify(content)}`);\n throw new Error('Unknown content passed to postBlob. Must be string or Buffer (node) or Blob (web)');\n }\n }\n\n /**\n * Update a tree in Git\n * @see https://developer.github.com/v3/git/trees/#create-a-tree\n * @param {string} baseTreeSHA - the SHA of the tree to update\n * @param {string} path - the path for the new file\n * @param {string} blobSHA - the SHA for the blob to put at `path`\n * @param {Requestable.callback} cb - will receive the new tree that is created\n * @return {Promise} - the promise for the http request\n * @deprecated use {@link Repository#createTree} instead\n */\n updateTree(baseTreeSHA, path, blobSHA, cb) {\n let newTree = {\n base_tree: baseTreeSHA, // eslint-disable-line\n tree: [{\n path: path,\n sha: blobSHA,\n mode: '100644',\n type: 'blob',\n }],\n };\n\n return this._request('POST', `/repos/${this.__fullname}/git/trees`, newTree, cb);\n }\n\n /**\n * Create a new tree in git\n * @see https://developer.github.com/v3/git/trees/#create-a-tree\n * @param {Object} tree - the tree to create\n * @param {string} baseSHA - the root sha of the tree\n * @param {Requestable.callback} cb - will receive the new tree that is created\n * @return {Promise} - the promise for the http request\n */\n createTree(tree, baseSHA, cb) {\n return this._request('POST', `/repos/${this.__fullname}/git/trees`, {\n tree,\n base_tree: baseSHA, // eslint-disable-line camelcase\n }, cb);\n }\n\n /**\n * Add a commit to the repository\n * @see https://developer.github.com/v3/git/commits/#create-a-commit\n * @param {string} parent - the SHA of the parent commit\n * @param {string} tree - the SHA of the tree for this commit\n * @param {string} message - the commit message\n * @param {Requestable.callback} cb - will receive the commit that is created\n * @return {Promise} - the promise for the http request\n */\n commit(parent, tree, message, cb) {\n let data = {\n message,\n tree,\n parents: [parent],\n };\n\n return this._request('POST', `/repos/${this.__fullname}/git/commits`, data, cb)\n .then((response) => {\n this.__currentTree.sha = response.data.sha; // Update latest commit\n return response;\n });\n }\n\n /**\n * Update a ref\n * @see https://developer.github.com/v3/git/refs/#update-a-reference\n * @param {string} ref - the ref to update\n * @param {string} commitSHA - the SHA to point the reference to\n * @param {boolean} force - indicates whether to force or ensure a fast-forward update\n * @param {Requestable.callback} cb - will receive the updated ref back\n * @return {Promise} - the promise for the http request\n */\n updateHead(ref, commitSHA, force, cb) {\n return this._request('PATCH', `/repos/${this.__fullname}/git/refs/${ref}`, {\n sha: commitSHA,\n force: force,\n }, cb);\n }\n\n /**\n * Update commit status\n * @see https://developer.github.com/v3/repos/statuses/\n * @param {string} commitSHA - the SHA of the commit that should be updated\n * @param {object} options - Commit status parameters\n * @param {string} options.state - The state of the status. Can be one of: pending, success, error, or failure.\n * @param {string} [options.target_url] - The target URL to associate with this status.\n * @param {string} [options.description] - A short description of the status.\n * @param {string} [options.context] - A string label to differentiate this status among CI systems.\n * @param {Requestable.callback} cb - will receive the updated commit back\n * @return {Promise} - the promise for the http request\n */\n updateStatus(commitSHA, options, cb) {\n return this._request('POST', `/repos/${this.__fullname}/statuses/${commitSHA}`, options, cb);\n }\n\n /**\n * Update repository information\n * @see https://developer.github.com/v3/repos/#edit\n * @param {object} options - New parameters that will be set to the repository\n * @param {string} options.name - Name of the repository\n * @param {string} [options.description] - A short description of the repository\n * @param {string} [options.homepage] - A URL with more information about the repository\n * @param {boolean} [options.private] - Either true to make the repository private, or false to make it public.\n * @param {boolean} [options.has_issues] - Either true to enable issues for this repository, false to disable them.\n * @param {boolean} [options.has_wiki] - Either true to enable the wiki for this repository, false to disable it.\n * @param {boolean} [options.has_downloads] - Either true to enable downloads, false to disable them.\n * @param {string} [options.default_branch] - Updates the default branch for this repository.\n * @param {Requestable.callback} cb - will receive the updated repository back\n * @return {Promise} - the promise for the http request\n */\n updateRepository(options, cb) {\n return this._request('PATCH', `/repos/${this.__fullname}`, options, cb);\n }\n\n /**\n * Get information about the repository\n * @see https://developer.github.com/v3/repos/#get\n * @param {Requestable.callback} cb - will receive the information about the repository\n * @return {Promise} - the promise for the http request\n */\n getDetails(cb) {\n return this._request('GET', `/repos/${this.__fullname}`, null, cb);\n }\n\n /**\n * List the contributors to the repository\n * @see https://developer.github.com/v3/repos/#list-contributors\n * @param {Requestable.callback} cb - will receive the list of contributors\n * @return {Promise} - the promise for the http request\n */\n getContributors(cb) {\n return this._request('GET', `/repos/${this.__fullname}/contributors`, null, cb);\n }\n\n /**\n * List the contributor stats to the repository\n * @see https://developer.github.com/v3/repos/#list-contributors\n * @param {Requestable.callback} cb - will receive the list of contributors\n * @return {Promise} - the promise for the http request\n */\n getContributorStats(cb) {\n return this._request('GET', `/repos/${this.__fullname}/stats/contributors`, null, cb);\n }\n\n /**\n * List the users who are collaborators on the repository. The currently authenticated user must have\n * push access to use this method\n * @see https://developer.github.com/v3/repos/collaborators/#list-collaborators\n * @param {Requestable.callback} cb - will receive the list of collaborators\n * @return {Promise} - the promise for the http request\n */\n getCollaborators(cb) {\n return this._request('GET', `/repos/${this.__fullname}/collaborators`, null, cb);\n }\n\n /**\n * Check if a user is a collaborator on the repository\n * @see https://developer.github.com/v3/repos/collaborators/#check-if-a-user-is-a-collaborator\n * @param {string} username - the user to check\n * @param {Requestable.callback} cb - will receive true if the user is a collaborator and false if they are not\n * @return {Promise} - the promise for the http request {Boolean} [description]\n */\n isCollaborator(username, cb) {\n return this._request('GET', `/repos/${this.__fullname}/collaborators/${username}`, null, cb);\n }\n\n /**\n * Get the contents of a repository\n * @see https://developer.github.com/v3/repos/contents/#get-contents\n * @param {string} ref - the ref to check\n * @param {string} path - the path containing the content to fetch\n * @param {boolean} raw - `true` if the results should be returned raw instead of GitHub's normalized format\n * @param {Requestable.callback} cb - will receive the fetched data\n * @return {Promise} - the promise for the http request\n */\n getContents(ref, path, raw, cb) {\n path = path ? `${encodeURI(path)}` : '';\n return this._request('GET', `/repos/${this.__fullname}/contents/${path}`, {\n ref,\n }, cb, raw);\n }\n\n /**\n * Get the README of a repository\n * @see https://developer.github.com/v3/repos/contents/#get-the-readme\n * @param {string} ref - the ref to check\n * @param {boolean} raw - `true` if the results should be returned raw instead of GitHub's normalized format\n * @param {Requestable.callback} cb - will receive the fetched data\n * @return {Promise} - the promise for the http request\n */\n getReadme(ref, raw, cb) {\n return this._request('GET', `/repos/${this.__fullname}/readme`, {\n ref,\n }, cb, raw);\n }\n\n /**\n * Fork a repository\n * @see https://developer.github.com/v3/repos/forks/#create-a-fork\n * @param {Requestable.callback} cb - will receive the information about the newly created fork\n * @return {Promise} - the promise for the http request\n */\n fork(cb) {\n return this._request('POST', `/repos/${this.__fullname}/forks`, null, cb);\n }\n\n /**\n * List a repository's forks\n * @see https://developer.github.com/v3/repos/forks/#list-forks\n * @param {Requestable.callback} cb - will receive the list of repositories forked from this one\n * @return {Promise} - the promise for the http request\n */\n listForks(cb) {\n return this._request('GET', `/repos/${this.__fullname}/forks`, null, cb);\n }\n\n /**\n * Create a new branch from an existing branch.\n * @param {string} [oldBranch=master] - the name of the existing branch\n * @param {string} newBranch - the name of the new branch\n * @param {Requestable.callback} cb - will receive the commit data for the head of the new branch\n * @return {Promise} - the promise for the http request\n */\n createBranch(oldBranch, newBranch, cb) {\n if (typeof newBranch === 'function') {\n cb = newBranch;\n newBranch = oldBranch;\n oldBranch = 'master';\n }\n\n return this.getRef(`heads/${oldBranch}`)\n .then((response) => {\n let sha = response.data.object.sha;\n return this.createRef({\n sha,\n ref: `refs/heads/${newBranch}`,\n }, cb);\n });\n }\n\n /**\n * Create a new pull request\n * @see https://developer.github.com/v3/pulls/#create-a-pull-request\n * @param {Object} options - the pull request description\n * @param {Requestable.callback} cb - will receive the new pull request\n * @return {Promise} - the promise for the http request\n */\n createPullRequest(options, cb) {\n return this._request('POST', `/repos/${this.__fullname}/pulls`, options, cb);\n }\n\n /**\n * Update a pull request\n * @see https://developer.github.com/v3/pulls/#update-a-pull-request\n * @param {number|string} number - the number of the pull request to update\n * @param {Object} options - the pull request description\n * @param {Requestable.callback} [cb] - will receive the pull request information\n * @return {Promise} - the promise for the http request\n */\n updatePullRequest(number, options, cb) {\n return this._request('PATCH', `/repos/${this.__fullname}/pulls/${number}`, options, cb);\n }\n\n /**\n * List the hooks for the repository\n * @see https://developer.github.com/v3/repos/hooks/#list-hooks\n * @param {Requestable.callback} cb - will receive the list of hooks\n * @return {Promise} - the promise for the http request\n */\n listHooks(cb) {\n return this._request('GET', `/repos/${this.__fullname}/hooks`, null, cb);\n }\n\n /**\n * Get a hook for the repository\n * @see https://developer.github.com/v3/repos/hooks/#get-single-hook\n * @param {number} id - the id of the webook\n * @param {Requestable.callback} cb - will receive the details of the webook\n * @return {Promise} - the promise for the http request\n */\n getHook(id, cb) {\n return this._request('GET', `/repos/${this.__fullname}/hooks/${id}`, null, cb);\n }\n\n /**\n * Add a new hook to the repository\n * @see https://developer.github.com/v3/repos/hooks/#create-a-hook\n * @param {Object} options - the configuration describing the new hook\n * @param {Requestable.callback} cb - will receive the new webhook\n * @return {Promise} - the promise for the http request\n */\n createHook(options, cb) {\n return this._request('POST', `/repos/${this.__fullname}/hooks`, options, cb);\n }\n\n /**\n * Edit an existing webhook\n * @see https://developer.github.com/v3/repos/hooks/#edit-a-hook\n * @param {number} id - the id of the webhook\n * @param {Object} options - the new description of the webhook\n * @param {Requestable.callback} cb - will receive the updated webhook\n * @return {Promise} - the promise for the http request\n */\n updateHook(id, options, cb) {\n return this._request('PATCH', `/repos/${this.__fullname}/hooks/${id}`, options, cb);\n }\n\n /**\n * Delete a webhook\n * @see https://developer.github.com/v3/repos/hooks/#delete-a-hook\n * @param {number} id - the id of the webhook to be deleted\n * @param {Requestable.callback} cb - will receive true if the call is successful\n * @return {Promise} - the promise for the http request\n */\n deleteHook(id, cb) {\n return this._request('DELETE', `/repos/${this.__fullname}/hooks/${id}`, null, cb);\n }\n\n /**\n * List the deploy keys for the repository\n * @see https://developer.github.com/v3/repos/keys/#list-deploy-keys\n * @param {Requestable.callback} cb - will receive the list of deploy keys\n * @return {Promise} - the promise for the http request\n */\n listKeys(cb) {\n return this._request('GET', `/repos/${this.__fullname}/keys`, null, cb);\n }\n\n /**\n * Get a deploy key for the repository\n * @see https://developer.github.com/v3/repos/keys/#get-a-deploy-key\n * @param {number} id - the id of the deploy key\n * @param {Requestable.callback} cb - will receive the details of the deploy key\n * @return {Promise} - the promise for the http request\n */\n getKey(id, cb) {\n return this._request('GET', `/repos/${this.__fullname}/keys/${id}`, null, cb);\n }\n\n /**\n * Add a new deploy key to the repository\n * @see https://developer.github.com/v3/repos/keys/#add-a-new-deploy-key\n * @param {Object} options - the configuration describing the new deploy key\n * @param {Requestable.callback} cb - will receive the new deploy key\n * @return {Promise} - the promise for the http request\n */\n createKey(options, cb) {\n return this._request('POST', `/repos/${this.__fullname}/keys`, options, cb);\n }\n\n /**\n * Delete a deploy key\n * @see https://developer.github.com/v3/repos/keys/#remove-a-deploy-key\n * @param {number} id - the id of the deploy key to be deleted\n * @param {Requestable.callback} cb - will receive true if the call is successful\n * @return {Promise} - the promise for the http request\n */\n deleteKey(id, cb) {\n return this._request('DELETE', `/repos/${this.__fullname}/keys/${id}`, null, cb);\n }\n\n /**\n * Delete a file from a branch\n * @see https://developer.github.com/v3/repos/contents/#delete-a-file\n * @param {string} branch - the branch to delete from, or the default branch if not specified\n * @param {string} path - the path of the file to remove\n * @param {Requestable.callback} cb - will receive the commit in which the delete occurred\n * @return {Promise} - the promise for the http request\n */\n deleteFile(branch, path, cb) {\n return this.getSha(branch, path)\n .then((response) => {\n const deleteCommit = {\n message: `Delete the file at '${path}'`,\n sha: response.data.sha,\n branch,\n };\n return this._request('DELETE', `/repos/${this.__fullname}/contents/${path}`, deleteCommit, cb);\n });\n }\n\n /**\n * Change all references in a repo from oldPath to new_path\n * @param {string} branch - the branch to carry out the reference change, or the default branch if not specified\n * @param {string} oldPath - original path\n * @param {string} newPath - new reference path\n * @param {Requestable.callback} cb - will receive the commit in which the move occurred\n * @return {Promise} - the promise for the http request\n */\n move(branch, oldPath, newPath, cb) {\n let oldSha;\n return this.getRef(`heads/${branch}`)\n .then(({data: {object}}) => this.getTree(`${object.sha}?recursive=true`))\n .then(({data: {tree, sha}}) => {\n oldSha = sha;\n let newTree = tree.map((ref) => {\n if (ref.path === oldPath) {\n ref.path = newPath;\n }\n if (ref.type === 'tree') {\n delete ref.sha;\n }\n return ref;\n });\n return this.createTree(newTree);\n })\n .then(({data: tree}) => this.commit(oldSha, tree.sha, `Renamed '${oldPath}' to '${newPath}'`))\n .then(({data: commit}) => this.updateHead(`heads/${branch}`, commit.sha, true, cb));\n }\n\n /**\n * Write a file to the repository\n * @see https://developer.github.com/v3/repos/contents/#update-a-file\n * @param {string} branch - the name of the branch\n * @param {string} path - the path for the file\n * @param {string} content - the contents of the file\n * @param {string} message - the commit message\n * @param {Object} [options] - commit options\n * @param {Object} [options.author] - the author of the commit\n * @param {Object} [options.commiter] - the committer\n * @param {boolean} [options.encode] - true if the content should be base64 encoded\n * @param {Requestable.callback} cb - will receive the new commit\n * @return {Promise} - the promise for the http request\n */\n writeFile(branch, path, content, message, options, cb) {\n if (typeof options === 'function') {\n cb = options;\n options = {};\n }\n let filePath = path ? encodeURI(path) : '';\n let shouldEncode = options.encode !== false;\n let commit = {\n branch,\n message,\n author: options.author,\n committer: options.committer,\n content: shouldEncode ? Base64.encode(content) : content,\n };\n\n return this.getSha(branch, filePath)\n .then((response) => {\n commit.sha = response.data.sha;\n return this._request('PUT', `/repos/${this.__fullname}/contents/${filePath}`, commit, cb);\n }, () => {\n return this._request('PUT', `/repos/${this.__fullname}/contents/${filePath}`, commit, cb);\n });\n }\n\n /**\n * Check if a repository is starred by you\n * @see https://developer.github.com/v3/activity/starring/#check-if-you-are-starring-a-repository\n * @param {Requestable.callback} cb - will receive true if the repository is starred and false if the repository\n * is not starred\n * @return {Promise} - the promise for the http request {Boolean} [description]\n */\n isStarred(cb) {\n return this._request204or404(`/user/starred/${this.__fullname}`, null, cb);\n }\n\n /**\n * Star a repository\n * @see https://developer.github.com/v3/activity/starring/#star-a-repository\n * @param {Requestable.callback} cb - will receive true if the repository is starred\n * @return {Promise} - the promise for the http request\n */\n star(cb) {\n return this._request('PUT', `/user/starred/${this.__fullname}`, null, cb);\n }\n\n /**\n * Unstar a repository\n * @see https://developer.github.com/v3/activity/starring/#unstar-a-repository\n * @param {Requestable.callback} cb - will receive true if the repository is unstarred\n * @return {Promise} - the promise for the http request\n */\n unstar(cb) {\n return this._request('DELETE', `/user/starred/${this.__fullname}`, null, cb);\n }\n\n /**\n * Create a new release\n * @see https://developer.github.com/v3/repos/releases/#create-a-release\n * @param {Object} options - the description of the release\n * @param {Requestable.callback} cb - will receive the newly created release\n * @return {Promise} - the promise for the http request\n */\n createRelease(options, cb) {\n return this._request('POST', `/repos/${this.__fullname}/releases`, options, cb);\n }\n\n /**\n * Edit a release\n * @see https://developer.github.com/v3/repos/releases/#edit-a-release\n * @param {string} id - the id of the release\n * @param {Object} options - the description of the release\n * @param {Requestable.callback} cb - will receive the modified release\n * @return {Promise} - the promise for the http request\n */\n updateRelease(id, options, cb) {\n return this._request('PATCH', `/repos/${this.__fullname}/releases/${id}`, options, cb);\n }\n\n /**\n * Get information about all releases\n * @see https://developer.github.com/v3/repos/releases/#list-releases-for-a-repository\n * @param {Requestable.callback} cb - will receive the release information\n * @return {Promise} - the promise for the http request\n */\n listReleases(cb) {\n return this._request('GET', `/repos/${this.__fullname}/releases`, null, cb);\n }\n\n /**\n * Get information about a release\n * @see https://developer.github.com/v3/repos/releases/#get-a-single-release\n * @param {string} id - the id of the release\n * @param {Requestable.callback} cb - will receive the release information\n * @return {Promise} - the promise for the http request\n */\n getRelease(id, cb) {\n return this._request('GET', `/repos/${this.__fullname}/releases/${id}`, null, cb);\n }\n\n /**\n * Delete a release\n * @see https://developer.github.com/v3/repos/releases/#delete-a-release\n * @param {string} id - the release to be deleted\n * @param {Requestable.callback} cb - will receive true if the operation is successful\n * @return {Promise} - the promise for the http request\n */\n deleteRelease(id, cb) {\n return this._request('DELETE', `/repos/${this.__fullname}/releases/${id}`, null, cb);\n }\n\n /**\n * Merge a pull request\n * @see https://developer.github.com/v3/pulls/#merge-a-pull-request-merge-button\n * @param {number|string} number - the number of the pull request to merge\n * @param {Object} options - the merge options for the pull request\n * @param {Requestable.callback} [cb] - will receive the merge information if the operation is successful\n * @return {Promise} - the promise for the http request\n */\n mergePullRequest(number, options, cb) {\n return this._request('PUT', `/repos/${this.__fullname}/pulls/${number}/merge`, options, cb);\n }\n\n /**\n * Get information about all projects\n * @see https://developer.github.com/v3/projects/#list-repository-projects\n * @param {Requestable.callback} [cb] - will receive the list of projects\n * @return {Promise} - the promise for the http request\n */\n listProjects(cb) {\n return this._requestAllPages(`/repos/${this.__fullname}/projects`, {AcceptHeader: 'inertia-preview'}, cb);\n }\n\n /**\n * Create a new project\n * @see https://developer.github.com/v3/projects/#create-a-repository-project\n * @param {Object} options - the description of the project\n * @param {Requestable.callback} cb - will receive the newly created project\n * @return {Promise} - the promise for the http request\n */\n createProject(options, cb) {\n options = options || {};\n options.AcceptHeader = 'inertia-preview';\n return this._request('POST', `/repos/${this.__fullname}/projects`, options, cb);\n }\n\n}\n\nmodule.exports = Repository;\n","/**\n * @file\n * @copyright 2016 Yahoo Inc.\n * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n * Github.js is freely distributable.\n */\n\nimport axios from 'axios';\nimport debug from 'debug';\nimport {Base64} from 'js-base64';\n\nconst log = debug('github:request');\n\n/**\n * The error structure returned when a network call fails\n */\nclass ResponseError extends Error {\n /**\n * Construct a new ResponseError\n * @param {string} message - an message to return instead of the the default error message\n * @param {string} path - the requested path\n * @param {Object} response - the object returned by Axios\n */\n constructor(message, path, response) {\n super(message);\n this.path = path;\n this.request = response.config;\n this.response = (response || {}).response || response;\n this.status = response.status;\n }\n}\n\n/**\n * Requestable wraps the logic for making http requests to the API\n */\nclass Requestable {\n /**\n * Either a username and password or an oauth token for Github\n * @typedef {Object} Requestable.auth\n * @prop {string} [username] - the Github username\n * @prop {string} [password] - the user's password\n * @prop {token} [token] - an OAuth token\n */\n /**\n * Initialize the http internals.\n * @param {Requestable.auth} [auth] - the credentials to authenticate to Github. If auth is\n * not provided request will be made unauthenticated\n * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n * @param {string} [AcceptHeader=v3] - the accept header for the requests\n */\n constructor(auth, apiBase, AcceptHeader) {\n this.__apiBase = apiBase || 'https://api.github.com';\n this.__auth = {\n token: auth.token,\n username: auth.username,\n password: auth.password,\n };\n this.__AcceptHeader = AcceptHeader || 'v3';\n\n if (auth.token) {\n this.__authorizationHeader = 'token ' + auth.token;\n } else if (auth.username && auth.password) {\n this.__authorizationHeader = 'Basic ' + Base64.encode(auth.username + ':' + auth.password);\n }\n }\n\n /**\n * Compute the URL to use to make a request.\n * @private\n * @param {string} path - either a URL relative to the API base or an absolute URL\n * @return {string} - the URL to use\n */\n __getURL(path) {\n let url = path;\n\n if (path.indexOf('//') === -1) {\n url = this.__apiBase + path;\n }\n\n let newCacheBuster = 'timestamp=' + new Date().getTime();\n return url.replace(/(timestamp=\\d+)/, newCacheBuster);\n }\n\n /**\n * Compute the headers required for an API request.\n * @private\n * @param {boolean} raw - if the request should be treated as JSON or as a raw request\n * @param {string} AcceptHeader - the accept header for the request\n * @return {Object} - the headers to use in the request\n */\n __getRequestHeaders(raw, AcceptHeader) {\n let headers = {\n 'Content-Type': 'application/json;charset=UTF-8',\n 'Accept': 'application/vnd.github.' + (AcceptHeader || this.__AcceptHeader),\n };\n\n if (raw) {\n headers.Accept += '.raw';\n }\n headers.Accept += '+json';\n\n if (this.__authorizationHeader) {\n headers.Authorization = this.__authorizationHeader;\n }\n\n return headers;\n }\n\n /**\n * Sets the default options for API requests\n * @protected\n * @param {Object} [requestOptions={}] - the current options for the request\n * @return {Object} - the options to pass to the request\n */\n _getOptionsWithDefaults(requestOptions = {}) {\n if (!(requestOptions.visibility || requestOptions.affiliation)) {\n requestOptions.type = requestOptions.type || 'all';\n }\n requestOptions.sort = requestOptions.sort || 'updated';\n requestOptions.per_page = requestOptions.per_page || '100'; // eslint-disable-line\n\n return requestOptions;\n }\n\n /**\n * if a `Date` is passed to this function it will be converted to an ISO string\n * @param {*} date - the object to attempt to cooerce into an ISO date string\n * @return {string} - the ISO representation of `date` or whatever was passed in if it was not a date\n */\n _dateToISO(date) {\n if (date && (date instanceof Date)) {\n date = date.toISOString();\n }\n\n return date;\n }\n\n /**\n * A function that receives the result of the API request.\n * @callback Requestable.callback\n * @param {Requestable.Error} error - the error returned by the API or `null`\n * @param {(Object|true)} result - the data returned by the API or `true` if the API returns `204 No Content`\n * @param {Object} request - the raw {@linkcode https://github.com/mzabriskie/axios#response-schema Response}\n */\n /**\n * Make a request.\n * @param {string} method - the method for the request (GET, PUT, POST, DELETE)\n * @param {string} path - the path for the request\n * @param {*} [data] - the data to send to the server. For HTTP methods that don't have a body the data\n * will be sent as query parameters\n * @param {Requestable.callback} [cb] - the callback for the request\n * @param {boolean} [raw=false] - if the request should be sent as raw. If this is a falsy value then the\n * request will be made as JSON\n * @return {Promise} - the Promise for the http request\n */\n _request(method, path, data, cb, raw) {\n const url = this.__getURL(path);\n\n const AcceptHeader = (data || {}).AcceptHeader;\n if (AcceptHeader) {\n delete data.AcceptHeader;\n }\n const headers = this.__getRequestHeaders(raw, AcceptHeader);\n\n let queryParams = {};\n\n const shouldUseDataAsParams = data && (typeof data === 'object') && methodHasNoBody(method);\n if (shouldUseDataAsParams) {\n queryParams = data;\n data = undefined;\n }\n\n const config = {\n url: url,\n method: method,\n headers: headers,\n params: queryParams,\n data: data,\n responseType: raw ? 'text' : 'json',\n };\n\n log(`${config.method} to ${config.url}`);\n const requestPromise = axios(config).catch(callbackErrorOrThrow(cb, path));\n\n if (cb) {\n requestPromise.then((response) => {\n if (response.data && Object.keys(response.data).length > 0) {\n // When data has results\n cb(null, response.data, response);\n } else if (config.method !== 'GET' && Object.keys(response.data).length < 1) {\n // True when successful submit a request and receive a empty object\n cb(null, (response.status < 300), response);\n } else {\n cb(null, response.data, response);\n }\n });\n }\n\n return requestPromise;\n }\n\n /**\n * Make a request to an endpoint the returns 204 when true and 404 when false\n * @param {string} path - the path to request\n * @param {Object} data - any query parameters for the request\n * @param {Requestable.callback} cb - the callback that will receive `true` or `false`\n * @param {method} [method=GET] - HTTP Method to use\n * @return {Promise} - the promise for the http request\n */\n _request204or404(path, data, cb, method = 'GET') {\n return this._request(method, path, data)\n .then(function success(response) {\n if (cb) {\n cb(null, true, response);\n }\n return true;\n }, function failure(response) {\n if (response.response.status === 404) {\n if (cb) {\n cb(null, false, response);\n }\n return false;\n }\n\n if (cb) {\n cb(response);\n }\n throw response;\n });\n }\n\n /**\n * Make a request and fetch all the available data. Github will paginate responses so for queries\n * that might span multiple pages this method is preferred to {@link Requestable#request}\n * @param {string} path - the path to request\n * @param {Object} options - the query parameters to include\n * @param {Requestable.callback} [cb] - the function to receive the data. The returned data will always be an array.\n * @param {Object[]} results - the partial results. This argument is intended for interal use only.\n * @return {Promise} - a promise which will resolve when all pages have been fetched\n * @deprecated This will be folded into {@link Requestable#_request} in the 2.0 release.\n */\n _requestAllPages(path, options, cb, results) {\n results = results || [];\n\n return this._request('GET', path, options)\n .then((response) => {\n let thisGroup;\n if (response.data instanceof Array) {\n thisGroup = response.data;\n } else if (response.data.items instanceof Array) {\n thisGroup = response.data.items;\n } else {\n let message = `cannot figure out how to append ${response.data} to the result set`;\n throw new ResponseError(message, path, response);\n }\n results.push(...thisGroup);\n\n const nextUrl = getNextPage(response.headers.link);\n if (nextUrl && typeof options.page !== 'number') {\n log(`getting next page: ${nextUrl}`);\n return this._requestAllPages(nextUrl, options, cb, results);\n }\n\n if (cb) {\n cb(null, results, response);\n }\n\n response.data = results;\n return response;\n }).catch(callbackErrorOrThrow(cb, path));\n }\n}\n\nmodule.exports = Requestable;\n\n// ////////////////////////// //\n// Private helper functions //\n// ////////////////////////// //\nconst METHODS_WITH_NO_BODY = ['GET', 'HEAD', 'DELETE'];\nfunction methodHasNoBody(method) {\n return METHODS_WITH_NO_BODY.indexOf(method) !== -1;\n}\n\nfunction getNextPage(linksHeader = '') {\n const links = linksHeader.split(/\\s*,\\s*/); // splits and strips the urls\n return links.reduce(function(nextUrl, link) {\n if (link.search(/rel=\"next\"/) !== -1) {\n return (link.match(/<(.*)>/) || [])[1];\n }\n\n return nextUrl;\n }, undefined);\n}\n\nfunction callbackErrorOrThrow(cb, path) {\n return function handler(object) {\n let error;\n if (object.hasOwnProperty('config')) {\n const {response: {status, statusText}, config: {method, url}} = object;\n let message = (`${status} error making request ${method} ${url}: \"${statusText}\"`);\n error = new ResponseError(message, path, object);\n log(`${message} ${JSON.stringify(object.data)}`);\n } else {\n error = object;\n }\n if (cb) {\n log('going to error callback');\n cb(error);\n } else {\n log('throwing error');\n throw error;\n }\n };\n}\n","/**\n * @file\n * @copyright 2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n * Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\nimport debug from 'debug';\nconst log = debug('github:search');\n\n/**\n * Wrap the Search API\n */\nclass Search extends Requestable {\n /**\n * Create a Search\n * @param {Object} defaults - defaults for the search\n * @param {Requestable.auth} [auth] - information required to authenticate to Github\n * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n */\n constructor(defaults, auth, apiBase) {\n super(auth, apiBase);\n this.__defaults = this._getOptionsWithDefaults(defaults);\n }\n\n /**\n * Available search options\n * @see https://developer.github.com/v3/search/#parameters\n * @typedef {Object} Search.Params\n * @param {string} q - the query to make\n * @param {string} sort - the sort field, one of `stars`, `forks`, or `updated`.\n * Default is [best match](https://developer.github.com/v3/search/#ranking-search-results)\n * @param {string} order - the ordering, either `asc` or `desc`\n */\n /**\n * Perform a search on the GitHub API\n * @private\n * @param {string} path - the scope of the search\n * @param {Search.Params} [withOptions] - additional parameters for the search\n * @param {Requestable.callback} [cb] - will receive the results of the search\n * @return {Promise} - the promise for the http request\n */\n _search(path, withOptions = {}, cb = undefined) {\n let requestOptions = {};\n Object.keys(this.__defaults).forEach((prop) => {\n requestOptions[prop] = this.__defaults[prop];\n });\n Object.keys(withOptions).forEach((prop) => {\n requestOptions[prop] = withOptions[prop];\n });\n\n log(`searching ${path} with options:`, requestOptions);\n return this._requestAllPages(`/search/${path}`, requestOptions, cb);\n }\n\n /**\n * Search for repositories\n * @see https://developer.github.com/v3/search/#search-repositories\n * @param {Search.Params} [options] - additional parameters for the search\n * @param {Requestable.callback} [cb] - will receive the results of the search\n * @return {Promise} - the promise for the http request\n */\n forRepositories(options, cb) {\n return this._search('repositories', options, cb);\n }\n\n /**\n * Search for code\n * @see https://developer.github.com/v3/search/#search-code\n * @param {Search.Params} [options] - additional parameters for the search\n * @param {Requestable.callback} [cb] - will receive the results of the search\n * @return {Promise} - the promise for the http request\n */\n forCode(options, cb) {\n return this._search('code', options, cb);\n }\n\n /**\n * Search for issues\n * @see https://developer.github.com/v3/search/#search-issues\n * @param {Search.Params} [options] - additional parameters for the search\n * @param {Requestable.callback} [cb] - will receive the results of the search\n * @return {Promise} - the promise for the http request\n */\n forIssues(options, cb) {\n return this._search('issues', options, cb);\n }\n\n /**\n * Search for users\n * @see https://developer.github.com/v3/search/#search-users\n * @param {Search.Params} [options] - additional parameters for the search\n * @param {Requestable.callback} [cb] - will receive the results of the search\n * @return {Promise} - the promise for the http request\n */\n forUsers(options, cb) {\n return this._search('users', options, cb);\n }\n}\n\nmodule.exports = Search;\n","/**\n * @file\n * @copyright 2016 Matt Smith (Development Seed)\n * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n * Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\nimport debug from 'debug';\nconst log = debug('github:team');\n\n/**\n * A Team allows scoping of API requests to a particular Github Organization Team.\n */\nclass Team extends Requestable {\n /**\n * Create a Team.\n * @param {string} [teamId] - the id for the team\n * @param {Requestable.auth} [auth] - information required to authenticate to Github\n * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n */\n constructor(teamId, auth, apiBase) {\n super(auth, apiBase);\n this.__teamId = teamId;\n }\n\n /**\n * Get Team information\n * @see https://developer.github.com/v3/orgs/teams/#get-team\n * @param {Requestable.callback} [cb] - will receive the team\n * @return {Promise} - the promise for the http request\n */\n getTeam(cb) {\n log(`Fetching Team ${this.__teamId}`);\n return this._request('Get', `/teams/${this.__teamId}`, undefined, cb);\n }\n\n /**\n * List the Team's repositories\n * @see https://developer.github.com/v3/orgs/teams/#list-team-repos\n * @param {Requestable.callback} [cb] - will receive the list of repositories\n * @return {Promise} - the promise for the http request\n */\n listRepos(cb) {\n log(`Fetching repositories for Team ${this.__teamId}`);\n return this._requestAllPages(`/teams/${this.__teamId}/repos`, undefined, cb);\n }\n\n /**\n * Edit Team information\n * @see https://developer.github.com/v3/orgs/teams/#edit-team\n * @param {object} options - Parameters for team edit\n * @param {string} options.name - The name of the team\n * @param {string} [options.description] - Team description\n * @param {string} [options.repo_names] - Repos to add the team to\n * @param {string} [options.privacy=secret] - The level of privacy the team should have. Can be either one\n * of: `secret`, or `closed`\n * @param {Requestable.callback} [cb] - will receive the updated team\n * @return {Promise} - the promise for the http request\n */\n editTeam(options, cb) {\n log(`Editing Team ${this.__teamId}`);\n return this._request('PATCH', `/teams/${this.__teamId}`, options, cb);\n }\n\n /**\n * List the users who are members of the Team\n * @see https://developer.github.com/v3/orgs/teams/#list-team-members\n * @param {object} options - Parameters for listing team users\n * @param {string} [options.role=all] - can be one of: `all`, `maintainer`, or `member`\n * @param {Requestable.callback} [cb] - will receive the list of users\n * @return {Promise} - the promise for the http request\n */\n listMembers(options, cb) {\n log(`Getting members of Team ${this.__teamId}`);\n return this._requestAllPages(`/teams/${this.__teamId}/members`, options, cb);\n }\n\n /**\n * Get Team membership status for a user\n * @see https://developer.github.com/v3/orgs/teams/#get-team-membership\n * @param {string} username - can be one of: `all`, `maintainer`, or `member`\n * @param {Requestable.callback} [cb] - will receive the membership status of a user\n * @return {Promise} - the promise for the http request\n */\n getMembership(username, cb) {\n log(`Getting membership of user ${username} in Team ${this.__teamId}`);\n return this._request('GET', `/teams/${this.__teamId}/memberships/${username}`, undefined, cb);\n }\n\n /**\n * Add a member to the Team\n * @see https://developer.github.com/v3/orgs/teams/#add-team-membership\n * @param {string} username - can be one of: `all`, `maintainer`, or `member`\n * @param {object} options - Parameters for adding a team member\n * @param {string} [options.role=member] - The role that this user should have in the team. Can be one\n * of: `member`, or `maintainer`\n * @param {Requestable.callback} [cb] - will receive the membership status of added user\n * @return {Promise} - the promise for the http request\n */\n addMembership(username, options, cb) {\n log(`Adding user ${username} to Team ${this.__teamId}`);\n return this._request('PUT', `/teams/${this.__teamId}/memberships/${username}`, options, cb);\n }\n\n /**\n * Get repo management status for team\n * @see https://developer.github.com/v3/orgs/teams/#remove-team-membership\n * @param {string} owner - Organization name\n * @param {string} repo - Repo name\n * @param {Requestable.callback} [cb] - will receive the membership status of added user\n * @return {Promise} - the promise for the http request\n */\n isManagedRepo(owner, repo, cb) {\n log(`Getting repo management by Team ${this.__teamId} for repo ${owner}/${repo}`);\n return this._request204or404(`/teams/${this.__teamId}/repos/${owner}/${repo}`, undefined, cb);\n }\n\n /**\n * Add or Update repo management status for team\n * @see https://developer.github.com/v3/orgs/teams/#add-or-update-team-repository\n * @param {string} owner - Organization name\n * @param {string} repo - Repo name\n * @param {object} options - Parameters for adding or updating repo management for the team\n * @param {string} [options.permission] - The permission to grant the team on this repository. Can be one\n * of: `pull`, `push`, or `admin`\n * @param {Requestable.callback} [cb] - will receive the membership status of added user\n * @return {Promise} - the promise for the http request\n */\n manageRepo(owner, repo, options, cb) {\n log(`Adding or Updating repo management by Team ${this.__teamId} for repo ${owner}/${repo}`);\n return this._request204or404(`/teams/${this.__teamId}/repos/${owner}/${repo}`, options, cb, 'PUT');\n }\n\n /**\n * Remove repo management status for team\n * @see https://developer.github.com/v3/orgs/teams/#remove-team-repository\n * @param {string} owner - Organization name\n * @param {string} repo - Repo name\n * @param {Requestable.callback} [cb] - will receive the membership status of added user\n * @return {Promise} - the promise for the http request\n */\n unmanageRepo(owner, repo, cb) {\n log(`Remove repo management by Team ${this.__teamId} for repo ${owner}/${repo}`);\n return this._request204or404(`/teams/${this.__teamId}/repos/${owner}/${repo}`, undefined, cb, 'DELETE');\n }\n\n /**\n * Delete Team\n * @see https://developer.github.com/v3/orgs/teams/#delete-team\n * @param {Requestable.callback} [cb] - will receive the list of repositories\n * @return {Promise} - the promise for the http request\n */\n deleteTeam(cb) {\n log(`Deleting Team ${this.__teamId}`);\n return this._request204or404(`/teams/${this.__teamId}`, undefined, cb, 'DELETE');\n }\n}\n\nmodule.exports = Team;\n","/**\n * @file\n * @copyright 2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n * Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\nimport debug from 'debug';\nconst log = debug('github:user');\n\n/**\n * A User allows scoping of API requests to a particular Github user.\n */\nclass User extends Requestable {\n /**\n * Create a User.\n * @param {string} [username] - the user to use for user-scoped queries\n * @param {Requestable.auth} [auth] - information required to authenticate to Github\n * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n */\n constructor(username, auth, apiBase) {\n super(auth, apiBase);\n this.__user = username;\n }\n\n /**\n * Get the url for the request. (dependent on if we're requesting for the authenticated user or not)\n * @private\n * @param {string} endpoint - the endpoint being requested\n * @return {string} - the resolved endpoint\n */\n __getScopedUrl(endpoint) {\n if (this.__user) {\n return endpoint ?\n `/users/${this.__user}/${endpoint}` :\n `/users/${this.__user}`\n ;\n\n } else { // eslint-disable-line\n switch (endpoint) {\n case '':\n return '/user';\n\n case 'notifications':\n case 'gists':\n return `/${endpoint}`;\n\n default:\n return `/user/${endpoint}`;\n }\n }\n }\n\n /**\n * List the user's repositories\n * @see https://developer.github.com/v3/repos/#list-user-repositories\n * @param {Object} [options={}] - any options to refine the search\n * @param {Requestable.callback} [cb] - will receive the list of repositories\n * @return {Promise} - the promise for the http request\n */\n listRepos(options, cb) {\n if (typeof options === 'function') {\n cb = options;\n options = {};\n }\n\n options = this._getOptionsWithDefaults(options);\n\n log(`Fetching repositories with options: ${JSON.stringify(options)}`);\n return this._requestAllPages(this.__getScopedUrl('repos'), options, cb);\n }\n\n /**\n * List the orgs that the user belongs to\n * @see https://developer.github.com/v3/orgs/#list-user-organizations\n * @param {Requestable.callback} [cb] - will receive the list of organizations\n * @return {Promise} - the promise for the http request\n */\n listOrgs(cb) {\n return this._request('GET', this.__getScopedUrl('orgs'), null, cb);\n }\n\n /**\n * List the user's gists\n * @see https://developer.github.com/v3/gists/#list-a-users-gists\n * @param {Requestable.callback} [cb] - will receive the list of gists\n * @return {Promise} - the promise for the http request\n */\n listGists(cb) {\n return this._request('GET', this.__getScopedUrl('gists'), null, cb);\n }\n\n /**\n * List the user's starred gists\n * @see https://developer.github.com/v3/gists/#list-starred-gists\n * @param {Requestable.callback} [cb] - will receive the list of gists\n * @return {Promise} - the promise for the http request\n */\n listStarredGists(cb) {\n return this._request('GET', this.__getScopedUrl('gists/starred'), null, cb);\n }\n\n /**\n * List the user's notifications\n * @see https://developer.github.com/v3/activity/notifications/#list-your-notifications\n * @param {Object} [options={}] - any options to refine the search\n * @param {Requestable.callback} [cb] - will receive the list of repositories\n * @return {Promise} - the promise for the http request\n */\n listNotifications(options, cb) {\n options = options || {};\n if (typeof options === 'function') {\n cb = options;\n options = {};\n }\n\n options.since = this._dateToISO(options.since);\n options.before = this._dateToISO(options.before);\n\n return this._request('GET', this.__getScopedUrl('notifications'), options, cb);\n }\n\n /**\n * Show the user's profile\n * @see https://developer.github.com/v3/users/#get-a-single-user\n * @param {Requestable.callback} [cb] - will receive the user's information\n * @return {Promise} - the promise for the http request\n */\n getProfile(cb) {\n return this._request('GET', this.__getScopedUrl(''), null, cb);\n }\n\n /**\n * Gets the list of starred repositories for the user\n * @see https://developer.github.com/v3/activity/starring/#list-repositories-being-starred\n * @param {Requestable.callback} [cb] - will receive the list of starred repositories\n * @return {Promise} - the promise for the http request\n */\n listStarredRepos(cb) {\n let requestOptions = this._getOptionsWithDefaults();\n return this._requestAllPages(this.__getScopedUrl('starred'), requestOptions, cb);\n }\n\n /**\n * List email addresses for a user\n * @see https://developer.github.com/v3/users/emails/#list-email-addresses-for-a-user\n * @param {Requestable.callback} [cb] - will receive the list of emails\n * @return {Promise} - the promise for the http request\n */\n getEmails(cb) {\n return this._request('GET', '/user/emails', null, cb);\n }\n\n /**\n * Have the authenticated user follow this user\n * @see https://developer.github.com/v3/users/followers/#follow-a-user\n * @param {string} username - the user to follow\n * @param {Requestable.callback} [cb] - will receive true if the request succeeds\n * @return {Promise} - the promise for the http request\n */\n follow(username, cb) {\n return this._request('PUT', `/user/following/${this.__user}`, null, cb);\n }\n\n /**\n * Have the currently authenticated user unfollow this user\n * @see https://developer.github.com/v3/users/followers/#follow-a-user\n * @param {string} username - the user to unfollow\n * @param {Requestable.callback} [cb] - receives true if the request succeeds\n * @return {Promise} - the promise for the http request\n */\n unfollow(username, cb) {\n return this._request('DELETE', `/user/following/${this.__user}`, null, cb);\n }\n\n /**\n * Create a new repository for the currently authenticated user\n * @see https://developer.github.com/v3/repos/#create\n * @param {object} options - the repository definition\n * @param {Requestable.callback} [cb] - will receive the API response\n * @return {Promise} - the promise for the http request\n */\n createRepo(options, cb) {\n return this._request('POST', '/user/repos', options, cb);\n }\n}\n\nmodule.exports = User;\n","module.exports = require('./lib/axios');","'use strict';\n\nvar utils = require('./../utils');\nvar settle = require('./../core/settle');\nvar buildURL = require('./../helpers/buildURL');\nvar parseHeaders = require('./../helpers/parseHeaders');\nvar isURLSameOrigin = require('./../helpers/isURLSameOrigin');\nvar createError = require('../core/createError');\nvar btoa = (typeof window !== 'undefined' && window.btoa && window.btoa.bind(window)) || require('./../helpers/btoa');\n\nmodule.exports = function xhrAdapter(config) {\n return new Promise(function dispatchXhrRequest(resolve, reject) {\n var requestData = config.data;\n var requestHeaders = config.headers;\n\n if (utils.isFormData(requestData)) {\n delete requestHeaders['Content-Type']; // Let the browser set it\n }\n\n var request = new XMLHttpRequest();\n var loadEvent = 'onreadystatechange';\n var xDomain = false;\n\n // For IE 8/9 CORS support\n // Only supports POST and GET calls and doesn't returns the response headers.\n // DON'T do this for testing b/c XMLHttpRequest is mocked, not XDomainRequest.\n if (process.env.NODE_ENV !== 'test' &&\n typeof window !== 'undefined' &&\n window.XDomainRequest && !('withCredentials' in request) &&\n !isURLSameOrigin(config.url)) {\n request = new window.XDomainRequest();\n loadEvent = 'onload';\n xDomain = true;\n request.onprogress = function handleProgress() {};\n request.ontimeout = function handleTimeout() {};\n }\n\n // HTTP basic authentication\n if (config.auth) {\n var username = config.auth.username || '';\n var password = config.auth.password || '';\n requestHeaders.Authorization = 'Basic ' + btoa(username + ':' + password);\n }\n\n request.open(config.method.toUpperCase(), buildURL(config.url, config.params, config.paramsSerializer), true);\n\n // Set the request timeout in MS\n request.timeout = config.timeout;\n\n // Listen for ready state\n request[loadEvent] = function handleLoad() {\n if (!request || (request.readyState !== 4 && !xDomain)) {\n return;\n }\n\n // The request errored out and we didn't get a response, this will be\n // handled by onerror instead\n // With one exception: request that using file: protocol, most browsers\n // will return status as 0 even though it's a successful request\n if (request.status === 0 && !(request.responseURL && request.responseURL.indexOf('file:') === 0)) {\n return;\n }\n\n // Prepare the response\n var responseHeaders = 'getAllResponseHeaders' in request ? parseHeaders(request.getAllResponseHeaders()) : null;\n var responseData = !config.responseType || config.responseType === 'text' ? request.responseText : request.response;\n var response = {\n data: responseData,\n // IE sends 1223 instead of 204 (https://github.com/mzabriskie/axios/issues/201)\n status: request.status === 1223 ? 204 : request.status,\n statusText: request.status === 1223 ? 'No Content' : request.statusText,\n headers: responseHeaders,\n config: config,\n request: request\n };\n\n settle(resolve, reject, response);\n\n // Clean up request\n request = null;\n };\n\n // Handle low level network errors\n request.onerror = function handleError() {\n // Real errors are hidden from us by the browser\n // onerror should only fire if it's a network error\n reject(createError('Network Error', config));\n\n // Clean up request\n request = null;\n };\n\n // Handle timeout\n request.ontimeout = function handleTimeout() {\n reject(createError('timeout of ' + config.timeout + 'ms exceeded', config, 'ECONNABORTED'));\n\n // Clean up request\n request = null;\n };\n\n // Add xsrf header\n // This is only done if running in a standard browser environment.\n // Specifically not if we're in a web worker, or react-native.\n if (utils.isStandardBrowserEnv()) {\n var cookies = require('./../helpers/cookies');\n\n // Add xsrf header\n var xsrfValue = (config.withCredentials || isURLSameOrigin(config.url)) && config.xsrfCookieName ?\n cookies.read(config.xsrfCookieName) :\n undefined;\n\n if (xsrfValue) {\n requestHeaders[config.xsrfHeaderName] = xsrfValue;\n }\n }\n\n // Add headers to the request\n if ('setRequestHeader' in request) {\n utils.forEach(requestHeaders, function setRequestHeader(val, key) {\n if (typeof requestData === 'undefined' && key.toLowerCase() === 'content-type') {\n // Remove Content-Type if data is undefined\n delete requestHeaders[key];\n } else {\n // Otherwise add header to the request\n request.setRequestHeader(key, val);\n }\n });\n }\n\n // Add withCredentials to request if needed\n if (config.withCredentials) {\n request.withCredentials = true;\n }\n\n // Add responseType to request if needed\n if (config.responseType) {\n try {\n request.responseType = config.responseType;\n } catch (e) {\n if (request.responseType !== 'json') {\n throw e;\n }\n }\n }\n\n // Handle progress if needed\n if (typeof config.onDownloadProgress === 'function') {\n request.addEventListener('progress', config.onDownloadProgress);\n }\n\n // Not all browsers support upload events\n if (typeof config.onUploadProgress === 'function' && request.upload) {\n request.upload.addEventListener('progress', config.onUploadProgress);\n }\n\n if (config.cancelToken) {\n // Handle cancellation\n config.cancelToken.promise.then(function onCanceled(cancel) {\n if (!request) {\n return;\n }\n\n request.abort();\n reject(cancel);\n // Clean up request\n request = null;\n });\n }\n\n if (requestData === undefined) {\n requestData = null;\n }\n\n // Send the request\n request.send(requestData);\n });\n};\n","'use strict';\n\nvar utils = require('./utils');\nvar bind = require('./helpers/bind');\nvar Axios = require('./core/Axios');\nvar defaults = require('./defaults');\n\n/**\n * Create an instance of Axios\n *\n * @param {Object} defaultConfig The default config for the instance\n * @return {Axios} A new instance of Axios\n */\nfunction createInstance(defaultConfig) {\n var context = new Axios(defaultConfig);\n var instance = bind(Axios.prototype.request, context);\n\n // Copy axios.prototype to instance\n utils.extend(instance, Axios.prototype, context);\n\n // Copy context to instance\n utils.extend(instance, context);\n\n return instance;\n}\n\n// Create the default instance to be exported\nvar axios = createInstance(defaults);\n\n// Expose Axios class to allow class inheritance\naxios.Axios = Axios;\n\n// Factory for creating new instances\naxios.create = function create(instanceConfig) {\n return createInstance(utils.merge(defaults, instanceConfig));\n};\n\n// Expose Cancel & CancelToken\naxios.Cancel = require('./cancel/Cancel');\naxios.CancelToken = require('./cancel/CancelToken');\naxios.isCancel = require('./cancel/isCancel');\n\n// Expose all/spread\naxios.all = function all(promises) {\n return Promise.all(promises);\n};\naxios.spread = require('./helpers/spread');\n\nmodule.exports = axios;\n\n// Allow use of default import syntax in TypeScript\nmodule.exports.default = axios;\n","'use strict';\n\n/**\n * A `Cancel` is an object that is thrown when an operation is canceled.\n *\n * @class\n * @param {string=} message The message.\n */\nfunction Cancel(message) {\n this.message = message;\n}\n\nCancel.prototype.toString = function toString() {\n return 'Cancel' + (this.message ? ': ' + this.message : '');\n};\n\nCancel.prototype.__CANCEL__ = true;\n\nmodule.exports = Cancel;\n","'use strict';\n\nvar Cancel = require('./Cancel');\n\n/**\n * A `CancelToken` is an object that can be used to request cancellation of an operation.\n *\n * @class\n * @param {Function} executor The executor function.\n */\nfunction CancelToken(executor) {\n if (typeof executor !== 'function') {\n throw new TypeError('executor must be a function.');\n }\n\n var resolvePromise;\n this.promise = new Promise(function promiseExecutor(resolve) {\n resolvePromise = resolve;\n });\n\n var token = this;\n executor(function cancel(message) {\n if (token.reason) {\n // Cancellation has already been requested\n return;\n }\n\n token.reason = new Cancel(message);\n resolvePromise(token.reason);\n });\n}\n\n/**\n * Throws a `Cancel` if cancellation has been requested.\n */\nCancelToken.prototype.throwIfRequested = function throwIfRequested() {\n if (this.reason) {\n throw this.reason;\n }\n};\n\n/**\n * Returns an object that contains a new `CancelToken` and a function that, when called,\n * cancels the `CancelToken`.\n */\nCancelToken.source = function source() {\n var cancel;\n var token = new CancelToken(function executor(c) {\n cancel = c;\n });\n return {\n token: token,\n cancel: cancel\n };\n};\n\nmodule.exports = CancelToken;\n","'use strict';\n\nmodule.exports = function isCancel(value) {\n return !!(value && value.__CANCEL__);\n};\n","'use strict';\n\nvar defaults = require('./../defaults');\nvar utils = require('./../utils');\nvar InterceptorManager = require('./InterceptorManager');\nvar dispatchRequest = require('./dispatchRequest');\nvar isAbsoluteURL = require('./../helpers/isAbsoluteURL');\nvar combineURLs = require('./../helpers/combineURLs');\n\n/**\n * Create a new instance of Axios\n *\n * @param {Object} instanceConfig The default config for the instance\n */\nfunction Axios(instanceConfig) {\n this.defaults = instanceConfig;\n this.interceptors = {\n request: new InterceptorManager(),\n response: new InterceptorManager()\n };\n}\n\n/**\n * Dispatch a request\n *\n * @param {Object} config The config specific for this request (merged with this.defaults)\n */\nAxios.prototype.request = function request(config) {\n /*eslint no-param-reassign:0*/\n // Allow for axios('example/url'[, config]) a la fetch API\n if (typeof config === 'string') {\n config = utils.merge({\n url: arguments[0]\n }, arguments[1]);\n }\n\n config = utils.merge(defaults, this.defaults, { method: 'get' }, config);\n\n // Support baseURL config\n if (config.baseURL && !isAbsoluteURL(config.url)) {\n config.url = combineURLs(config.baseURL, config.url);\n }\n\n // Hook up interceptors middleware\n var chain = [dispatchRequest, undefined];\n var promise = Promise.resolve(config);\n\n this.interceptors.request.forEach(function unshiftRequestInterceptors(interceptor) {\n chain.unshift(interceptor.fulfilled, interceptor.rejected);\n });\n\n this.interceptors.response.forEach(function pushResponseInterceptors(interceptor) {\n chain.push(interceptor.fulfilled, interceptor.rejected);\n });\n\n while (chain.length) {\n promise = promise.then(chain.shift(), chain.shift());\n }\n\n return promise;\n};\n\n// Provide aliases for supported request methods\nutils.forEach(['delete', 'get', 'head'], function forEachMethodNoData(method) {\n /*eslint func-names:0*/\n Axios.prototype[method] = function(url, config) {\n return this.request(utils.merge(config || {}, {\n method: method,\n url: url\n }));\n };\n});\n\nutils.forEach(['post', 'put', 'patch'], function forEachMethodWithData(method) {\n /*eslint func-names:0*/\n Axios.prototype[method] = function(url, data, config) {\n return this.request(utils.merge(config || {}, {\n method: method,\n url: url,\n data: data\n }));\n };\n});\n\nmodule.exports = Axios;\n","'use strict';\n\nvar utils = require('./../utils');\n\nfunction InterceptorManager() {\n this.handlers = [];\n}\n\n/**\n * Add a new interceptor to the stack\n *\n * @param {Function} fulfilled The function to handle `then` for a `Promise`\n * @param {Function} rejected The function to handle `reject` for a `Promise`\n *\n * @return {Number} An ID used to remove interceptor later\n */\nInterceptorManager.prototype.use = function use(fulfilled, rejected) {\n this.handlers.push({\n fulfilled: fulfilled,\n rejected: rejected\n });\n return this.handlers.length - 1;\n};\n\n/**\n * Remove an interceptor from the stack\n *\n * @param {Number} id The ID that was returned by `use`\n */\nInterceptorManager.prototype.eject = function eject(id) {\n if (this.handlers[id]) {\n this.handlers[id] = null;\n }\n};\n\n/**\n * Iterate over all the registered interceptors\n *\n * This method is particularly useful for skipping over any\n * interceptors that may have become `null` calling `eject`.\n *\n * @param {Function} fn The function to call for each interceptor\n */\nInterceptorManager.prototype.forEach = function forEach(fn) {\n utils.forEach(this.handlers, function forEachHandler(h) {\n if (h !== null) {\n fn(h);\n }\n });\n};\n\nmodule.exports = InterceptorManager;\n","'use strict';\n\nvar enhanceError = require('./enhanceError');\n\n/**\n * Create an Error with the specified message, config, error code, and response.\n *\n * @param {string} message The error message.\n * @param {Object} config The config.\n * @param {string} [code] The error code (for example, 'ECONNABORTED').\n @ @param {Object} [response] The response.\n * @returns {Error} The created error.\n */\nmodule.exports = function createError(message, config, code, response) {\n var error = new Error(message);\n return enhanceError(error, config, code, response);\n};\n","'use strict';\n\nvar utils = require('./../utils');\nvar transformData = require('./transformData');\nvar isCancel = require('../cancel/isCancel');\nvar defaults = require('../defaults');\n\n/**\n * Throws a `Cancel` if cancellation has been requested.\n */\nfunction throwIfCancellationRequested(config) {\n if (config.cancelToken) {\n config.cancelToken.throwIfRequested();\n }\n}\n\n/**\n * Dispatch a request to the server using the configured adapter.\n *\n * @param {object} config The config that is to be used for the request\n * @returns {Promise} The Promise to be fulfilled\n */\nmodule.exports = function dispatchRequest(config) {\n throwIfCancellationRequested(config);\n\n // Ensure headers exist\n config.headers = config.headers || {};\n\n // Transform request data\n config.data = transformData(\n config.data,\n config.headers,\n config.transformRequest\n );\n\n // Flatten headers\n config.headers = utils.merge(\n config.headers.common || {},\n config.headers[config.method] || {},\n config.headers || {}\n );\n\n utils.forEach(\n ['delete', 'get', 'head', 'post', 'put', 'patch', 'common'],\n function cleanHeaderConfig(method) {\n delete config.headers[method];\n }\n );\n\n var adapter = config.adapter || defaults.adapter;\n\n return adapter(config).then(function onAdapterResolution(response) {\n throwIfCancellationRequested(config);\n\n // Transform response data\n response.data = transformData(\n response.data,\n response.headers,\n config.transformResponse\n );\n\n return response;\n }, function onAdapterRejection(reason) {\n if (!isCancel(reason)) {\n throwIfCancellationRequested(config);\n\n // Transform response data\n if (reason && reason.response) {\n reason.response.data = transformData(\n reason.response.data,\n reason.response.headers,\n config.transformResponse\n );\n }\n }\n\n return Promise.reject(reason);\n });\n};\n","'use strict';\n\n/**\n * Update an Error with the specified config, error code, and response.\n *\n * @param {Error} error The error to update.\n * @param {Object} config The config.\n * @param {string} [code] The error code (for example, 'ECONNABORTED').\n @ @param {Object} [response] The response.\n * @returns {Error} The error.\n */\nmodule.exports = function enhanceError(error, config, code, response) {\n error.config = config;\n if (code) {\n error.code = code;\n }\n error.response = response;\n return error;\n};\n","'use strict';\n\nvar createError = require('./createError');\n\n/**\n * Resolve or reject a Promise based on response status.\n *\n * @param {Function} resolve A function that resolves the promise.\n * @param {Function} reject A function that rejects the promise.\n * @param {object} response The response.\n */\nmodule.exports = function settle(resolve, reject, response) {\n var validateStatus = response.config.validateStatus;\n // Note: status is not exposed by XDomainRequest\n if (!response.status || !validateStatus || validateStatus(response.status)) {\n resolve(response);\n } else {\n reject(createError(\n 'Request failed with status code ' + response.status,\n response.config,\n null,\n response\n ));\n }\n};\n","'use strict';\n\nvar utils = require('./../utils');\n\n/**\n * Transform the data for a request or a response\n *\n * @param {Object|String} data The data to be transformed\n * @param {Array} headers The headers for the request or response\n * @param {Array|Function} fns A single function or Array of functions\n * @returns {*} The resulting transformed data\n */\nmodule.exports = function transformData(data, headers, fns) {\n /*eslint no-param-reassign:0*/\n utils.forEach(fns, function transform(fn) {\n data = fn(data, headers);\n });\n\n return data;\n};\n","'use strict';\n\nvar utils = require('./utils');\nvar normalizeHeaderName = require('./helpers/normalizeHeaderName');\n\nvar PROTECTION_PREFIX = /^\\)\\]\\}',?\\n/;\nvar DEFAULT_CONTENT_TYPE = {\n 'Content-Type': 'application/x-www-form-urlencoded'\n};\n\nfunction setContentTypeIfUnset(headers, value) {\n if (!utils.isUndefined(headers) && utils.isUndefined(headers['Content-Type'])) {\n headers['Content-Type'] = value;\n }\n}\n\nfunction getDefaultAdapter() {\n var adapter;\n if (typeof XMLHttpRequest !== 'undefined') {\n // For browsers use XHR adapter\n adapter = require('./adapters/xhr');\n } else if (typeof process !== 'undefined') {\n // For node use HTTP adapter\n adapter = require('./adapters/http');\n }\n return adapter;\n}\n\nvar defaults = {\n adapter: getDefaultAdapter(),\n\n transformRequest: [function transformRequest(data, headers) {\n normalizeHeaderName(headers, 'Content-Type');\n if (utils.isFormData(data) ||\n utils.isArrayBuffer(data) ||\n utils.isStream(data) ||\n utils.isFile(data) ||\n utils.isBlob(data)\n ) {\n return data;\n }\n if (utils.isArrayBufferView(data)) {\n return data.buffer;\n }\n if (utils.isURLSearchParams(data)) {\n setContentTypeIfUnset(headers, 'application/x-www-form-urlencoded;charset=utf-8');\n return data.toString();\n }\n if (utils.isObject(data)) {\n setContentTypeIfUnset(headers, 'application/json;charset=utf-8');\n return JSON.stringify(data);\n }\n return data;\n }],\n\n transformResponse: [function transformResponse(data) {\n /*eslint no-param-reassign:0*/\n if (typeof data === 'string') {\n data = data.replace(PROTECTION_PREFIX, '');\n try {\n data = JSON.parse(data);\n } catch (e) { /* Ignore */ }\n }\n return data;\n }],\n\n timeout: 0,\n\n xsrfCookieName: 'XSRF-TOKEN',\n xsrfHeaderName: 'X-XSRF-TOKEN',\n\n maxContentLength: -1,\n\n validateStatus: function validateStatus(status) {\n return status >= 200 && status < 300;\n }\n};\n\ndefaults.headers = {\n common: {\n 'Accept': 'application/json, text/plain, */*'\n }\n};\n\nutils.forEach(['delete', 'get', 'head'], function forEachMehtodNoData(method) {\n defaults.headers[method] = {};\n});\n\nutils.forEach(['post', 'put', 'patch'], function forEachMethodWithData(method) {\n defaults.headers[method] = utils.merge(DEFAULT_CONTENT_TYPE);\n});\n\nmodule.exports = defaults;\n","'use strict';\n\nmodule.exports = function bind(fn, thisArg) {\n return function wrap() {\n var args = new Array(arguments.length);\n for (var i = 0; i < args.length; i++) {\n args[i] = arguments[i];\n }\n return fn.apply(thisArg, args);\n };\n};\n","'use strict';\n\n// btoa polyfill for IE<10 courtesy https://github.com/davidchambers/Base64.js\n\nvar chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=';\n\nfunction E() {\n this.message = 'String contains an invalid character';\n}\nE.prototype = new Error;\nE.prototype.code = 5;\nE.prototype.name = 'InvalidCharacterError';\n\nfunction btoa(input) {\n var str = String(input);\n var output = '';\n for (\n // initialize result and counter\n var block, charCode, idx = 0, map = chars;\n // if the next str index does not exist:\n // change the mapping table to \"=\"\n // check if d has no fractional digits\n str.charAt(idx | 0) || (map = '=', idx % 1);\n // \"8 - idx % 1 * 8\" generates the sequence 2, 4, 6, 8\n output += map.charAt(63 & block >> 8 - idx % 1 * 8)\n ) {\n charCode = str.charCodeAt(idx += 3 / 4);\n if (charCode > 0xFF) {\n throw new E();\n }\n block = block << 8 | charCode;\n }\n return output;\n}\n\nmodule.exports = btoa;\n","'use strict';\n\nvar utils = require('./../utils');\n\nfunction encode(val) {\n return encodeURIComponent(val).\n replace(/%40/gi, '@').\n replace(/%3A/gi, ':').\n replace(/%24/g, '$').\n replace(/%2C/gi, ',').\n replace(/%20/g, '+').\n replace(/%5B/gi, '[').\n replace(/%5D/gi, ']');\n}\n\n/**\n * Build a URL by appending params to the end\n *\n * @param {string} url The base of the url (e.g., http://www.google.com)\n * @param {object} [params] The params to be appended\n * @returns {string} The formatted url\n */\nmodule.exports = function buildURL(url, params, paramsSerializer) {\n /*eslint no-param-reassign:0*/\n if (!params) {\n return url;\n }\n\n var serializedParams;\n if (paramsSerializer) {\n serializedParams = paramsSerializer(params);\n } else if (utils.isURLSearchParams(params)) {\n serializedParams = params.toString();\n } else {\n var parts = [];\n\n utils.forEach(params, function serialize(val, key) {\n if (val === null || typeof val === 'undefined') {\n return;\n }\n\n if (utils.isArray(val)) {\n key = key + '[]';\n }\n\n if (!utils.isArray(val)) {\n val = [val];\n }\n\n utils.forEach(val, function parseValue(v) {\n if (utils.isDate(v)) {\n v = v.toISOString();\n } else if (utils.isObject(v)) {\n v = JSON.stringify(v);\n }\n parts.push(encode(key) + '=' + encode(v));\n });\n });\n\n serializedParams = parts.join('&');\n }\n\n if (serializedParams) {\n url += (url.indexOf('?') === -1 ? '?' : '&') + serializedParams;\n }\n\n return url;\n};\n","'use strict';\n\n/**\n * Creates a new URL by combining the specified URLs\n *\n * @param {string} baseURL The base URL\n * @param {string} relativeURL The relative URL\n * @returns {string} The combined URL\n */\nmodule.exports = function combineURLs(baseURL, relativeURL) {\n return baseURL.replace(/\\/+$/, '') + '/' + relativeURL.replace(/^\\/+/, '');\n};\n","'use strict';\n\nvar utils = require('./../utils');\n\nmodule.exports = (\n utils.isStandardBrowserEnv() ?\n\n // Standard browser envs support document.cookie\n (function standardBrowserEnv() {\n return {\n write: function write(name, value, expires, path, domain, secure) {\n var cookie = [];\n cookie.push(name + '=' + encodeURIComponent(value));\n\n if (utils.isNumber(expires)) {\n cookie.push('expires=' + new Date(expires).toGMTString());\n }\n\n if (utils.isString(path)) {\n cookie.push('path=' + path);\n }\n\n if (utils.isString(domain)) {\n cookie.push('domain=' + domain);\n }\n\n if (secure === true) {\n cookie.push('secure');\n }\n\n document.cookie = cookie.join('; ');\n },\n\n read: function read(name) {\n var match = document.cookie.match(new RegExp('(^|;\\\\s*)(' + name + ')=([^;]*)'));\n return (match ? decodeURIComponent(match[3]) : null);\n },\n\n remove: function remove(name) {\n this.write(name, '', Date.now() - 86400000);\n }\n };\n })() :\n\n // Non standard browser env (web workers, react-native) lack needed support.\n (function nonStandardBrowserEnv() {\n return {\n write: function write() {},\n read: function read() { return null; },\n remove: function remove() {}\n };\n })()\n);\n","'use strict';\n\n/**\n * Determines whether the specified URL is absolute\n *\n * @param {string} url The URL to test\n * @returns {boolean} True if the specified URL is absolute, otherwise false\n */\nmodule.exports = function isAbsoluteURL(url) {\n // A URL is considered absolute if it begins with \"://\" or \"//\" (protocol-relative URL).\n // RFC 3986 defines scheme name as a sequence of characters beginning with a letter and followed\n // by any combination of letters, digits, plus, period, or hyphen.\n return /^([a-z][a-z\\d\\+\\-\\.]*:)?\\/\\//i.test(url);\n};\n","'use strict';\n\nvar utils = require('./../utils');\n\nmodule.exports = (\n utils.isStandardBrowserEnv() ?\n\n // Standard browser envs have full support of the APIs needed to test\n // whether the request URL is of the same origin as current location.\n (function standardBrowserEnv() {\n var msie = /(msie|trident)/i.test(navigator.userAgent);\n var urlParsingNode = document.createElement('a');\n var originURL;\n\n /**\n * Parse a URL to discover it's components\n *\n * @param {String} url The URL to be parsed\n * @returns {Object}\n */\n function resolveURL(url) {\n var href = url;\n\n if (msie) {\n // IE needs attribute set twice to normalize properties\n urlParsingNode.setAttribute('href', href);\n href = urlParsingNode.href;\n }\n\n urlParsingNode.setAttribute('href', href);\n\n // urlParsingNode provides the UrlUtils interface - http://url.spec.whatwg.org/#urlutils\n return {\n href: urlParsingNode.href,\n protocol: urlParsingNode.protocol ? urlParsingNode.protocol.replace(/:$/, '') : '',\n host: urlParsingNode.host,\n search: urlParsingNode.search ? urlParsingNode.search.replace(/^\\?/, '') : '',\n hash: urlParsingNode.hash ? urlParsingNode.hash.replace(/^#/, '') : '',\n hostname: urlParsingNode.hostname,\n port: urlParsingNode.port,\n pathname: (urlParsingNode.pathname.charAt(0) === '/') ?\n urlParsingNode.pathname :\n '/' + urlParsingNode.pathname\n };\n }\n\n originURL = resolveURL(window.location.href);\n\n /**\n * Determine if a URL shares the same origin as the current location\n *\n * @param {String} requestURL The URL to test\n * @returns {boolean} True if URL shares the same origin, otherwise false\n */\n return function isURLSameOrigin(requestURL) {\n var parsed = (utils.isString(requestURL)) ? resolveURL(requestURL) : requestURL;\n return (parsed.protocol === originURL.protocol &&\n parsed.host === originURL.host);\n };\n })() :\n\n // Non standard browser envs (web workers, react-native) lack needed support.\n (function nonStandardBrowserEnv() {\n return function isURLSameOrigin() {\n return true;\n };\n })()\n);\n","'use strict';\n\nvar utils = require('../utils');\n\nmodule.exports = function normalizeHeaderName(headers, normalizedName) {\n utils.forEach(headers, function processHeader(value, name) {\n if (name !== normalizedName && name.toUpperCase() === normalizedName.toUpperCase()) {\n headers[normalizedName] = value;\n delete headers[name];\n }\n });\n};\n","'use strict';\n\nvar utils = require('./../utils');\n\n/**\n * Parse headers into an object\n *\n * ```\n * Date: Wed, 27 Aug 2014 08:58:49 GMT\n * Content-Type: application/json\n * Connection: keep-alive\n * Transfer-Encoding: chunked\n * ```\n *\n * @param {String} headers Headers needing to be parsed\n * @returns {Object} Headers parsed into an object\n */\nmodule.exports = function parseHeaders(headers) {\n var parsed = {};\n var key;\n var val;\n var i;\n\n if (!headers) { return parsed; }\n\n utils.forEach(headers.split('\\n'), function parser(line) {\n i = line.indexOf(':');\n key = utils.trim(line.substr(0, i)).toLowerCase();\n val = utils.trim(line.substr(i + 1));\n\n if (key) {\n parsed[key] = parsed[key] ? parsed[key] + ', ' + val : val;\n }\n });\n\n return parsed;\n};\n","'use strict';\n\n/**\n * Syntactic sugar for invoking a function and expanding an array for arguments.\n *\n * Common use case would be to use `Function.prototype.apply`.\n *\n * ```js\n * function f(x, y, z) {}\n * var args = [1, 2, 3];\n * f.apply(null, args);\n * ```\n *\n * With `spread` this example can be re-written.\n *\n * ```js\n * spread(function(x, y, z) {})([1, 2, 3]);\n * ```\n *\n * @param {Function} callback\n * @returns {Function}\n */\nmodule.exports = function spread(callback) {\n return function wrap(arr) {\n return callback.apply(null, arr);\n };\n};\n","'use strict';\n\nvar bind = require('./helpers/bind');\n\n/*global toString:true*/\n\n// utils is a library of generic helper functions non-specific to axios\n\nvar toString = Object.prototype.toString;\n\n/**\n * Determine if a value is an Array\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if value is an Array, otherwise false\n */\nfunction isArray(val) {\n return toString.call(val) === '[object Array]';\n}\n\n/**\n * Determine if a value is an ArrayBuffer\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if value is an ArrayBuffer, otherwise false\n */\nfunction isArrayBuffer(val) {\n return toString.call(val) === '[object ArrayBuffer]';\n}\n\n/**\n * Determine if a value is a FormData\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if value is an FormData, otherwise false\n */\nfunction isFormData(val) {\n return (typeof FormData !== 'undefined') && (val instanceof FormData);\n}\n\n/**\n * Determine if a value is a view on an ArrayBuffer\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if value is a view on an ArrayBuffer, otherwise false\n */\nfunction isArrayBufferView(val) {\n var result;\n if ((typeof ArrayBuffer !== 'undefined') && (ArrayBuffer.isView)) {\n result = ArrayBuffer.isView(val);\n } else {\n result = (val) && (val.buffer) && (val.buffer instanceof ArrayBuffer);\n }\n return result;\n}\n\n/**\n * Determine if a value is a String\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if value is a String, otherwise false\n */\nfunction isString(val) {\n return typeof val === 'string';\n}\n\n/**\n * Determine if a value is a Number\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if value is a Number, otherwise false\n */\nfunction isNumber(val) {\n return typeof val === 'number';\n}\n\n/**\n * Determine if a value is undefined\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if the value is undefined, otherwise false\n */\nfunction isUndefined(val) {\n return typeof val === 'undefined';\n}\n\n/**\n * Determine if a value is an Object\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if value is an Object, otherwise false\n */\nfunction isObject(val) {\n return val !== null && typeof val === 'object';\n}\n\n/**\n * Determine if a value is a Date\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if value is a Date, otherwise false\n */\nfunction isDate(val) {\n return toString.call(val) === '[object Date]';\n}\n\n/**\n * Determine if a value is a File\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if value is a File, otherwise false\n */\nfunction isFile(val) {\n return toString.call(val) === '[object File]';\n}\n\n/**\n * Determine if a value is a Blob\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if value is a Blob, otherwise false\n */\nfunction isBlob(val) {\n return toString.call(val) === '[object Blob]';\n}\n\n/**\n * Determine if a value is a Function\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if value is a Function, otherwise false\n */\nfunction isFunction(val) {\n return toString.call(val) === '[object Function]';\n}\n\n/**\n * Determine if a value is a Stream\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if value is a Stream, otherwise false\n */\nfunction isStream(val) {\n return isObject(val) && isFunction(val.pipe);\n}\n\n/**\n * Determine if a value is a URLSearchParams object\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if value is a URLSearchParams object, otherwise false\n */\nfunction isURLSearchParams(val) {\n return typeof URLSearchParams !== 'undefined' && val instanceof URLSearchParams;\n}\n\n/**\n * Trim excess whitespace off the beginning and end of a string\n *\n * @param {String} str The String to trim\n * @returns {String} The String freed of excess whitespace\n */\nfunction trim(str) {\n return str.replace(/^\\s*/, '').replace(/\\s*$/, '');\n}\n\n/**\n * Determine if we're running in a standard browser environment\n *\n * This allows axios to run in a web worker, and react-native.\n * Both environments support XMLHttpRequest, but not fully standard globals.\n *\n * web workers:\n * typeof window -> undefined\n * typeof document -> undefined\n *\n * react-native:\n * typeof document.createElement -> undefined\n */\nfunction isStandardBrowserEnv() {\n return (\n typeof window !== 'undefined' &&\n typeof document !== 'undefined' &&\n typeof document.createElement === 'function'\n );\n}\n\n/**\n * Iterate over an Array or an Object invoking a function for each item.\n *\n * If `obj` is an Array callback will be called passing\n * the value, index, and complete array for each item.\n *\n * If 'obj' is an Object callback will be called passing\n * the value, key, and complete object for each property.\n *\n * @param {Object|Array} obj The object to iterate\n * @param {Function} fn The callback to invoke for each item\n */\nfunction forEach(obj, fn) {\n // Don't bother if no value provided\n if (obj === null || typeof obj === 'undefined') {\n return;\n }\n\n // Force an array if not already something iterable\n if (typeof obj !== 'object' && !isArray(obj)) {\n /*eslint no-param-reassign:0*/\n obj = [obj];\n }\n\n if (isArray(obj)) {\n // Iterate over array values\n for (var i = 0, l = obj.length; i < l; i++) {\n fn.call(null, obj[i], i, obj);\n }\n } else {\n // Iterate over object keys\n for (var key in obj) {\n if (Object.prototype.hasOwnProperty.call(obj, key)) {\n fn.call(null, obj[key], key, obj);\n }\n }\n }\n}\n\n/**\n * Accepts varargs expecting each argument to be an object, then\n * immutably merges the properties of each object and returns result.\n *\n * When multiple objects contain the same key the later object in\n * the arguments list will take precedence.\n *\n * Example:\n *\n * ```js\n * var result = merge({foo: 123}, {foo: 456});\n * console.log(result.foo); // outputs 456\n * ```\n *\n * @param {Object} obj1 Object to merge\n * @returns {Object} Result of all merge properties\n */\nfunction merge(/* obj1, obj2, obj3, ... */) {\n var result = {};\n function assignValue(val, key) {\n if (typeof result[key] === 'object' && typeof val === 'object') {\n result[key] = merge(result[key], val);\n } else {\n result[key] = val;\n }\n }\n\n for (var i = 0, l = arguments.length; i < l; i++) {\n forEach(arguments[i], assignValue);\n }\n return result;\n}\n\n/**\n * Extends object a by mutably adding to it the properties of object b.\n *\n * @param {Object} a The object to be extended\n * @param {Object} b The object to copy properties from\n * @param {Object} thisArg The object to bind function to\n * @return {Object} The resulting value of object a\n */\nfunction extend(a, b, thisArg) {\n forEach(b, function assignValue(val, key) {\n if (thisArg && typeof val === 'function') {\n a[key] = bind(val, thisArg);\n } else {\n a[key] = val;\n }\n });\n return a;\n}\n\nmodule.exports = {\n isArray: isArray,\n isArrayBuffer: isArrayBuffer,\n isFormData: isFormData,\n isArrayBufferView: isArrayBufferView,\n isString: isString,\n isNumber: isNumber,\n isObject: isObject,\n isUndefined: isUndefined,\n isDate: isDate,\n isFile: isFile,\n isBlob: isBlob,\n isFunction: isFunction,\n isStream: isStream,\n isURLSearchParams: isURLSearchParams,\n isStandardBrowserEnv: isStandardBrowserEnv,\n forEach: forEach,\n merge: merge,\n extend: extend,\n trim: trim\n};\n","'use strict'\n\nexports.byteLength = byteLength\nexports.toByteArray = toByteArray\nexports.fromByteArray = fromByteArray\n\nvar lookup = []\nvar revLookup = []\nvar Arr = typeof Uint8Array !== 'undefined' ? Uint8Array : Array\n\nvar code = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'\nfor (var i = 0, len = code.length; i < len; ++i) {\n lookup[i] = code[i]\n revLookup[code.charCodeAt(i)] = i\n}\n\nrevLookup['-'.charCodeAt(0)] = 62\nrevLookup['_'.charCodeAt(0)] = 63\n\nfunction placeHoldersCount (b64) {\n var len = b64.length\n if (len % 4 > 0) {\n throw new Error('Invalid string. Length must be a multiple of 4')\n }\n\n // the number of equal signs (place holders)\n // if there are two placeholders, than the two characters before it\n // represent one byte\n // if there is only one, then the three characters before it represent 2 bytes\n // this is just a cheap hack to not do indexOf twice\n return b64[len - 2] === '=' ? 2 : b64[len - 1] === '=' ? 1 : 0\n}\n\nfunction byteLength (b64) {\n // base64 is 4/3 + up to two characters of the original data\n return b64.length * 3 / 4 - placeHoldersCount(b64)\n}\n\nfunction toByteArray (b64) {\n var i, j, l, tmp, placeHolders, arr\n var len = b64.length\n placeHolders = placeHoldersCount(b64)\n\n arr = new Arr(len * 3 / 4 - placeHolders)\n\n // if there are placeholders, only get up to the last complete 4 chars\n l = placeHolders > 0 ? len - 4 : len\n\n var L = 0\n\n for (i = 0, j = 0; i < l; i += 4, j += 3) {\n tmp = (revLookup[b64.charCodeAt(i)] << 18) | (revLookup[b64.charCodeAt(i + 1)] << 12) | (revLookup[b64.charCodeAt(i + 2)] << 6) | revLookup[b64.charCodeAt(i + 3)]\n arr[L++] = (tmp >> 16) & 0xFF\n arr[L++] = (tmp >> 8) & 0xFF\n arr[L++] = tmp & 0xFF\n }\n\n if (placeHolders === 2) {\n tmp = (revLookup[b64.charCodeAt(i)] << 2) | (revLookup[b64.charCodeAt(i + 1)] >> 4)\n arr[L++] = tmp & 0xFF\n } else if (placeHolders === 1) {\n tmp = (revLookup[b64.charCodeAt(i)] << 10) | (revLookup[b64.charCodeAt(i + 1)] << 4) | (revLookup[b64.charCodeAt(i + 2)] >> 2)\n arr[L++] = (tmp >> 8) & 0xFF\n arr[L++] = tmp & 0xFF\n }\n\n return arr\n}\n\nfunction tripletToBase64 (num) {\n return lookup[num >> 18 & 0x3F] + lookup[num >> 12 & 0x3F] + lookup[num >> 6 & 0x3F] + lookup[num & 0x3F]\n}\n\nfunction encodeChunk (uint8, start, end) {\n var tmp\n var output = []\n for (var i = start; i < end; i += 3) {\n tmp = (uint8[i] << 16) + (uint8[i + 1] << 8) + (uint8[i + 2])\n output.push(tripletToBase64(tmp))\n }\n return output.join('')\n}\n\nfunction fromByteArray (uint8) {\n var tmp\n var len = uint8.length\n var extraBytes = len % 3 // if we have 1 byte left, pad 2 bytes\n var output = ''\n var parts = []\n var maxChunkLength = 16383 // must be multiple of 3\n\n // go through the array every three bytes, we'll deal with trailing stuff later\n for (var i = 0, len2 = len - extraBytes; i < len2; i += maxChunkLength) {\n parts.push(encodeChunk(uint8, i, (i + maxChunkLength) > len2 ? len2 : (i + maxChunkLength)))\n }\n\n // pad the end with zeros, but make sure to not forget the extra bytes\n if (extraBytes === 1) {\n tmp = uint8[len - 1]\n output += lookup[tmp >> 2]\n output += lookup[(tmp << 4) & 0x3F]\n output += '=='\n } else if (extraBytes === 2) {\n tmp = (uint8[len - 2] << 8) + (uint8[len - 1])\n output += lookup[tmp >> 10]\n output += lookup[(tmp >> 4) & 0x3F]\n output += lookup[(tmp << 2) & 0x3F]\n output += '='\n }\n\n parts.push(output)\n\n return parts.join('')\n}\n","/*!\n * The buffer module from node.js, for the browser.\n *\n * @author Feross Aboukhadijeh \n * @license MIT\n */\n/* eslint-disable no-proto */\n\n'use strict'\n\nvar base64 = require('base64-js')\nvar ieee754 = require('ieee754')\nvar isArray = require('isarray')\n\nexports.Buffer = Buffer\nexports.SlowBuffer = SlowBuffer\nexports.INSPECT_MAX_BYTES = 50\n\n/**\n * If `Buffer.TYPED_ARRAY_SUPPORT`:\n * === true Use Uint8Array implementation (fastest)\n * === false Use Object implementation (most compatible, even IE6)\n *\n * Browsers that support typed arrays are IE 10+, Firefox 4+, Chrome 7+, Safari 5.1+,\n * Opera 11.6+, iOS 4.2+.\n *\n * Due to various browser bugs, sometimes the Object implementation will be used even\n * when the browser supports typed arrays.\n *\n * Note:\n *\n * - Firefox 4-29 lacks support for adding new properties to `Uint8Array` instances,\n * See: https://bugzilla.mozilla.org/show_bug.cgi?id=695438.\n *\n * - Chrome 9-10 is missing the `TypedArray.prototype.subarray` function.\n *\n * - IE10 has a broken `TypedArray.prototype.subarray` function which returns arrays of\n * incorrect length in some situations.\n\n * We detect these buggy browsers and set `Buffer.TYPED_ARRAY_SUPPORT` to `false` so they\n * get the Object implementation, which is slower but behaves correctly.\n */\nBuffer.TYPED_ARRAY_SUPPORT = global.TYPED_ARRAY_SUPPORT !== undefined\n ? global.TYPED_ARRAY_SUPPORT\n : typedArraySupport()\n\n/*\n * Export kMaxLength after typed array support is determined.\n */\nexports.kMaxLength = kMaxLength()\n\nfunction typedArraySupport () {\n try {\n var arr = new Uint8Array(1)\n arr.__proto__ = {__proto__: Uint8Array.prototype, foo: function () { return 42 }}\n return arr.foo() === 42 && // typed array instances can be augmented\n typeof arr.subarray === 'function' && // chrome 9-10 lack `subarray`\n arr.subarray(1, 1).byteLength === 0 // ie10 has broken `subarray`\n } catch (e) {\n return false\n }\n}\n\nfunction kMaxLength () {\n return Buffer.TYPED_ARRAY_SUPPORT\n ? 0x7fffffff\n : 0x3fffffff\n}\n\nfunction createBuffer (that, length) {\n if (kMaxLength() < length) {\n throw new RangeError('Invalid typed array length')\n }\n if (Buffer.TYPED_ARRAY_SUPPORT) {\n // Return an augmented `Uint8Array` instance, for best performance\n that = new Uint8Array(length)\n that.__proto__ = Buffer.prototype\n } else {\n // Fallback: Return an object instance of the Buffer class\n if (that === null) {\n that = new Buffer(length)\n }\n that.length = length\n }\n\n return that\n}\n\n/**\n * The Buffer constructor returns instances of `Uint8Array` that have their\n * prototype changed to `Buffer.prototype`. Furthermore, `Buffer` is a subclass of\n * `Uint8Array`, so the returned instances will have all the node `Buffer` methods\n * and the `Uint8Array` methods. Square bracket notation works as expected -- it\n * returns a single octet.\n *\n * The `Uint8Array` prototype remains unmodified.\n */\n\nfunction Buffer (arg, encodingOrOffset, length) {\n if (!Buffer.TYPED_ARRAY_SUPPORT && !(this instanceof Buffer)) {\n return new Buffer(arg, encodingOrOffset, length)\n }\n\n // Common case.\n if (typeof arg === 'number') {\n if (typeof encodingOrOffset === 'string') {\n throw new Error(\n 'If encoding is specified then the first argument must be a string'\n )\n }\n return allocUnsafe(this, arg)\n }\n return from(this, arg, encodingOrOffset, length)\n}\n\nBuffer.poolSize = 8192 // not used by this implementation\n\n// TODO: Legacy, not needed anymore. Remove in next major version.\nBuffer._augment = function (arr) {\n arr.__proto__ = Buffer.prototype\n return arr\n}\n\nfunction from (that, value, encodingOrOffset, length) {\n if (typeof value === 'number') {\n throw new TypeError('\"value\" argument must not be a number')\n }\n\n if (typeof ArrayBuffer !== 'undefined' && value instanceof ArrayBuffer) {\n return fromArrayBuffer(that, value, encodingOrOffset, length)\n }\n\n if (typeof value === 'string') {\n return fromString(that, value, encodingOrOffset)\n }\n\n return fromObject(that, value)\n}\n\n/**\n * Functionally equivalent to Buffer(arg, encoding) but throws a TypeError\n * if value is a number.\n * Buffer.from(str[, encoding])\n * Buffer.from(array)\n * Buffer.from(buffer)\n * Buffer.from(arrayBuffer[, byteOffset[, length]])\n **/\nBuffer.from = function (value, encodingOrOffset, length) {\n return from(null, value, encodingOrOffset, length)\n}\n\nif (Buffer.TYPED_ARRAY_SUPPORT) {\n Buffer.prototype.__proto__ = Uint8Array.prototype\n Buffer.__proto__ = Uint8Array\n if (typeof Symbol !== 'undefined' && Symbol.species &&\n Buffer[Symbol.species] === Buffer) {\n // Fix subarray() in ES2016. See: https://github.com/feross/buffer/pull/97\n Object.defineProperty(Buffer, Symbol.species, {\n value: null,\n configurable: true\n })\n }\n}\n\nfunction assertSize (size) {\n if (typeof size !== 'number') {\n throw new TypeError('\"size\" argument must be a number')\n } else if (size < 0) {\n throw new RangeError('\"size\" argument must not be negative')\n }\n}\n\nfunction alloc (that, size, fill, encoding) {\n assertSize(size)\n if (size <= 0) {\n return createBuffer(that, size)\n }\n if (fill !== undefined) {\n // Only pay attention to encoding if it's a string. This\n // prevents accidentally sending in a number that would\n // be interpretted as a start offset.\n return typeof encoding === 'string'\n ? createBuffer(that, size).fill(fill, encoding)\n : createBuffer(that, size).fill(fill)\n }\n return createBuffer(that, size)\n}\n\n/**\n * Creates a new filled Buffer instance.\n * alloc(size[, fill[, encoding]])\n **/\nBuffer.alloc = function (size, fill, encoding) {\n return alloc(null, size, fill, encoding)\n}\n\nfunction allocUnsafe (that, size) {\n assertSize(size)\n that = createBuffer(that, size < 0 ? 0 : checked(size) | 0)\n if (!Buffer.TYPED_ARRAY_SUPPORT) {\n for (var i = 0; i < size; ++i) {\n that[i] = 0\n }\n }\n return that\n}\n\n/**\n * Equivalent to Buffer(num), by default creates a non-zero-filled Buffer instance.\n * */\nBuffer.allocUnsafe = function (size) {\n return allocUnsafe(null, size)\n}\n/**\n * Equivalent to SlowBuffer(num), by default creates a non-zero-filled Buffer instance.\n */\nBuffer.allocUnsafeSlow = function (size) {\n return allocUnsafe(null, size)\n}\n\nfunction fromString (that, string, encoding) {\n if (typeof encoding !== 'string' || encoding === '') {\n encoding = 'utf8'\n }\n\n if (!Buffer.isEncoding(encoding)) {\n throw new TypeError('\"encoding\" must be a valid string encoding')\n }\n\n var length = byteLength(string, encoding) | 0\n that = createBuffer(that, length)\n\n var actual = that.write(string, encoding)\n\n if (actual !== length) {\n // Writing a hex string, for example, that contains invalid characters will\n // cause everything after the first invalid character to be ignored. (e.g.\n // 'abxxcd' will be treated as 'ab')\n that = that.slice(0, actual)\n }\n\n return that\n}\n\nfunction fromArrayLike (that, array) {\n var length = array.length < 0 ? 0 : checked(array.length) | 0\n that = createBuffer(that, length)\n for (var i = 0; i < length; i += 1) {\n that[i] = array[i] & 255\n }\n return that\n}\n\nfunction fromArrayBuffer (that, array, byteOffset, length) {\n array.byteLength // this throws if `array` is not a valid ArrayBuffer\n\n if (byteOffset < 0 || array.byteLength < byteOffset) {\n throw new RangeError('\\'offset\\' is out of bounds')\n }\n\n if (array.byteLength < byteOffset + (length || 0)) {\n throw new RangeError('\\'length\\' is out of bounds')\n }\n\n if (byteOffset === undefined && length === undefined) {\n array = new Uint8Array(array)\n } else if (length === undefined) {\n array = new Uint8Array(array, byteOffset)\n } else {\n array = new Uint8Array(array, byteOffset, length)\n }\n\n if (Buffer.TYPED_ARRAY_SUPPORT) {\n // Return an augmented `Uint8Array` instance, for best performance\n that = array\n that.__proto__ = Buffer.prototype\n } else {\n // Fallback: Return an object instance of the Buffer class\n that = fromArrayLike(that, array)\n }\n return that\n}\n\nfunction fromObject (that, obj) {\n if (Buffer.isBuffer(obj)) {\n var len = checked(obj.length) | 0\n that = createBuffer(that, len)\n\n if (that.length === 0) {\n return that\n }\n\n obj.copy(that, 0, 0, len)\n return that\n }\n\n if (obj) {\n if ((typeof ArrayBuffer !== 'undefined' &&\n obj.buffer instanceof ArrayBuffer) || 'length' in obj) {\n if (typeof obj.length !== 'number' || isnan(obj.length)) {\n return createBuffer(that, 0)\n }\n return fromArrayLike(that, obj)\n }\n\n if (obj.type === 'Buffer' && isArray(obj.data)) {\n return fromArrayLike(that, obj.data)\n }\n }\n\n throw new TypeError('First argument must be a string, Buffer, ArrayBuffer, Array, or array-like object.')\n}\n\nfunction checked (length) {\n // Note: cannot use `length < kMaxLength()` here because that fails when\n // length is NaN (which is otherwise coerced to zero.)\n if (length >= kMaxLength()) {\n throw new RangeError('Attempt to allocate Buffer larger than maximum ' +\n 'size: 0x' + kMaxLength().toString(16) + ' bytes')\n }\n return length | 0\n}\n\nfunction SlowBuffer (length) {\n if (+length != length) { // eslint-disable-line eqeqeq\n length = 0\n }\n return Buffer.alloc(+length)\n}\n\nBuffer.isBuffer = function isBuffer (b) {\n return !!(b != null && b._isBuffer)\n}\n\nBuffer.compare = function compare (a, b) {\n if (!Buffer.isBuffer(a) || !Buffer.isBuffer(b)) {\n throw new TypeError('Arguments must be Buffers')\n }\n\n if (a === b) return 0\n\n var x = a.length\n var y = b.length\n\n for (var i = 0, len = Math.min(x, y); i < len; ++i) {\n if (a[i] !== b[i]) {\n x = a[i]\n y = b[i]\n break\n }\n }\n\n if (x < y) return -1\n if (y < x) return 1\n return 0\n}\n\nBuffer.isEncoding = function isEncoding (encoding) {\n switch (String(encoding).toLowerCase()) {\n case 'hex':\n case 'utf8':\n case 'utf-8':\n case 'ascii':\n case 'latin1':\n case 'binary':\n case 'base64':\n case 'ucs2':\n case 'ucs-2':\n case 'utf16le':\n case 'utf-16le':\n return true\n default:\n return false\n }\n}\n\nBuffer.concat = function concat (list, length) {\n if (!isArray(list)) {\n throw new TypeError('\"list\" argument must be an Array of Buffers')\n }\n\n if (list.length === 0) {\n return Buffer.alloc(0)\n }\n\n var i\n if (length === undefined) {\n length = 0\n for (i = 0; i < list.length; ++i) {\n length += list[i].length\n }\n }\n\n var buffer = Buffer.allocUnsafe(length)\n var pos = 0\n for (i = 0; i < list.length; ++i) {\n var buf = list[i]\n if (!Buffer.isBuffer(buf)) {\n throw new TypeError('\"list\" argument must be an Array of Buffers')\n }\n buf.copy(buffer, pos)\n pos += buf.length\n }\n return buffer\n}\n\nfunction byteLength (string, encoding) {\n if (Buffer.isBuffer(string)) {\n return string.length\n }\n if (typeof ArrayBuffer !== 'undefined' && typeof ArrayBuffer.isView === 'function' &&\n (ArrayBuffer.isView(string) || string instanceof ArrayBuffer)) {\n return string.byteLength\n }\n if (typeof string !== 'string') {\n string = '' + string\n }\n\n var len = string.length\n if (len === 0) return 0\n\n // Use a for loop to avoid recursion\n var loweredCase = false\n for (;;) {\n switch (encoding) {\n case 'ascii':\n case 'latin1':\n case 'binary':\n return len\n case 'utf8':\n case 'utf-8':\n case undefined:\n return utf8ToBytes(string).length\n case 'ucs2':\n case 'ucs-2':\n case 'utf16le':\n case 'utf-16le':\n return len * 2\n case 'hex':\n return len >>> 1\n case 'base64':\n return base64ToBytes(string).length\n default:\n if (loweredCase) return utf8ToBytes(string).length // assume utf8\n encoding = ('' + encoding).toLowerCase()\n loweredCase = true\n }\n }\n}\nBuffer.byteLength = byteLength\n\nfunction slowToString (encoding, start, end) {\n var loweredCase = false\n\n // No need to verify that \"this.length <= MAX_UINT32\" since it's a read-only\n // property of a typed array.\n\n // This behaves neither like String nor Uint8Array in that we set start/end\n // to their upper/lower bounds if the value passed is out of range.\n // undefined is handled specially as per ECMA-262 6th Edition,\n // Section 13.3.3.7 Runtime Semantics: KeyedBindingInitialization.\n if (start === undefined || start < 0) {\n start = 0\n }\n // Return early if start > this.length. Done here to prevent potential uint32\n // coercion fail below.\n if (start > this.length) {\n return ''\n }\n\n if (end === undefined || end > this.length) {\n end = this.length\n }\n\n if (end <= 0) {\n return ''\n }\n\n // Force coersion to uint32. This will also coerce falsey/NaN values to 0.\n end >>>= 0\n start >>>= 0\n\n if (end <= start) {\n return ''\n }\n\n if (!encoding) encoding = 'utf8'\n\n while (true) {\n switch (encoding) {\n case 'hex':\n return hexSlice(this, start, end)\n\n case 'utf8':\n case 'utf-8':\n return utf8Slice(this, start, end)\n\n case 'ascii':\n return asciiSlice(this, start, end)\n\n case 'latin1':\n case 'binary':\n return latin1Slice(this, start, end)\n\n case 'base64':\n return base64Slice(this, start, end)\n\n case 'ucs2':\n case 'ucs-2':\n case 'utf16le':\n case 'utf-16le':\n return utf16leSlice(this, start, end)\n\n default:\n if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)\n encoding = (encoding + '').toLowerCase()\n loweredCase = true\n }\n }\n}\n\n// The property is used by `Buffer.isBuffer` and `is-buffer` (in Safari 5-7) to detect\n// Buffer instances.\nBuffer.prototype._isBuffer = true\n\nfunction swap (b, n, m) {\n var i = b[n]\n b[n] = b[m]\n b[m] = i\n}\n\nBuffer.prototype.swap16 = function swap16 () {\n var len = this.length\n if (len % 2 !== 0) {\n throw new RangeError('Buffer size must be a multiple of 16-bits')\n }\n for (var i = 0; i < len; i += 2) {\n swap(this, i, i + 1)\n }\n return this\n}\n\nBuffer.prototype.swap32 = function swap32 () {\n var len = this.length\n if (len % 4 !== 0) {\n throw new RangeError('Buffer size must be a multiple of 32-bits')\n }\n for (var i = 0; i < len; i += 4) {\n swap(this, i, i + 3)\n swap(this, i + 1, i + 2)\n }\n return this\n}\n\nBuffer.prototype.swap64 = function swap64 () {\n var len = this.length\n if (len % 8 !== 0) {\n throw new RangeError('Buffer size must be a multiple of 64-bits')\n }\n for (var i = 0; i < len; i += 8) {\n swap(this, i, i + 7)\n swap(this, i + 1, i + 6)\n swap(this, i + 2, i + 5)\n swap(this, i + 3, i + 4)\n }\n return this\n}\n\nBuffer.prototype.toString = function toString () {\n var length = this.length | 0\n if (length === 0) return ''\n if (arguments.length === 0) return utf8Slice(this, 0, length)\n return slowToString.apply(this, arguments)\n}\n\nBuffer.prototype.equals = function equals (b) {\n if (!Buffer.isBuffer(b)) throw new TypeError('Argument must be a Buffer')\n if (this === b) return true\n return Buffer.compare(this, b) === 0\n}\n\nBuffer.prototype.inspect = function inspect () {\n var str = ''\n var max = exports.INSPECT_MAX_BYTES\n if (this.length > 0) {\n str = this.toString('hex', 0, max).match(/.{2}/g).join(' ')\n if (this.length > max) str += ' ... '\n }\n return ''\n}\n\nBuffer.prototype.compare = function compare (target, start, end, thisStart, thisEnd) {\n if (!Buffer.isBuffer(target)) {\n throw new TypeError('Argument must be a Buffer')\n }\n\n if (start === undefined) {\n start = 0\n }\n if (end === undefined) {\n end = target ? target.length : 0\n }\n if (thisStart === undefined) {\n thisStart = 0\n }\n if (thisEnd === undefined) {\n thisEnd = this.length\n }\n\n if (start < 0 || end > target.length || thisStart < 0 || thisEnd > this.length) {\n throw new RangeError('out of range index')\n }\n\n if (thisStart >= thisEnd && start >= end) {\n return 0\n }\n if (thisStart >= thisEnd) {\n return -1\n }\n if (start >= end) {\n return 1\n }\n\n start >>>= 0\n end >>>= 0\n thisStart >>>= 0\n thisEnd >>>= 0\n\n if (this === target) return 0\n\n var x = thisEnd - thisStart\n var y = end - start\n var len = Math.min(x, y)\n\n var thisCopy = this.slice(thisStart, thisEnd)\n var targetCopy = target.slice(start, end)\n\n for (var i = 0; i < len; ++i) {\n if (thisCopy[i] !== targetCopy[i]) {\n x = thisCopy[i]\n y = targetCopy[i]\n break\n }\n }\n\n if (x < y) return -1\n if (y < x) return 1\n return 0\n}\n\n// Finds either the first index of `val` in `buffer` at offset >= `byteOffset`,\n// OR the last index of `val` in `buffer` at offset <= `byteOffset`.\n//\n// Arguments:\n// - buffer - a Buffer to search\n// - val - a string, Buffer, or number\n// - byteOffset - an index into `buffer`; will be clamped to an int32\n// - encoding - an optional encoding, relevant is val is a string\n// - dir - true for indexOf, false for lastIndexOf\nfunction bidirectionalIndexOf (buffer, val, byteOffset, encoding, dir) {\n // Empty buffer means no match\n if (buffer.length === 0) return -1\n\n // Normalize byteOffset\n if (typeof byteOffset === 'string') {\n encoding = byteOffset\n byteOffset = 0\n } else if (byteOffset > 0x7fffffff) {\n byteOffset = 0x7fffffff\n } else if (byteOffset < -0x80000000) {\n byteOffset = -0x80000000\n }\n byteOffset = +byteOffset // Coerce to Number.\n if (isNaN(byteOffset)) {\n // byteOffset: it it's undefined, null, NaN, \"foo\", etc, search whole buffer\n byteOffset = dir ? 0 : (buffer.length - 1)\n }\n\n // Normalize byteOffset: negative offsets start from the end of the buffer\n if (byteOffset < 0) byteOffset = buffer.length + byteOffset\n if (byteOffset >= buffer.length) {\n if (dir) return -1\n else byteOffset = buffer.length - 1\n } else if (byteOffset < 0) {\n if (dir) byteOffset = 0\n else return -1\n }\n\n // Normalize val\n if (typeof val === 'string') {\n val = Buffer.from(val, encoding)\n }\n\n // Finally, search either indexOf (if dir is true) or lastIndexOf\n if (Buffer.isBuffer(val)) {\n // Special case: looking for empty string/buffer always fails\n if (val.length === 0) {\n return -1\n }\n return arrayIndexOf(buffer, val, byteOffset, encoding, dir)\n } else if (typeof val === 'number') {\n val = val & 0xFF // Search for a byte value [0-255]\n if (Buffer.TYPED_ARRAY_SUPPORT &&\n typeof Uint8Array.prototype.indexOf === 'function') {\n if (dir) {\n return Uint8Array.prototype.indexOf.call(buffer, val, byteOffset)\n } else {\n return Uint8Array.prototype.lastIndexOf.call(buffer, val, byteOffset)\n }\n }\n return arrayIndexOf(buffer, [ val ], byteOffset, encoding, dir)\n }\n\n throw new TypeError('val must be string, number or Buffer')\n}\n\nfunction arrayIndexOf (arr, val, byteOffset, encoding, dir) {\n var indexSize = 1\n var arrLength = arr.length\n var valLength = val.length\n\n if (encoding !== undefined) {\n encoding = String(encoding).toLowerCase()\n if (encoding === 'ucs2' || encoding === 'ucs-2' ||\n encoding === 'utf16le' || encoding === 'utf-16le') {\n if (arr.length < 2 || val.length < 2) {\n return -1\n }\n indexSize = 2\n arrLength /= 2\n valLength /= 2\n byteOffset /= 2\n }\n }\n\n function read (buf, i) {\n if (indexSize === 1) {\n return buf[i]\n } else {\n return buf.readUInt16BE(i * indexSize)\n }\n }\n\n var i\n if (dir) {\n var foundIndex = -1\n for (i = byteOffset; i < arrLength; i++) {\n if (read(arr, i) === read(val, foundIndex === -1 ? 0 : i - foundIndex)) {\n if (foundIndex === -1) foundIndex = i\n if (i - foundIndex + 1 === valLength) return foundIndex * indexSize\n } else {\n if (foundIndex !== -1) i -= i - foundIndex\n foundIndex = -1\n }\n }\n } else {\n if (byteOffset + valLength > arrLength) byteOffset = arrLength - valLength\n for (i = byteOffset; i >= 0; i--) {\n var found = true\n for (var j = 0; j < valLength; j++) {\n if (read(arr, i + j) !== read(val, j)) {\n found = false\n break\n }\n }\n if (found) return i\n }\n }\n\n return -1\n}\n\nBuffer.prototype.includes = function includes (val, byteOffset, encoding) {\n return this.indexOf(val, byteOffset, encoding) !== -1\n}\n\nBuffer.prototype.indexOf = function indexOf (val, byteOffset, encoding) {\n return bidirectionalIndexOf(this, val, byteOffset, encoding, true)\n}\n\nBuffer.prototype.lastIndexOf = function lastIndexOf (val, byteOffset, encoding) {\n return bidirectionalIndexOf(this, val, byteOffset, encoding, false)\n}\n\nfunction hexWrite (buf, string, offset, length) {\n offset = Number(offset) || 0\n var remaining = buf.length - offset\n if (!length) {\n length = remaining\n } else {\n length = Number(length)\n if (length > remaining) {\n length = remaining\n }\n }\n\n // must be an even number of digits\n var strLen = string.length\n if (strLen % 2 !== 0) throw new TypeError('Invalid hex string')\n\n if (length > strLen / 2) {\n length = strLen / 2\n }\n for (var i = 0; i < length; ++i) {\n var parsed = parseInt(string.substr(i * 2, 2), 16)\n if (isNaN(parsed)) return i\n buf[offset + i] = parsed\n }\n return i\n}\n\nfunction utf8Write (buf, string, offset, length) {\n return blitBuffer(utf8ToBytes(string, buf.length - offset), buf, offset, length)\n}\n\nfunction asciiWrite (buf, string, offset, length) {\n return blitBuffer(asciiToBytes(string), buf, offset, length)\n}\n\nfunction latin1Write (buf, string, offset, length) {\n return asciiWrite(buf, string, offset, length)\n}\n\nfunction base64Write (buf, string, offset, length) {\n return blitBuffer(base64ToBytes(string), buf, offset, length)\n}\n\nfunction ucs2Write (buf, string, offset, length) {\n return blitBuffer(utf16leToBytes(string, buf.length - offset), buf, offset, length)\n}\n\nBuffer.prototype.write = function write (string, offset, length, encoding) {\n // Buffer#write(string)\n if (offset === undefined) {\n encoding = 'utf8'\n length = this.length\n offset = 0\n // Buffer#write(string, encoding)\n } else if (length === undefined && typeof offset === 'string') {\n encoding = offset\n length = this.length\n offset = 0\n // Buffer#write(string, offset[, length][, encoding])\n } else if (isFinite(offset)) {\n offset = offset | 0\n if (isFinite(length)) {\n length = length | 0\n if (encoding === undefined) encoding = 'utf8'\n } else {\n encoding = length\n length = undefined\n }\n // legacy write(string, encoding, offset, length) - remove in v0.13\n } else {\n throw new Error(\n 'Buffer.write(string, encoding, offset[, length]) is no longer supported'\n )\n }\n\n var remaining = this.length - offset\n if (length === undefined || length > remaining) length = remaining\n\n if ((string.length > 0 && (length < 0 || offset < 0)) || offset > this.length) {\n throw new RangeError('Attempt to write outside buffer bounds')\n }\n\n if (!encoding) encoding = 'utf8'\n\n var loweredCase = false\n for (;;) {\n switch (encoding) {\n case 'hex':\n return hexWrite(this, string, offset, length)\n\n case 'utf8':\n case 'utf-8':\n return utf8Write(this, string, offset, length)\n\n case 'ascii':\n return asciiWrite(this, string, offset, length)\n\n case 'latin1':\n case 'binary':\n return latin1Write(this, string, offset, length)\n\n case 'base64':\n // Warning: maxLength not taken into account in base64Write\n return base64Write(this, string, offset, length)\n\n case 'ucs2':\n case 'ucs-2':\n case 'utf16le':\n case 'utf-16le':\n return ucs2Write(this, string, offset, length)\n\n default:\n if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)\n encoding = ('' + encoding).toLowerCase()\n loweredCase = true\n }\n }\n}\n\nBuffer.prototype.toJSON = function toJSON () {\n return {\n type: 'Buffer',\n data: Array.prototype.slice.call(this._arr || this, 0)\n }\n}\n\nfunction base64Slice (buf, start, end) {\n if (start === 0 && end === buf.length) {\n return base64.fromByteArray(buf)\n } else {\n return base64.fromByteArray(buf.slice(start, end))\n }\n}\n\nfunction utf8Slice (buf, start, end) {\n end = Math.min(buf.length, end)\n var res = []\n\n var i = start\n while (i < end) {\n var firstByte = buf[i]\n var codePoint = null\n var bytesPerSequence = (firstByte > 0xEF) ? 4\n : (firstByte > 0xDF) ? 3\n : (firstByte > 0xBF) ? 2\n : 1\n\n if (i + bytesPerSequence <= end) {\n var secondByte, thirdByte, fourthByte, tempCodePoint\n\n switch (bytesPerSequence) {\n case 1:\n if (firstByte < 0x80) {\n codePoint = firstByte\n }\n break\n case 2:\n secondByte = buf[i + 1]\n if ((secondByte & 0xC0) === 0x80) {\n tempCodePoint = (firstByte & 0x1F) << 0x6 | (secondByte & 0x3F)\n if (tempCodePoint > 0x7F) {\n codePoint = tempCodePoint\n }\n }\n break\n case 3:\n secondByte = buf[i + 1]\n thirdByte = buf[i + 2]\n if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80) {\n tempCodePoint = (firstByte & 0xF) << 0xC | (secondByte & 0x3F) << 0x6 | (thirdByte & 0x3F)\n if (tempCodePoint > 0x7FF && (tempCodePoint < 0xD800 || tempCodePoint > 0xDFFF)) {\n codePoint = tempCodePoint\n }\n }\n break\n case 4:\n secondByte = buf[i + 1]\n thirdByte = buf[i + 2]\n fourthByte = buf[i + 3]\n if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80 && (fourthByte & 0xC0) === 0x80) {\n tempCodePoint = (firstByte & 0xF) << 0x12 | (secondByte & 0x3F) << 0xC | (thirdByte & 0x3F) << 0x6 | (fourthByte & 0x3F)\n if (tempCodePoint > 0xFFFF && tempCodePoint < 0x110000) {\n codePoint = tempCodePoint\n }\n }\n }\n }\n\n if (codePoint === null) {\n // we did not generate a valid codePoint so insert a\n // replacement char (U+FFFD) and advance only 1 byte\n codePoint = 0xFFFD\n bytesPerSequence = 1\n } else if (codePoint > 0xFFFF) {\n // encode to utf16 (surrogate pair dance)\n codePoint -= 0x10000\n res.push(codePoint >>> 10 & 0x3FF | 0xD800)\n codePoint = 0xDC00 | codePoint & 0x3FF\n }\n\n res.push(codePoint)\n i += bytesPerSequence\n }\n\n return decodeCodePointsArray(res)\n}\n\n// Based on http://stackoverflow.com/a/22747272/680742, the browser with\n// the lowest limit is Chrome, with 0x10000 args.\n// We go 1 magnitude less, for safety\nvar MAX_ARGUMENTS_LENGTH = 0x1000\n\nfunction decodeCodePointsArray (codePoints) {\n var len = codePoints.length\n if (len <= MAX_ARGUMENTS_LENGTH) {\n return String.fromCharCode.apply(String, codePoints) // avoid extra slice()\n }\n\n // Decode in chunks to avoid \"call stack size exceeded\".\n var res = ''\n var i = 0\n while (i < len) {\n res += String.fromCharCode.apply(\n String,\n codePoints.slice(i, i += MAX_ARGUMENTS_LENGTH)\n )\n }\n return res\n}\n\nfunction asciiSlice (buf, start, end) {\n var ret = ''\n end = Math.min(buf.length, end)\n\n for (var i = start; i < end; ++i) {\n ret += String.fromCharCode(buf[i] & 0x7F)\n }\n return ret\n}\n\nfunction latin1Slice (buf, start, end) {\n var ret = ''\n end = Math.min(buf.length, end)\n\n for (var i = start; i < end; ++i) {\n ret += String.fromCharCode(buf[i])\n }\n return ret\n}\n\nfunction hexSlice (buf, start, end) {\n var len = buf.length\n\n if (!start || start < 0) start = 0\n if (!end || end < 0 || end > len) end = len\n\n var out = ''\n for (var i = start; i < end; ++i) {\n out += toHex(buf[i])\n }\n return out\n}\n\nfunction utf16leSlice (buf, start, end) {\n var bytes = buf.slice(start, end)\n var res = ''\n for (var i = 0; i < bytes.length; i += 2) {\n res += String.fromCharCode(bytes[i] + bytes[i + 1] * 256)\n }\n return res\n}\n\nBuffer.prototype.slice = function slice (start, end) {\n var len = this.length\n start = ~~start\n end = end === undefined ? len : ~~end\n\n if (start < 0) {\n start += len\n if (start < 0) start = 0\n } else if (start > len) {\n start = len\n }\n\n if (end < 0) {\n end += len\n if (end < 0) end = 0\n } else if (end > len) {\n end = len\n }\n\n if (end < start) end = start\n\n var newBuf\n if (Buffer.TYPED_ARRAY_SUPPORT) {\n newBuf = this.subarray(start, end)\n newBuf.__proto__ = Buffer.prototype\n } else {\n var sliceLen = end - start\n newBuf = new Buffer(sliceLen, undefined)\n for (var i = 0; i < sliceLen; ++i) {\n newBuf[i] = this[i + start]\n }\n }\n\n return newBuf\n}\n\n/*\n * Need to make sure that buffer isn't trying to write out of bounds.\n */\nfunction checkOffset (offset, ext, length) {\n if ((offset % 1) !== 0 || offset < 0) throw new RangeError('offset is not uint')\n if (offset + ext > length) throw new RangeError('Trying to access beyond buffer length')\n}\n\nBuffer.prototype.readUIntLE = function readUIntLE (offset, byteLength, noAssert) {\n offset = offset | 0\n byteLength = byteLength | 0\n if (!noAssert) checkOffset(offset, byteLength, this.length)\n\n var val = this[offset]\n var mul = 1\n var i = 0\n while (++i < byteLength && (mul *= 0x100)) {\n val += this[offset + i] * mul\n }\n\n return val\n}\n\nBuffer.prototype.readUIntBE = function readUIntBE (offset, byteLength, noAssert) {\n offset = offset | 0\n byteLength = byteLength | 0\n if (!noAssert) {\n checkOffset(offset, byteLength, this.length)\n }\n\n var val = this[offset + --byteLength]\n var mul = 1\n while (byteLength > 0 && (mul *= 0x100)) {\n val += this[offset + --byteLength] * mul\n }\n\n return val\n}\n\nBuffer.prototype.readUInt8 = function readUInt8 (offset, noAssert) {\n if (!noAssert) checkOffset(offset, 1, this.length)\n return this[offset]\n}\n\nBuffer.prototype.readUInt16LE = function readUInt16LE (offset, noAssert) {\n if (!noAssert) checkOffset(offset, 2, this.length)\n return this[offset] | (this[offset + 1] << 8)\n}\n\nBuffer.prototype.readUInt16BE = function readUInt16BE (offset, noAssert) {\n if (!noAssert) checkOffset(offset, 2, this.length)\n return (this[offset] << 8) | this[offset + 1]\n}\n\nBuffer.prototype.readUInt32LE = function readUInt32LE (offset, noAssert) {\n if (!noAssert) checkOffset(offset, 4, this.length)\n\n return ((this[offset]) |\n (this[offset + 1] << 8) |\n (this[offset + 2] << 16)) +\n (this[offset + 3] * 0x1000000)\n}\n\nBuffer.prototype.readUInt32BE = function readUInt32BE (offset, noAssert) {\n if (!noAssert) checkOffset(offset, 4, this.length)\n\n return (this[offset] * 0x1000000) +\n ((this[offset + 1] << 16) |\n (this[offset + 2] << 8) |\n this[offset + 3])\n}\n\nBuffer.prototype.readIntLE = function readIntLE (offset, byteLength, noAssert) {\n offset = offset | 0\n byteLength = byteLength | 0\n if (!noAssert) checkOffset(offset, byteLength, this.length)\n\n var val = this[offset]\n var mul = 1\n var i = 0\n while (++i < byteLength && (mul *= 0x100)) {\n val += this[offset + i] * mul\n }\n mul *= 0x80\n\n if (val >= mul) val -= Math.pow(2, 8 * byteLength)\n\n return val\n}\n\nBuffer.prototype.readIntBE = function readIntBE (offset, byteLength, noAssert) {\n offset = offset | 0\n byteLength = byteLength | 0\n if (!noAssert) checkOffset(offset, byteLength, this.length)\n\n var i = byteLength\n var mul = 1\n var val = this[offset + --i]\n while (i > 0 && (mul *= 0x100)) {\n val += this[offset + --i] * mul\n }\n mul *= 0x80\n\n if (val >= mul) val -= Math.pow(2, 8 * byteLength)\n\n return val\n}\n\nBuffer.prototype.readInt8 = function readInt8 (offset, noAssert) {\n if (!noAssert) checkOffset(offset, 1, this.length)\n if (!(this[offset] & 0x80)) return (this[offset])\n return ((0xff - this[offset] + 1) * -1)\n}\n\nBuffer.prototype.readInt16LE = function readInt16LE (offset, noAssert) {\n if (!noAssert) checkOffset(offset, 2, this.length)\n var val = this[offset] | (this[offset + 1] << 8)\n return (val & 0x8000) ? val | 0xFFFF0000 : val\n}\n\nBuffer.prototype.readInt16BE = function readInt16BE (offset, noAssert) {\n if (!noAssert) checkOffset(offset, 2, this.length)\n var val = this[offset + 1] | (this[offset] << 8)\n return (val & 0x8000) ? val | 0xFFFF0000 : val\n}\n\nBuffer.prototype.readInt32LE = function readInt32LE (offset, noAssert) {\n if (!noAssert) checkOffset(offset, 4, this.length)\n\n return (this[offset]) |\n (this[offset + 1] << 8) |\n (this[offset + 2] << 16) |\n (this[offset + 3] << 24)\n}\n\nBuffer.prototype.readInt32BE = function readInt32BE (offset, noAssert) {\n if (!noAssert) checkOffset(offset, 4, this.length)\n\n return (this[offset] << 24) |\n (this[offset + 1] << 16) |\n (this[offset + 2] << 8) |\n (this[offset + 3])\n}\n\nBuffer.prototype.readFloatLE = function readFloatLE (offset, noAssert) {\n if (!noAssert) checkOffset(offset, 4, this.length)\n return ieee754.read(this, offset, true, 23, 4)\n}\n\nBuffer.prototype.readFloatBE = function readFloatBE (offset, noAssert) {\n if (!noAssert) checkOffset(offset, 4, this.length)\n return ieee754.read(this, offset, false, 23, 4)\n}\n\nBuffer.prototype.readDoubleLE = function readDoubleLE (offset, noAssert) {\n if (!noAssert) checkOffset(offset, 8, this.length)\n return ieee754.read(this, offset, true, 52, 8)\n}\n\nBuffer.prototype.readDoubleBE = function readDoubleBE (offset, noAssert) {\n if (!noAssert) checkOffset(offset, 8, this.length)\n return ieee754.read(this, offset, false, 52, 8)\n}\n\nfunction checkInt (buf, value, offset, ext, max, min) {\n if (!Buffer.isBuffer(buf)) throw new TypeError('\"buffer\" argument must be a Buffer instance')\n if (value > max || value < min) throw new RangeError('\"value\" argument is out of bounds')\n if (offset + ext > buf.length) throw new RangeError('Index out of range')\n}\n\nBuffer.prototype.writeUIntLE = function writeUIntLE (value, offset, byteLength, noAssert) {\n value = +value\n offset = offset | 0\n byteLength = byteLength | 0\n if (!noAssert) {\n var maxBytes = Math.pow(2, 8 * byteLength) - 1\n checkInt(this, value, offset, byteLength, maxBytes, 0)\n }\n\n var mul = 1\n var i = 0\n this[offset] = value & 0xFF\n while (++i < byteLength && (mul *= 0x100)) {\n this[offset + i] = (value / mul) & 0xFF\n }\n\n return offset + byteLength\n}\n\nBuffer.prototype.writeUIntBE = function writeUIntBE (value, offset, byteLength, noAssert) {\n value = +value\n offset = offset | 0\n byteLength = byteLength | 0\n if (!noAssert) {\n var maxBytes = Math.pow(2, 8 * byteLength) - 1\n checkInt(this, value, offset, byteLength, maxBytes, 0)\n }\n\n var i = byteLength - 1\n var mul = 1\n this[offset + i] = value & 0xFF\n while (--i >= 0 && (mul *= 0x100)) {\n this[offset + i] = (value / mul) & 0xFF\n }\n\n return offset + byteLength\n}\n\nBuffer.prototype.writeUInt8 = function writeUInt8 (value, offset, noAssert) {\n value = +value\n offset = offset | 0\n if (!noAssert) checkInt(this, value, offset, 1, 0xff, 0)\n if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value)\n this[offset] = (value & 0xff)\n return offset + 1\n}\n\nfunction objectWriteUInt16 (buf, value, offset, littleEndian) {\n if (value < 0) value = 0xffff + value + 1\n for (var i = 0, j = Math.min(buf.length - offset, 2); i < j; ++i) {\n buf[offset + i] = (value & (0xff << (8 * (littleEndian ? i : 1 - i)))) >>>\n (littleEndian ? i : 1 - i) * 8\n }\n}\n\nBuffer.prototype.writeUInt16LE = function writeUInt16LE (value, offset, noAssert) {\n value = +value\n offset = offset | 0\n if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)\n if (Buffer.TYPED_ARRAY_SUPPORT) {\n this[offset] = (value & 0xff)\n this[offset + 1] = (value >>> 8)\n } else {\n objectWriteUInt16(this, value, offset, true)\n }\n return offset + 2\n}\n\nBuffer.prototype.writeUInt16BE = function writeUInt16BE (value, offset, noAssert) {\n value = +value\n offset = offset | 0\n if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)\n if (Buffer.TYPED_ARRAY_SUPPORT) {\n this[offset] = (value >>> 8)\n this[offset + 1] = (value & 0xff)\n } else {\n objectWriteUInt16(this, value, offset, false)\n }\n return offset + 2\n}\n\nfunction objectWriteUInt32 (buf, value, offset, littleEndian) {\n if (value < 0) value = 0xffffffff + value + 1\n for (var i = 0, j = Math.min(buf.length - offset, 4); i < j; ++i) {\n buf[offset + i] = (value >>> (littleEndian ? i : 3 - i) * 8) & 0xff\n }\n}\n\nBuffer.prototype.writeUInt32LE = function writeUInt32LE (value, offset, noAssert) {\n value = +value\n offset = offset | 0\n if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)\n if (Buffer.TYPED_ARRAY_SUPPORT) {\n this[offset + 3] = (value >>> 24)\n this[offset + 2] = (value >>> 16)\n this[offset + 1] = (value >>> 8)\n this[offset] = (value & 0xff)\n } else {\n objectWriteUInt32(this, value, offset, true)\n }\n return offset + 4\n}\n\nBuffer.prototype.writeUInt32BE = function writeUInt32BE (value, offset, noAssert) {\n value = +value\n offset = offset | 0\n if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)\n if (Buffer.TYPED_ARRAY_SUPPORT) {\n this[offset] = (value >>> 24)\n this[offset + 1] = (value >>> 16)\n this[offset + 2] = (value >>> 8)\n this[offset + 3] = (value & 0xff)\n } else {\n objectWriteUInt32(this, value, offset, false)\n }\n return offset + 4\n}\n\nBuffer.prototype.writeIntLE = function writeIntLE (value, offset, byteLength, noAssert) {\n value = +value\n offset = offset | 0\n if (!noAssert) {\n var limit = Math.pow(2, 8 * byteLength - 1)\n\n checkInt(this, value, offset, byteLength, limit - 1, -limit)\n }\n\n var i = 0\n var mul = 1\n var sub = 0\n this[offset] = value & 0xFF\n while (++i < byteLength && (mul *= 0x100)) {\n if (value < 0 && sub === 0 && this[offset + i - 1] !== 0) {\n sub = 1\n }\n this[offset + i] = ((value / mul) >> 0) - sub & 0xFF\n }\n\n return offset + byteLength\n}\n\nBuffer.prototype.writeIntBE = function writeIntBE (value, offset, byteLength, noAssert) {\n value = +value\n offset = offset | 0\n if (!noAssert) {\n var limit = Math.pow(2, 8 * byteLength - 1)\n\n checkInt(this, value, offset, byteLength, limit - 1, -limit)\n }\n\n var i = byteLength - 1\n var mul = 1\n var sub = 0\n this[offset + i] = value & 0xFF\n while (--i >= 0 && (mul *= 0x100)) {\n if (value < 0 && sub === 0 && this[offset + i + 1] !== 0) {\n sub = 1\n }\n this[offset + i] = ((value / mul) >> 0) - sub & 0xFF\n }\n\n return offset + byteLength\n}\n\nBuffer.prototype.writeInt8 = function writeInt8 (value, offset, noAssert) {\n value = +value\n offset = offset | 0\n if (!noAssert) checkInt(this, value, offset, 1, 0x7f, -0x80)\n if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value)\n if (value < 0) value = 0xff + value + 1\n this[offset] = (value & 0xff)\n return offset + 1\n}\n\nBuffer.prototype.writeInt16LE = function writeInt16LE (value, offset, noAssert) {\n value = +value\n offset = offset | 0\n if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000)\n if (Buffer.TYPED_ARRAY_SUPPORT) {\n this[offset] = (value & 0xff)\n this[offset + 1] = (value >>> 8)\n } else {\n objectWriteUInt16(this, value, offset, true)\n }\n return offset + 2\n}\n\nBuffer.prototype.writeInt16BE = function writeInt16BE (value, offset, noAssert) {\n value = +value\n offset = offset | 0\n if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000)\n if (Buffer.TYPED_ARRAY_SUPPORT) {\n this[offset] = (value >>> 8)\n this[offset + 1] = (value & 0xff)\n } else {\n objectWriteUInt16(this, value, offset, false)\n }\n return offset + 2\n}\n\nBuffer.prototype.writeInt32LE = function writeInt32LE (value, offset, noAssert) {\n value = +value\n offset = offset | 0\n if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)\n if (Buffer.TYPED_ARRAY_SUPPORT) {\n this[offset] = (value & 0xff)\n this[offset + 1] = (value >>> 8)\n this[offset + 2] = (value >>> 16)\n this[offset + 3] = (value >>> 24)\n } else {\n objectWriteUInt32(this, value, offset, true)\n }\n return offset + 4\n}\n\nBuffer.prototype.writeInt32BE = function writeInt32BE (value, offset, noAssert) {\n value = +value\n offset = offset | 0\n if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)\n if (value < 0) value = 0xffffffff + value + 1\n if (Buffer.TYPED_ARRAY_SUPPORT) {\n this[offset] = (value >>> 24)\n this[offset + 1] = (value >>> 16)\n this[offset + 2] = (value >>> 8)\n this[offset + 3] = (value & 0xff)\n } else {\n objectWriteUInt32(this, value, offset, false)\n }\n return offset + 4\n}\n\nfunction checkIEEE754 (buf, value, offset, ext, max, min) {\n if (offset + ext > buf.length) throw new RangeError('Index out of range')\n if (offset < 0) throw new RangeError('Index out of range')\n}\n\nfunction writeFloat (buf, value, offset, littleEndian, noAssert) {\n if (!noAssert) {\n checkIEEE754(buf, value, offset, 4, 3.4028234663852886e+38, -3.4028234663852886e+38)\n }\n ieee754.write(buf, value, offset, littleEndian, 23, 4)\n return offset + 4\n}\n\nBuffer.prototype.writeFloatLE = function writeFloatLE (value, offset, noAssert) {\n return writeFloat(this, value, offset, true, noAssert)\n}\n\nBuffer.prototype.writeFloatBE = function writeFloatBE (value, offset, noAssert) {\n return writeFloat(this, value, offset, false, noAssert)\n}\n\nfunction writeDouble (buf, value, offset, littleEndian, noAssert) {\n if (!noAssert) {\n checkIEEE754(buf, value, offset, 8, 1.7976931348623157E+308, -1.7976931348623157E+308)\n }\n ieee754.write(buf, value, offset, littleEndian, 52, 8)\n return offset + 8\n}\n\nBuffer.prototype.writeDoubleLE = function writeDoubleLE (value, offset, noAssert) {\n return writeDouble(this, value, offset, true, noAssert)\n}\n\nBuffer.prototype.writeDoubleBE = function writeDoubleBE (value, offset, noAssert) {\n return writeDouble(this, value, offset, false, noAssert)\n}\n\n// copy(targetBuffer, targetStart=0, sourceStart=0, sourceEnd=buffer.length)\nBuffer.prototype.copy = function copy (target, targetStart, start, end) {\n if (!start) start = 0\n if (!end && end !== 0) end = this.length\n if (targetStart >= target.length) targetStart = target.length\n if (!targetStart) targetStart = 0\n if (end > 0 && end < start) end = start\n\n // Copy 0 bytes; we're done\n if (end === start) return 0\n if (target.length === 0 || this.length === 0) return 0\n\n // Fatal error conditions\n if (targetStart < 0) {\n throw new RangeError('targetStart out of bounds')\n }\n if (start < 0 || start >= this.length) throw new RangeError('sourceStart out of bounds')\n if (end < 0) throw new RangeError('sourceEnd out of bounds')\n\n // Are we oob?\n if (end > this.length) end = this.length\n if (target.length - targetStart < end - start) {\n end = target.length - targetStart + start\n }\n\n var len = end - start\n var i\n\n if (this === target && start < targetStart && targetStart < end) {\n // descending copy from end\n for (i = len - 1; i >= 0; --i) {\n target[i + targetStart] = this[i + start]\n }\n } else if (len < 1000 || !Buffer.TYPED_ARRAY_SUPPORT) {\n // ascending copy from start\n for (i = 0; i < len; ++i) {\n target[i + targetStart] = this[i + start]\n }\n } else {\n Uint8Array.prototype.set.call(\n target,\n this.subarray(start, start + len),\n targetStart\n )\n }\n\n return len\n}\n\n// Usage:\n// buffer.fill(number[, offset[, end]])\n// buffer.fill(buffer[, offset[, end]])\n// buffer.fill(string[, offset[, end]][, encoding])\nBuffer.prototype.fill = function fill (val, start, end, encoding) {\n // Handle string cases:\n if (typeof val === 'string') {\n if (typeof start === 'string') {\n encoding = start\n start = 0\n end = this.length\n } else if (typeof end === 'string') {\n encoding = end\n end = this.length\n }\n if (val.length === 1) {\n var code = val.charCodeAt(0)\n if (code < 256) {\n val = code\n }\n }\n if (encoding !== undefined && typeof encoding !== 'string') {\n throw new TypeError('encoding must be a string')\n }\n if (typeof encoding === 'string' && !Buffer.isEncoding(encoding)) {\n throw new TypeError('Unknown encoding: ' + encoding)\n }\n } else if (typeof val === 'number') {\n val = val & 255\n }\n\n // Invalid ranges are not set to a default, so can range check early.\n if (start < 0 || this.length < start || this.length < end) {\n throw new RangeError('Out of range index')\n }\n\n if (end <= start) {\n return this\n }\n\n start = start >>> 0\n end = end === undefined ? this.length : end >>> 0\n\n if (!val) val = 0\n\n var i\n if (typeof val === 'number') {\n for (i = start; i < end; ++i) {\n this[i] = val\n }\n } else {\n var bytes = Buffer.isBuffer(val)\n ? val\n : utf8ToBytes(new Buffer(val, encoding).toString())\n var len = bytes.length\n for (i = 0; i < end - start; ++i) {\n this[i + start] = bytes[i % len]\n }\n }\n\n return this\n}\n\n// HELPER FUNCTIONS\n// ================\n\nvar INVALID_BASE64_RE = /[^+\\/0-9A-Za-z-_]/g\n\nfunction base64clean (str) {\n // Node strips out invalid characters like \\n and \\t from the string, base64-js does not\n str = stringtrim(str).replace(INVALID_BASE64_RE, '')\n // Node converts strings with length < 2 to ''\n if (str.length < 2) return ''\n // Node allows for non-padded base64 strings (missing trailing ===), base64-js does not\n while (str.length % 4 !== 0) {\n str = str + '='\n }\n return str\n}\n\nfunction stringtrim (str) {\n if (str.trim) return str.trim()\n return str.replace(/^\\s+|\\s+$/g, '')\n}\n\nfunction toHex (n) {\n if (n < 16) return '0' + n.toString(16)\n return n.toString(16)\n}\n\nfunction utf8ToBytes (string, units) {\n units = units || Infinity\n var codePoint\n var length = string.length\n var leadSurrogate = null\n var bytes = []\n\n for (var i = 0; i < length; ++i) {\n codePoint = string.charCodeAt(i)\n\n // is surrogate component\n if (codePoint > 0xD7FF && codePoint < 0xE000) {\n // last char was a lead\n if (!leadSurrogate) {\n // no lead yet\n if (codePoint > 0xDBFF) {\n // unexpected trail\n if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n continue\n } else if (i + 1 === length) {\n // unpaired lead\n if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n continue\n }\n\n // valid lead\n leadSurrogate = codePoint\n\n continue\n }\n\n // 2 leads in a row\n if (codePoint < 0xDC00) {\n if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n leadSurrogate = codePoint\n continue\n }\n\n // valid surrogate pair\n codePoint = (leadSurrogate - 0xD800 << 10 | codePoint - 0xDC00) + 0x10000\n } else if (leadSurrogate) {\n // valid bmp char, but last char was a lead\n if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n }\n\n leadSurrogate = null\n\n // encode utf8\n if (codePoint < 0x80) {\n if ((units -= 1) < 0) break\n bytes.push(codePoint)\n } else if (codePoint < 0x800) {\n if ((units -= 2) < 0) break\n bytes.push(\n codePoint >> 0x6 | 0xC0,\n codePoint & 0x3F | 0x80\n )\n } else if (codePoint < 0x10000) {\n if ((units -= 3) < 0) break\n bytes.push(\n codePoint >> 0xC | 0xE0,\n codePoint >> 0x6 & 0x3F | 0x80,\n codePoint & 0x3F | 0x80\n )\n } else if (codePoint < 0x110000) {\n if ((units -= 4) < 0) break\n bytes.push(\n codePoint >> 0x12 | 0xF0,\n codePoint >> 0xC & 0x3F | 0x80,\n codePoint >> 0x6 & 0x3F | 0x80,\n codePoint & 0x3F | 0x80\n )\n } else {\n throw new Error('Invalid code point')\n }\n }\n\n return bytes\n}\n\nfunction asciiToBytes (str) {\n var byteArray = []\n for (var i = 0; i < str.length; ++i) {\n // Node's code seems to be doing this and not & 0x7F..\n byteArray.push(str.charCodeAt(i) & 0xFF)\n }\n return byteArray\n}\n\nfunction utf16leToBytes (str, units) {\n var c, hi, lo\n var byteArray = []\n for (var i = 0; i < str.length; ++i) {\n if ((units -= 2) < 0) break\n\n c = str.charCodeAt(i)\n hi = c >> 8\n lo = c % 256\n byteArray.push(lo)\n byteArray.push(hi)\n }\n\n return byteArray\n}\n\nfunction base64ToBytes (str) {\n return base64.toByteArray(base64clean(str))\n}\n\nfunction blitBuffer (src, dst, offset, length) {\n for (var i = 0; i < length; ++i) {\n if ((i + offset >= dst.length) || (i >= src.length)) break\n dst[i + offset] = src[i]\n }\n return i\n}\n\nfunction isnan (val) {\n return val !== val // eslint-disable-line no-self-compare\n}\n","/**\n * This is the web browser implementation of `debug()`.\n *\n * Expose `debug()` as the module.\n */\n\nexports = module.exports = require('./debug');\nexports.log = log;\nexports.formatArgs = formatArgs;\nexports.save = save;\nexports.load = load;\nexports.useColors = useColors;\nexports.storage = 'undefined' != typeof chrome\n && 'undefined' != typeof chrome.storage\n ? chrome.storage.local\n : localstorage();\n\n/**\n * Colors.\n */\n\nexports.colors = [\n 'lightseagreen',\n 'forestgreen',\n 'goldenrod',\n 'dodgerblue',\n 'darkorchid',\n 'crimson'\n];\n\n/**\n * Currently only WebKit-based Web Inspectors, Firefox >= v31,\n * and the Firebug extension (any Firefox version) are known\n * to support \"%c\" CSS customizations.\n *\n * TODO: add a `localStorage` variable to explicitly enable/disable colors\n */\n\nfunction useColors() {\n // NB: In an Electron preload script, document will be defined but not fully\n // initialized. Since we know we're in Chrome, we'll just detect this case\n // explicitly\n if (typeof window !== 'undefined' && window && typeof window.process !== 'undefined' && window.process.type === 'renderer') {\n return true;\n }\n\n // is webkit? http://stackoverflow.com/a/16459606/376773\n // document is undefined in react-native: https://github.com/facebook/react-native/pull/1632\n return (typeof document !== 'undefined' && document && 'WebkitAppearance' in document.documentElement.style) ||\n // is firebug? http://stackoverflow.com/a/398120/376773\n (typeof window !== 'undefined' && window && window.console && (console.firebug || (console.exception && console.table))) ||\n // is firefox >= v31?\n // https://developer.mozilla.org/en-US/docs/Tools/Web_Console#Styling_messages\n (typeof navigator !== 'undefined' && navigator && navigator.userAgent && navigator.userAgent.toLowerCase().match(/firefox\\/(\\d+)/) && parseInt(RegExp.$1, 10) >= 31) ||\n // double check webkit in userAgent just in case we are in a worker\n (typeof navigator !== 'undefined' && navigator && navigator.userAgent && navigator.userAgent.toLowerCase().match(/applewebkit\\/(\\d+)/));\n}\n\n/**\n * Map %j to `JSON.stringify()`, since no Web Inspectors do that by default.\n */\n\nexports.formatters.j = function(v) {\n try {\n return JSON.stringify(v);\n } catch (err) {\n return '[UnexpectedJSONParseError]: ' + err.message;\n }\n};\n\n\n/**\n * Colorize log arguments if enabled.\n *\n * @api public\n */\n\nfunction formatArgs(args) {\n var useColors = this.useColors;\n\n args[0] = (useColors ? '%c' : '')\n + this.namespace\n + (useColors ? ' %c' : ' ')\n + args[0]\n + (useColors ? '%c ' : ' ')\n + '+' + exports.humanize(this.diff);\n\n if (!useColors) return;\n\n var c = 'color: ' + this.color;\n args.splice(1, 0, c, 'color: inherit')\n\n // the final \"%c\" is somewhat tricky, because there could be other\n // arguments passed either before or after the %c, so we need to\n // figure out the correct index to insert the CSS into\n var index = 0;\n var lastC = 0;\n args[0].replace(/%[a-zA-Z%]/g, function(match) {\n if ('%%' === match) return;\n index++;\n if ('%c' === match) {\n // we only are interested in the *last* %c\n // (the user may have provided their own)\n lastC = index;\n }\n });\n\n args.splice(lastC, 0, c);\n}\n\n/**\n * Invokes `console.log()` when available.\n * No-op when `console.log` is not a \"function\".\n *\n * @api public\n */\n\nfunction log() {\n // this hackery is required for IE8/9, where\n // the `console.log` function doesn't have 'apply'\n return 'object' === typeof console\n && console.log\n && Function.prototype.apply.call(console.log, console, arguments);\n}\n\n/**\n * Save `namespaces`.\n *\n * @param {String} namespaces\n * @api private\n */\n\nfunction save(namespaces) {\n try {\n if (null == namespaces) {\n exports.storage.removeItem('debug');\n } else {\n exports.storage.debug = namespaces;\n }\n } catch(e) {}\n}\n\n/**\n * Load `namespaces`.\n *\n * @return {String} returns the previously persisted debug modes\n * @api private\n */\n\nfunction load() {\n try {\n return exports.storage.debug;\n } catch(e) {}\n\n // If debug isn't set in LS, and we're in Electron, try to load $DEBUG\n if (typeof process !== 'undefined' && 'env' in process) {\n return process.env.DEBUG;\n }\n}\n\n/**\n * Enable namespaces listed in `localStorage.debug` initially.\n */\n\nexports.enable(load());\n\n/**\n * Localstorage attempts to return the localstorage.\n *\n * This is necessary because safari throws\n * when a user disables cookies/localstorage\n * and you attempt to access it.\n *\n * @return {LocalStorage}\n * @api private\n */\n\nfunction localstorage() {\n try {\n return window.localStorage;\n } catch (e) {}\n}\n","\n/**\n * This is the common logic for both the Node.js and web browser\n * implementations of `debug()`.\n *\n * Expose `debug()` as the module.\n */\n\nexports = module.exports = createDebug.debug = createDebug.default = createDebug;\nexports.coerce = coerce;\nexports.disable = disable;\nexports.enable = enable;\nexports.enabled = enabled;\nexports.humanize = require('ms');\n\n/**\n * The currently active debug mode names, and names to skip.\n */\n\nexports.names = [];\nexports.skips = [];\n\n/**\n * Map of special \"%n\" handling functions, for the debug \"format\" argument.\n *\n * Valid key names are a single, lower or upper-case letter, i.e. \"n\" and \"N\".\n */\n\nexports.formatters = {};\n\n/**\n * Previous log timestamp.\n */\n\nvar prevTime;\n\n/**\n * Select a color.\n * @param {String} namespace\n * @return {Number}\n * @api private\n */\n\nfunction selectColor(namespace) {\n var hash = 0, i;\n\n for (i in namespace) {\n hash = ((hash << 5) - hash) + namespace.charCodeAt(i);\n hash |= 0; // Convert to 32bit integer\n }\n\n return exports.colors[Math.abs(hash) % exports.colors.length];\n}\n\n/**\n * Create a debugger with the given `namespace`.\n *\n * @param {String} namespace\n * @return {Function}\n * @api public\n */\n\nfunction createDebug(namespace) {\n\n function debug() {\n // disabled?\n if (!debug.enabled) return;\n\n var self = debug;\n\n // set `diff` timestamp\n var curr = +new Date();\n var ms = curr - (prevTime || curr);\n self.diff = ms;\n self.prev = prevTime;\n self.curr = curr;\n prevTime = curr;\n\n // turn the `arguments` into a proper Array\n var args = new Array(arguments.length);\n for (var i = 0; i < args.length; i++) {\n args[i] = arguments[i];\n }\n\n args[0] = exports.coerce(args[0]);\n\n if ('string' !== typeof args[0]) {\n // anything else let's inspect with %O\n args.unshift('%O');\n }\n\n // apply any `formatters` transformations\n var index = 0;\n args[0] = args[0].replace(/%([a-zA-Z%])/g, function(match, format) {\n // if we encounter an escaped % then don't increase the array index\n if (match === '%%') return match;\n index++;\n var formatter = exports.formatters[format];\n if ('function' === typeof formatter) {\n var val = args[index];\n match = formatter.call(self, val);\n\n // now we need to remove `args[index]` since it's inlined in the `format`\n args.splice(index, 1);\n index--;\n }\n return match;\n });\n\n // apply env-specific formatting (colors, etc.)\n exports.formatArgs.call(self, args);\n\n var logFn = debug.log || exports.log || console.log.bind(console);\n logFn.apply(self, args);\n }\n\n debug.namespace = namespace;\n debug.enabled = exports.enabled(namespace);\n debug.useColors = exports.useColors();\n debug.color = selectColor(namespace);\n\n // env-specific initialization logic for debug instances\n if ('function' === typeof exports.init) {\n exports.init(debug);\n }\n\n return debug;\n}\n\n/**\n * Enables a debug mode by namespaces. This can include modes\n * separated by a colon and wildcards.\n *\n * @param {String} namespaces\n * @api public\n */\n\nfunction enable(namespaces) {\n exports.save(namespaces);\n\n var split = (namespaces || '').split(/[\\s,]+/);\n var len = split.length;\n\n for (var i = 0; i < len; i++) {\n if (!split[i]) continue; // ignore empty strings\n namespaces = split[i].replace(/\\*/g, '.*?');\n if (namespaces[0] === '-') {\n exports.skips.push(new RegExp('^' + namespaces.substr(1) + '$'));\n } else {\n exports.names.push(new RegExp('^' + namespaces + '$'));\n }\n }\n}\n\n/**\n * Disable debug output.\n *\n * @api public\n */\n\nfunction disable() {\n exports.enable('');\n}\n\n/**\n * Returns true if the given mode name is enabled, false otherwise.\n *\n * @param {String} name\n * @return {Boolean}\n * @api public\n */\n\nfunction enabled(name) {\n var i, len;\n for (i = 0, len = exports.skips.length; i < len; i++) {\n if (exports.skips[i].test(name)) {\n return false;\n }\n }\n for (i = 0, len = exports.names.length; i < len; i++) {\n if (exports.names[i].test(name)) {\n return true;\n }\n }\n return false;\n}\n\n/**\n * Coerce `val`.\n *\n * @param {Mixed} val\n * @return {Mixed}\n * @api private\n */\n\nfunction coerce(val) {\n if (val instanceof Error) return val.stack || val.message;\n return val;\n}\n","exports.read = function (buffer, offset, isLE, mLen, nBytes) {\n var e, m\n var eLen = nBytes * 8 - mLen - 1\n var eMax = (1 << eLen) - 1\n var eBias = eMax >> 1\n var nBits = -7\n var i = isLE ? (nBytes - 1) : 0\n var d = isLE ? -1 : 1\n var s = buffer[offset + i]\n\n i += d\n\n e = s & ((1 << (-nBits)) - 1)\n s >>= (-nBits)\n nBits += eLen\n for (; nBits > 0; e = e * 256 + buffer[offset + i], i += d, nBits -= 8) {}\n\n m = e & ((1 << (-nBits)) - 1)\n e >>= (-nBits)\n nBits += mLen\n for (; nBits > 0; m = m * 256 + buffer[offset + i], i += d, nBits -= 8) {}\n\n if (e === 0) {\n e = 1 - eBias\n } else if (e === eMax) {\n return m ? NaN : ((s ? -1 : 1) * Infinity)\n } else {\n m = m + Math.pow(2, mLen)\n e = e - eBias\n }\n return (s ? -1 : 1) * m * Math.pow(2, e - mLen)\n}\n\nexports.write = function (buffer, value, offset, isLE, mLen, nBytes) {\n var e, m, c\n var eLen = nBytes * 8 - mLen - 1\n var eMax = (1 << eLen) - 1\n var eBias = eMax >> 1\n var rt = (mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0)\n var i = isLE ? 0 : (nBytes - 1)\n var d = isLE ? 1 : -1\n var s = value < 0 || (value === 0 && 1 / value < 0) ? 1 : 0\n\n value = Math.abs(value)\n\n if (isNaN(value) || value === Infinity) {\n m = isNaN(value) ? 1 : 0\n e = eMax\n } else {\n e = Math.floor(Math.log(value) / Math.LN2)\n if (value * (c = Math.pow(2, -e)) < 1) {\n e--\n c *= 2\n }\n if (e + eBias >= 1) {\n value += rt / c\n } else {\n value += rt * Math.pow(2, 1 - eBias)\n }\n if (value * c >= 2) {\n e++\n c /= 2\n }\n\n if (e + eBias >= eMax) {\n m = 0\n e = eMax\n } else if (e + eBias >= 1) {\n m = (value * c - 1) * Math.pow(2, mLen)\n e = e + eBias\n } else {\n m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen)\n e = 0\n }\n }\n\n for (; mLen >= 8; buffer[offset + i] = m & 0xff, i += d, m /= 256, mLen -= 8) {}\n\n e = (e << mLen) | m\n eLen += mLen\n for (; eLen > 0; buffer[offset + i] = e & 0xff, i += d, e /= 256, eLen -= 8) {}\n\n buffer[offset + i - d] |= s * 128\n}\n","var toString = {}.toString;\n\nmodule.exports = Array.isArray || function (arr) {\n return toString.call(arr) == '[object Array]';\n};\n","/*\n * $Id: base64.js,v 2.15 2014/04/05 12:58:57 dankogai Exp dankogai $\n *\n * Licensed under the MIT license.\n * http://opensource.org/licenses/mit-license\n *\n * References:\n * http://en.wikipedia.org/wiki/Base64\n */\n\n(function(global) {\n 'use strict';\n // existing version for noConflict()\n var _Base64 = global.Base64;\n var version = \"2.1.9\";\n // if node.js, we use Buffer\n var buffer;\n if (typeof module !== 'undefined' && module.exports) {\n try {\n buffer = require('buffer').Buffer;\n } catch (err) {}\n }\n // constants\n var b64chars\n = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';\n var b64tab = function(bin) {\n var t = {};\n for (var i = 0, l = bin.length; i < l; i++) t[bin.charAt(i)] = i;\n return t;\n }(b64chars);\n var fromCharCode = String.fromCharCode;\n // encoder stuff\n var cb_utob = function(c) {\n if (c.length < 2) {\n var cc = c.charCodeAt(0);\n return cc < 0x80 ? c\n : cc < 0x800 ? (fromCharCode(0xc0 | (cc >>> 6))\n + fromCharCode(0x80 | (cc & 0x3f)))\n : (fromCharCode(0xe0 | ((cc >>> 12) & 0x0f))\n + fromCharCode(0x80 | ((cc >>> 6) & 0x3f))\n + fromCharCode(0x80 | ( cc & 0x3f)));\n } else {\n var cc = 0x10000\n + (c.charCodeAt(0) - 0xD800) * 0x400\n + (c.charCodeAt(1) - 0xDC00);\n return (fromCharCode(0xf0 | ((cc >>> 18) & 0x07))\n + fromCharCode(0x80 | ((cc >>> 12) & 0x3f))\n + fromCharCode(0x80 | ((cc >>> 6) & 0x3f))\n + fromCharCode(0x80 | ( cc & 0x3f)));\n }\n };\n var re_utob = /[\\uD800-\\uDBFF][\\uDC00-\\uDFFFF]|[^\\x00-\\x7F]/g;\n var utob = function(u) {\n return u.replace(re_utob, cb_utob);\n };\n var cb_encode = function(ccc) {\n var padlen = [0, 2, 1][ccc.length % 3],\n ord = ccc.charCodeAt(0) << 16\n | ((ccc.length > 1 ? ccc.charCodeAt(1) : 0) << 8)\n | ((ccc.length > 2 ? ccc.charCodeAt(2) : 0)),\n chars = [\n b64chars.charAt( ord >>> 18),\n b64chars.charAt((ord >>> 12) & 63),\n padlen >= 2 ? '=' : b64chars.charAt((ord >>> 6) & 63),\n padlen >= 1 ? '=' : b64chars.charAt(ord & 63)\n ];\n return chars.join('');\n };\n var btoa = global.btoa ? function(b) {\n return global.btoa(b);\n } : function(b) {\n return b.replace(/[\\s\\S]{1,3}/g, cb_encode);\n };\n var _encode = buffer ? function (u) {\n return (u.constructor === buffer.constructor ? u : new buffer(u))\n .toString('base64')\n }\n : function (u) { return btoa(utob(u)) }\n ;\n var encode = function(u, urisafe) {\n return !urisafe\n ? _encode(String(u))\n : _encode(String(u)).replace(/[+\\/]/g, function(m0) {\n return m0 == '+' ? '-' : '_';\n }).replace(/=/g, '');\n };\n var encodeURI = function(u) { return encode(u, true) };\n // decoder stuff\n var re_btou = new RegExp([\n '[\\xC0-\\xDF][\\x80-\\xBF]',\n '[\\xE0-\\xEF][\\x80-\\xBF]{2}',\n '[\\xF0-\\xF7][\\x80-\\xBF]{3}'\n ].join('|'), 'g');\n var cb_btou = function(cccc) {\n switch(cccc.length) {\n case 4:\n var cp = ((0x07 & cccc.charCodeAt(0)) << 18)\n | ((0x3f & cccc.charCodeAt(1)) << 12)\n | ((0x3f & cccc.charCodeAt(2)) << 6)\n | (0x3f & cccc.charCodeAt(3)),\n offset = cp - 0x10000;\n return (fromCharCode((offset >>> 10) + 0xD800)\n + fromCharCode((offset & 0x3FF) + 0xDC00));\n case 3:\n return fromCharCode(\n ((0x0f & cccc.charCodeAt(0)) << 12)\n | ((0x3f & cccc.charCodeAt(1)) << 6)\n | (0x3f & cccc.charCodeAt(2))\n );\n default:\n return fromCharCode(\n ((0x1f & cccc.charCodeAt(0)) << 6)\n | (0x3f & cccc.charCodeAt(1))\n );\n }\n };\n var btou = function(b) {\n return b.replace(re_btou, cb_btou);\n };\n var cb_decode = function(cccc) {\n var len = cccc.length,\n padlen = len % 4,\n n = (len > 0 ? b64tab[cccc.charAt(0)] << 18 : 0)\n | (len > 1 ? b64tab[cccc.charAt(1)] << 12 : 0)\n | (len > 2 ? b64tab[cccc.charAt(2)] << 6 : 0)\n | (len > 3 ? b64tab[cccc.charAt(3)] : 0),\n chars = [\n fromCharCode( n >>> 16),\n fromCharCode((n >>> 8) & 0xff),\n fromCharCode( n & 0xff)\n ];\n chars.length -= [0, 0, 2, 1][padlen];\n return chars.join('');\n };\n var atob = global.atob ? function(a) {\n return global.atob(a);\n } : function(a){\n return a.replace(/[\\s\\S]{1,4}/g, cb_decode);\n };\n var _decode = buffer ? function(a) {\n return (a.constructor === buffer.constructor\n ? a : new buffer(a, 'base64')).toString();\n }\n : function(a) { return btou(atob(a)) };\n var decode = function(a){\n return _decode(\n String(a).replace(/[-_]/g, function(m0) { return m0 == '-' ? '+' : '/' })\n .replace(/[^A-Za-z0-9\\+\\/]/g, '')\n );\n };\n var noConflict = function() {\n var Base64 = global.Base64;\n global.Base64 = _Base64;\n return Base64;\n };\n // export Base64\n global.Base64 = {\n VERSION: version,\n atob: atob,\n btoa: btoa,\n fromBase64: decode,\n toBase64: encode,\n utob: utob,\n encode: encode,\n encodeURI: encodeURI,\n btou: btou,\n decode: decode,\n noConflict: noConflict\n };\n // if ES5 is available, make Base64.extendString() available\n if (typeof Object.defineProperty === 'function') {\n var noEnum = function(v){\n return {value:v,enumerable:false,writable:true,configurable:true};\n };\n global.Base64.extendString = function () {\n Object.defineProperty(\n String.prototype, 'fromBase64', noEnum(function () {\n return decode(this)\n }));\n Object.defineProperty(\n String.prototype, 'toBase64', noEnum(function (urisafe) {\n return encode(this, urisafe)\n }));\n Object.defineProperty(\n String.prototype, 'toBase64URI', noEnum(function () {\n return encode(this, true)\n }));\n };\n }\n // that's it!\n if (global['Meteor']) {\n Base64 = global.Base64; // for normal export in Meteor.js\n }\n})(this);\n","/**\n * Helpers.\n */\n\nvar s = 1000\nvar m = s * 60\nvar h = m * 60\nvar d = h * 24\nvar y = d * 365.25\n\n/**\n * Parse or format the given `val`.\n *\n * Options:\n *\n * - `long` verbose formatting [false]\n *\n * @param {String|Number} val\n * @param {Object} options\n * @throws {Error} throw an error if val is not a non-empty string or a number\n * @return {String|Number}\n * @api public\n */\n\nmodule.exports = function (val, options) {\n options = options || {}\n var type = typeof val\n if (type === 'string' && val.length > 0) {\n return parse(val)\n } else if (type === 'number' && isNaN(val) === false) {\n return options.long ?\n\t\t\tfmtLong(val) :\n\t\t\tfmtShort(val)\n }\n throw new Error('val is not a non-empty string or a valid number. val=' + JSON.stringify(val))\n}\n\n/**\n * Parse the given `str` and return milliseconds.\n *\n * @param {String} str\n * @return {Number}\n * @api private\n */\n\nfunction parse(str) {\n str = String(str)\n if (str.length > 10000) {\n return\n }\n var match = /^((?:\\d+)?\\.?\\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|years?|yrs?|y)?$/i.exec(str)\n if (!match) {\n return\n }\n var n = parseFloat(match[1])\n var type = (match[2] || 'ms').toLowerCase()\n switch (type) {\n case 'years':\n case 'year':\n case 'yrs':\n case 'yr':\n case 'y':\n return n * y\n case 'days':\n case 'day':\n case 'd':\n return n * d\n case 'hours':\n case 'hour':\n case 'hrs':\n case 'hr':\n case 'h':\n return n * h\n case 'minutes':\n case 'minute':\n case 'mins':\n case 'min':\n case 'm':\n return n * m\n case 'seconds':\n case 'second':\n case 'secs':\n case 'sec':\n case 's':\n return n * s\n case 'milliseconds':\n case 'millisecond':\n case 'msecs':\n case 'msec':\n case 'ms':\n return n\n default:\n return undefined\n }\n}\n\n/**\n * Short format for `ms`.\n *\n * @param {Number} ms\n * @return {String}\n * @api private\n */\n\nfunction fmtShort(ms) {\n if (ms >= d) {\n return Math.round(ms / d) + 'd'\n }\n if (ms >= h) {\n return Math.round(ms / h) + 'h'\n }\n if (ms >= m) {\n return Math.round(ms / m) + 'm'\n }\n if (ms >= s) {\n return Math.round(ms / s) + 's'\n }\n return ms + 'ms'\n}\n\n/**\n * Long format for `ms`.\n *\n * @param {Number} ms\n * @return {String}\n * @api private\n */\n\nfunction fmtLong(ms) {\n return plural(ms, d, 'day') ||\n plural(ms, h, 'hour') ||\n plural(ms, m, 'minute') ||\n plural(ms, s, 'second') ||\n ms + ' ms'\n}\n\n/**\n * Pluralization helper.\n */\n\nfunction plural(ms, n, name) {\n if (ms < n) {\n return\n }\n if (ms < n * 1.5) {\n return Math.floor(ms / n) + ' ' + name\n }\n return Math.ceil(ms / n) + ' ' + name + 's'\n}\n","// shim for using process in browser\nvar process = module.exports = {};\n\n// cached from whatever global is present so that test runners that stub it\n// don't break things. But we need to wrap it in a try catch in case it is\n// wrapped in strict mode code which doesn't define any globals. It's inside a\n// function because try/catches deoptimize in certain engines.\n\nvar cachedSetTimeout;\nvar cachedClearTimeout;\n\nfunction defaultSetTimout() {\n throw new Error('setTimeout has not been defined');\n}\nfunction defaultClearTimeout () {\n throw new Error('clearTimeout has not been defined');\n}\n(function () {\n try {\n if (typeof setTimeout === 'function') {\n cachedSetTimeout = setTimeout;\n } else {\n cachedSetTimeout = defaultSetTimout;\n }\n } catch (e) {\n cachedSetTimeout = defaultSetTimout;\n }\n try {\n if (typeof clearTimeout === 'function') {\n cachedClearTimeout = clearTimeout;\n } else {\n cachedClearTimeout = defaultClearTimeout;\n }\n } catch (e) {\n cachedClearTimeout = defaultClearTimeout;\n }\n} ())\nfunction runTimeout(fun) {\n if (cachedSetTimeout === setTimeout) {\n //normal enviroments in sane situations\n return setTimeout(fun, 0);\n }\n // if setTimeout wasn't available but was latter defined\n if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {\n cachedSetTimeout = setTimeout;\n return setTimeout(fun, 0);\n }\n try {\n // when when somebody has screwed with setTimeout but no I.E. maddness\n return cachedSetTimeout(fun, 0);\n } catch(e){\n try {\n // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally\n return cachedSetTimeout.call(null, fun, 0);\n } catch(e){\n // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error\n return cachedSetTimeout.call(this, fun, 0);\n }\n }\n\n\n}\nfunction runClearTimeout(marker) {\n if (cachedClearTimeout === clearTimeout) {\n //normal enviroments in sane situations\n return clearTimeout(marker);\n }\n // if clearTimeout wasn't available but was latter defined\n if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {\n cachedClearTimeout = clearTimeout;\n return clearTimeout(marker);\n }\n try {\n // when when somebody has screwed with setTimeout but no I.E. maddness\n return cachedClearTimeout(marker);\n } catch (e){\n try {\n // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally\n return cachedClearTimeout.call(null, marker);\n } catch (e){\n // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error.\n // Some versions of I.E. have different rules for clearTimeout vs setTimeout\n return cachedClearTimeout.call(this, marker);\n }\n }\n\n\n\n}\nvar queue = [];\nvar draining = false;\nvar currentQueue;\nvar queueIndex = -1;\n\nfunction cleanUpNextTick() {\n if (!draining || !currentQueue) {\n return;\n }\n draining = false;\n if (currentQueue.length) {\n queue = currentQueue.concat(queue);\n } else {\n queueIndex = -1;\n }\n if (queue.length) {\n drainQueue();\n }\n}\n\nfunction drainQueue() {\n if (draining) {\n return;\n }\n var timeout = runTimeout(cleanUpNextTick);\n draining = true;\n\n var len = queue.length;\n while(len) {\n currentQueue = queue;\n queue = [];\n while (++queueIndex < len) {\n if (currentQueue) {\n currentQueue[queueIndex].run();\n }\n }\n queueIndex = -1;\n len = queue.length;\n }\n currentQueue = null;\n draining = false;\n runClearTimeout(timeout);\n}\n\nprocess.nextTick = function (fun) {\n var args = new Array(arguments.length - 1);\n if (arguments.length > 1) {\n for (var i = 1; i < arguments.length; i++) {\n args[i - 1] = arguments[i];\n }\n }\n queue.push(new Item(fun, args));\n if (queue.length === 1 && !draining) {\n runTimeout(drainQueue);\n }\n};\n\n// v8 likes predictible objects\nfunction Item(fun, array) {\n this.fun = fun;\n this.array = array;\n}\nItem.prototype.run = function () {\n this.fun.apply(null, this.array);\n};\nprocess.title = 'browser';\nprocess.browser = true;\nprocess.env = {};\nprocess.argv = [];\nprocess.version = ''; // empty string to avoid regexp issues\nprocess.versions = {};\n\nfunction noop() {}\n\nprocess.on = noop;\nprocess.addListener = noop;\nprocess.once = noop;\nprocess.off = noop;\nprocess.removeListener = noop;\nprocess.removeAllListeners = noop;\nprocess.emit = noop;\n\nprocess.binding = function (name) {\n throw new Error('process.binding is not supported');\n};\n\nprocess.cwd = function () { return '/' };\nprocess.chdir = function (dir) {\n throw new Error('process.chdir is not supported');\n};\nprocess.umask = function() { return 0; };\n","/*! https://mths.be/utf8js v2.1.2 by @mathias */\n;(function(root) {\n\n\t// Detect free variables `exports`\n\tvar freeExports = typeof exports == 'object' && exports;\n\n\t// Detect free variable `module`\n\tvar freeModule = typeof module == 'object' && module &&\n\t\tmodule.exports == freeExports && module;\n\n\t// Detect free variable `global`, from Node.js or Browserified code,\n\t// and use it as `root`\n\tvar freeGlobal = typeof global == 'object' && global;\n\tif (freeGlobal.global === freeGlobal || freeGlobal.window === freeGlobal) {\n\t\troot = freeGlobal;\n\t}\n\n\t/*--------------------------------------------------------------------------*/\n\n\tvar stringFromCharCode = String.fromCharCode;\n\n\t// Taken from https://mths.be/punycode\n\tfunction ucs2decode(string) {\n\t\tvar output = [];\n\t\tvar counter = 0;\n\t\tvar length = string.length;\n\t\tvar value;\n\t\tvar extra;\n\t\twhile (counter < length) {\n\t\t\tvalue = string.charCodeAt(counter++);\n\t\t\tif (value >= 0xD800 && value <= 0xDBFF && counter < length) {\n\t\t\t\t// high surrogate, and there is a next character\n\t\t\t\textra = string.charCodeAt(counter++);\n\t\t\t\tif ((extra & 0xFC00) == 0xDC00) { // low surrogate\n\t\t\t\t\toutput.push(((value & 0x3FF) << 10) + (extra & 0x3FF) + 0x10000);\n\t\t\t\t} else {\n\t\t\t\t\t// unmatched surrogate; only append this code unit, in case the next\n\t\t\t\t\t// code unit is the high surrogate of a surrogate pair\n\t\t\t\t\toutput.push(value);\n\t\t\t\t\tcounter--;\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\toutput.push(value);\n\t\t\t}\n\t\t}\n\t\treturn output;\n\t}\n\n\t// Taken from https://mths.be/punycode\n\tfunction ucs2encode(array) {\n\t\tvar length = array.length;\n\t\tvar index = -1;\n\t\tvar value;\n\t\tvar output = '';\n\t\twhile (++index < length) {\n\t\t\tvalue = array[index];\n\t\t\tif (value > 0xFFFF) {\n\t\t\t\tvalue -= 0x10000;\n\t\t\t\toutput += stringFromCharCode(value >>> 10 & 0x3FF | 0xD800);\n\t\t\t\tvalue = 0xDC00 | value & 0x3FF;\n\t\t\t}\n\t\t\toutput += stringFromCharCode(value);\n\t\t}\n\t\treturn output;\n\t}\n\n\tfunction checkScalarValue(codePoint) {\n\t\tif (codePoint >= 0xD800 && codePoint <= 0xDFFF) {\n\t\t\tthrow Error(\n\t\t\t\t'Lone surrogate U+' + codePoint.toString(16).toUpperCase() +\n\t\t\t\t' is not a scalar value'\n\t\t\t);\n\t\t}\n\t}\n\t/*--------------------------------------------------------------------------*/\n\n\tfunction createByte(codePoint, shift) {\n\t\treturn stringFromCharCode(((codePoint >> shift) & 0x3F) | 0x80);\n\t}\n\n\tfunction encodeCodePoint(codePoint) {\n\t\tif ((codePoint & 0xFFFFFF80) == 0) { // 1-byte sequence\n\t\t\treturn stringFromCharCode(codePoint);\n\t\t}\n\t\tvar symbol = '';\n\t\tif ((codePoint & 0xFFFFF800) == 0) { // 2-byte sequence\n\t\t\tsymbol = stringFromCharCode(((codePoint >> 6) & 0x1F) | 0xC0);\n\t\t}\n\t\telse if ((codePoint & 0xFFFF0000) == 0) { // 3-byte sequence\n\t\t\tcheckScalarValue(codePoint);\n\t\t\tsymbol = stringFromCharCode(((codePoint >> 12) & 0x0F) | 0xE0);\n\t\t\tsymbol += createByte(codePoint, 6);\n\t\t}\n\t\telse if ((codePoint & 0xFFE00000) == 0) { // 4-byte sequence\n\t\t\tsymbol = stringFromCharCode(((codePoint >> 18) & 0x07) | 0xF0);\n\t\t\tsymbol += createByte(codePoint, 12);\n\t\t\tsymbol += createByte(codePoint, 6);\n\t\t}\n\t\tsymbol += stringFromCharCode((codePoint & 0x3F) | 0x80);\n\t\treturn symbol;\n\t}\n\n\tfunction utf8encode(string) {\n\t\tvar codePoints = ucs2decode(string);\n\t\tvar length = codePoints.length;\n\t\tvar index = -1;\n\t\tvar codePoint;\n\t\tvar byteString = '';\n\t\twhile (++index < length) {\n\t\t\tcodePoint = codePoints[index];\n\t\t\tbyteString += encodeCodePoint(codePoint);\n\t\t}\n\t\treturn byteString;\n\t}\n\n\t/*--------------------------------------------------------------------------*/\n\n\tfunction readContinuationByte() {\n\t\tif (byteIndex >= byteCount) {\n\t\t\tthrow Error('Invalid byte index');\n\t\t}\n\n\t\tvar continuationByte = byteArray[byteIndex] & 0xFF;\n\t\tbyteIndex++;\n\n\t\tif ((continuationByte & 0xC0) == 0x80) {\n\t\t\treturn continuationByte & 0x3F;\n\t\t}\n\n\t\t// If we end up here, it’s not a continuation byte\n\t\tthrow Error('Invalid continuation byte');\n\t}\n\n\tfunction decodeSymbol() {\n\t\tvar byte1;\n\t\tvar byte2;\n\t\tvar byte3;\n\t\tvar byte4;\n\t\tvar codePoint;\n\n\t\tif (byteIndex > byteCount) {\n\t\t\tthrow Error('Invalid byte index');\n\t\t}\n\n\t\tif (byteIndex == byteCount) {\n\t\t\treturn false;\n\t\t}\n\n\t\t// Read first byte\n\t\tbyte1 = byteArray[byteIndex] & 0xFF;\n\t\tbyteIndex++;\n\n\t\t// 1-byte sequence (no continuation bytes)\n\t\tif ((byte1 & 0x80) == 0) {\n\t\t\treturn byte1;\n\t\t}\n\n\t\t// 2-byte sequence\n\t\tif ((byte1 & 0xE0) == 0xC0) {\n\t\t\tbyte2 = readContinuationByte();\n\t\t\tcodePoint = ((byte1 & 0x1F) << 6) | byte2;\n\t\t\tif (codePoint >= 0x80) {\n\t\t\t\treturn codePoint;\n\t\t\t} else {\n\t\t\t\tthrow Error('Invalid continuation byte');\n\t\t\t}\n\t\t}\n\n\t\t// 3-byte sequence (may include unpaired surrogates)\n\t\tif ((byte1 & 0xF0) == 0xE0) {\n\t\t\tbyte2 = readContinuationByte();\n\t\t\tbyte3 = readContinuationByte();\n\t\t\tcodePoint = ((byte1 & 0x0F) << 12) | (byte2 << 6) | byte3;\n\t\t\tif (codePoint >= 0x0800) {\n\t\t\t\tcheckScalarValue(codePoint);\n\t\t\t\treturn codePoint;\n\t\t\t} else {\n\t\t\t\tthrow Error('Invalid continuation byte');\n\t\t\t}\n\t\t}\n\n\t\t// 4-byte sequence\n\t\tif ((byte1 & 0xF8) == 0xF0) {\n\t\t\tbyte2 = readContinuationByte();\n\t\t\tbyte3 = readContinuationByte();\n\t\t\tbyte4 = readContinuationByte();\n\t\t\tcodePoint = ((byte1 & 0x07) << 0x12) | (byte2 << 0x0C) |\n\t\t\t\t(byte3 << 0x06) | byte4;\n\t\t\tif (codePoint >= 0x010000 && codePoint <= 0x10FFFF) {\n\t\t\t\treturn codePoint;\n\t\t\t}\n\t\t}\n\n\t\tthrow Error('Invalid UTF-8 detected');\n\t}\n\n\tvar byteArray;\n\tvar byteCount;\n\tvar byteIndex;\n\tfunction utf8decode(byteString) {\n\t\tbyteArray = ucs2decode(byteString);\n\t\tbyteCount = byteArray.length;\n\t\tbyteIndex = 0;\n\t\tvar codePoints = [];\n\t\tvar tmp;\n\t\twhile ((tmp = decodeSymbol()) !== false) {\n\t\t\tcodePoints.push(tmp);\n\t\t}\n\t\treturn ucs2encode(codePoints);\n\t}\n\n\t/*--------------------------------------------------------------------------*/\n\n\tvar utf8 = {\n\t\t'version': '2.1.2',\n\t\t'encode': utf8encode,\n\t\t'decode': utf8decode\n\t};\n\n\t// Some AMD build optimizers, like r.js, check for specific condition patterns\n\t// like the following:\n\tif (\n\t\ttypeof define == 'function' &&\n\t\ttypeof define.amd == 'object' &&\n\t\tdefine.amd\n\t) {\n\t\tdefine(function() {\n\t\t\treturn utf8;\n\t\t});\n\t}\telse if (freeExports && !freeExports.nodeType) {\n\t\tif (freeModule) { // in Node.js or RingoJS v0.8.0+\n\t\t\tfreeModule.exports = utf8;\n\t\t} else { // in Narwhal or RingoJS v0.7.0-\n\t\t\tvar object = {};\n\t\t\tvar hasOwnProperty = object.hasOwnProperty;\n\t\t\tfor (var key in utf8) {\n\t\t\t\thasOwnProperty.call(utf8, key) && (freeExports[key] = utf8[key]);\n\t\t\t}\n\t\t}\n\t} else { // in Rhino or a web browser\n\t\troot.utf8 = utf8;\n\t}\n\n}(this));\n"]} \ No newline at end of file diff --git a/dist/GitHub.js b/dist/GitHub.js index df427752..30ffb2a3 100644 --- a/dist/GitHub.js +++ b/dist/GitHub.js @@ -3401,19 +3401,6 @@ var User = function (_Requestable) { return this._request('GET', this.__getScopedUrl('gists/starred'), null, cb); } - /** - * List the user's gists - * @see https://developer.github.com/v3/gists/#list-a-users-gists - * @param {Requestable.callback} [cb] - will receive the list of gists - * @return {Promise} - the promise for the http request - */ - - }, { - key: 'listStarredGists', - value: function listStarredGists(cb) { - return this._request('GET', this.__getScopedUrl('gists'), null, cb); - } - /** * List the user's notifications * @see https://developer.github.com/v3/activity/notifications/#list-your-notifications diff --git a/dist/GitHub.js.map b/dist/GitHub.js.map index 531325c9..7c58c0b6 100644 --- a/dist/GitHub.js.map +++ b/dist/GitHub.js.map @@ -1 +1 @@ -{"version":3,"sources":["node_modules/browser-pack/_prelude.js","lib/Gist.js","lib/GitHub.js","lib/Issue.js","lib/Markdown.js","lib/Organization.js","lib/Project.js","lib/RateLimit.js","lib/Repository.js","lib/Requestable.js","lib/Search.js","lib/Team.js","lib/User.js"],"names":[],"mappings":"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","file":"GitHub.js","sourcesContent":["(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require==\"function\"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error(\"Cannot find module '\"+o+\"'\");throw f.code=\"MODULE_NOT_FOUND\",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require==\"function\"&&require;for(var o=0;o {\n this.__id = response.data.id;\n return response;\n });\n }\n\n /**\n * Delete a gist.\n * @see https://developer.github.com/v3/gists/#delete-a-gist\n * @param {Requestable.callback} [cb] - will receive true if the request succeeds\n * @return {Promise} - the Promise for the http request\n */\n delete(cb) {\n return this._request('DELETE', `/gists/${this.__id}`, null, cb);\n }\n\n /**\n * Fork a gist.\n * @see https://developer.github.com/v3/gists/#fork-a-gist\n * @param {Requestable.callback} [cb] - the function that will receive the gist\n * @return {Promise} - the Promise for the http request\n */\n fork(cb) {\n return this._request('POST', `/gists/${this.__id}/forks`, null, cb);\n }\n\n /**\n * Update a gist.\n * @see https://developer.github.com/v3/gists/#edit-a-gist\n * @param {Object} gist - the new data for the gist\n * @param {Requestable.callback} [cb] - the function that receives the API result\n * @return {Promise} - the Promise for the http request\n */\n update(gist, cb) {\n return this._request('PATCH', `/gists/${this.__id}`, gist, cb);\n }\n\n /**\n * Star a gist.\n * @see https://developer.github.com/v3/gists/#star-a-gist\n * @param {Requestable.callback} [cb] - will receive true if the request is successful\n * @return {Promise} - the Promise for the http request\n */\n star(cb) {\n return this._request('PUT', `/gists/${this.__id}/star`, null, cb);\n }\n\n /**\n * Unstar a gist.\n * @see https://developer.github.com/v3/gists/#unstar-a-gist\n * @param {Requestable.callback} [cb] - will receive true if the request is successful\n * @return {Promise} - the Promise for the http request\n */\n unstar(cb) {\n return this._request('DELETE', `/gists/${this.__id}/star`, null, cb);\n }\n\n /**\n * Check if a gist is starred by the user.\n * @see https://developer.github.com/v3/gists/#check-if-a-gist-is-starred\n * @param {Requestable.callback} [cb] - will receive true if the gist is starred and false if the gist is not starred\n * @return {Promise} - the Promise for the http request\n */\n isStarred(cb) {\n return this._request204or404(`/gists/${this.__id}/star`, null, cb);\n }\n\n /**\n * List the gist's commits\n * @see https://developer.github.com/v3/gists/#list-gist-commits\n * @param {Requestable.callback} [cb] - will receive the array of commits\n * @return {Promise} - the Promise for the http request\n */\n listCommits(cb) {\n return this._requestAllPages(`/gists/${this.__id}/commits`, null, cb);\n }\n\n /**\n * Fetch one of the gist's revision.\n * @see https://developer.github.com/v3/gists/#get-a-specific-revision-of-a-gist\n * @param {string} revision - the id of the revision\n * @param {Requestable.callback} [cb] - will receive the revision\n * @return {Promise} - the Promise for the http request\n */\n getRevision(revision, cb) {\n return this._request('GET', `/gists/${this.__id}/${revision}`, null, cb);\n }\n\n /**\n * List the gist's comments\n * @see https://developer.github.com/v3/gists/comments/#list-comments-on-a-gist\n * @param {Requestable.callback} [cb] - will receive the array of comments\n * @return {Promise} - the promise for the http request\n */\n listComments(cb) {\n return this._requestAllPages(`/gists/${this.__id}/comments`, null, cb);\n }\n\n /**\n * Fetch one of the gist's comments\n * @see https://developer.github.com/v3/gists/comments/#get-a-single-comment\n * @param {number} comment - the id of the comment\n * @param {Requestable.callback} [cb] - will receive the comment\n * @return {Promise} - the Promise for the http request\n */\n getComment(comment, cb) {\n return this._request('GET', `/gists/${this.__id}/comments/${comment}`, null, cb);\n }\n\n /**\n * Comment on a gist\n * @see https://developer.github.com/v3/gists/comments/#create-a-comment\n * @param {string} comment - the comment to add\n * @param {Requestable.callback} [cb] - the function that receives the API result\n * @return {Promise} - the Promise for the http request\n */\n createComment(comment, cb) {\n return this._request('POST', `/gists/${this.__id}/comments`, {body: comment}, cb);\n }\n\n /**\n * Edit a comment on the gist\n * @see https://developer.github.com/v3/gists/comments/#edit-a-comment\n * @param {number} comment - the id of the comment\n * @param {string} body - the new comment\n * @param {Requestable.callback} [cb] - will receive the modified comment\n * @return {Promise} - the promise for the http request\n */\n editComment(comment, body, cb) {\n return this._request('PATCH', `/gists/${this.__id}/comments/${comment}`, {body: body}, cb);\n }\n\n /**\n * Delete a comment on the gist.\n * @see https://developer.github.com/v3/gists/comments/#delete-a-comment\n * @param {number} comment - the id of the comment\n * @param {Requestable.callback} [cb] - will receive true if the request succeeds\n * @return {Promise} - the Promise for the http request\n */\n deleteComment(comment, cb) {\n return this._request('DELETE', `/gists/${this.__id}/comments/${comment}`, null, cb);\n }\n}\n\nmodule.exports = Gist;\n","/**\n * @file\n * @copyright 2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n * Github.js is freely distributable.\n */\n/* eslint valid-jsdoc: [\"error\", {\"requireReturnDescription\": false}] */\n\nimport Gist from './Gist';\nimport User from './User';\nimport Issue from './Issue';\nimport Search from './Search';\nimport RateLimit from './RateLimit';\nimport Repository from './Repository';\nimport Organization from './Organization';\nimport Team from './Team';\nimport Markdown from './Markdown';\nimport Project from './Project';\n\n/**\n * GitHub encapsulates the functionality to create various API wrapper objects.\n */\nclass GitHub {\n /**\n * Create a new GitHub.\n * @param {Requestable.auth} [auth] - the credentials to authenticate to Github. If auth is\n * not provided requests will be made unauthenticated\n * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n */\n constructor(auth, apiBase = 'https://api.github.com') {\n this.__apiBase = apiBase;\n this.__auth = auth || {};\n }\n\n /**\n * Create a new Gist wrapper\n * @param {number} [id] - the id for the gist, leave undefined when creating a new gist\n * @return {Gist}\n */\n getGist(id) {\n return new Gist(id, this.__auth, this.__apiBase);\n }\n\n /**\n * Create a new User wrapper\n * @param {string} [user] - the name of the user to get information about\n * leave undefined for the authenticated user\n * @return {User}\n */\n getUser(user) {\n return new User(user, this.__auth, this.__apiBase);\n }\n\n /**\n * Create a new Organization wrapper\n * @param {string} organization - the name of the organization\n * @return {Organization}\n */\n getOrganization(organization) {\n return new Organization(organization, this.__auth, this.__apiBase);\n }\n\n /**\n * create a new Team wrapper\n * @param {string} teamId - the name of the team\n * @return {team}\n */\n getTeam(teamId) {\n return new Team(teamId, this.__auth, this.__apiBase);\n }\n\n /**\n * Create a new Repository wrapper\n * @param {string} user - the user who owns the respository\n * @param {string} repo - the name of the repository\n * @return {Repository}\n */\n getRepo(user, repo) {\n return new Repository(this._getFullName(user, repo), this.__auth, this.__apiBase);\n }\n\n /**\n * Create a new Issue wrapper\n * @param {string} user - the user who owns the respository\n * @param {string} repo - the name of the repository\n * @return {Issue}\n */\n getIssues(user, repo) {\n return new Issue(this._getFullName(user, repo), this.__auth, this.__apiBase);\n }\n\n /**\n * Create a new Search wrapper\n * @param {string} query - the query to search for\n * @return {Search}\n */\n search(query) {\n return new Search(query, this.__auth, this.__apiBase);\n }\n\n /**\n * Create a new RateLimit wrapper\n * @return {RateLimit}\n */\n getRateLimit() {\n return new RateLimit(this.__auth, this.__apiBase);\n }\n\n /**\n * Create a new Markdown wrapper\n * @return {Markdown}\n */\n getMarkdown() {\n return new Markdown(this.__auth, this.__apiBase);\n }\n\n /**\n * Create a new Project wrapper\n * @param {string} id - the id of the project\n * @return {Markdown}\n */\n getProject(id) {\n return new Project(id, this.__auth, this.__apiBase);\n }\n\n /**\n * Computes the full repository name\n * @param {string} user - the username (or the full name)\n * @param {string} repo - the repository name, must not be passed if `user` is the full name\n * @return {string} the repository's full name\n */\n _getFullName(user, repo) {\n let fullname = user;\n\n if (repo) {\n fullname = `${user}/${repo}`;\n }\n\n return fullname;\n }\n}\n\nmodule.exports = GitHub;\n","/**\n * @file\n * @copyright 2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n * Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\n\n/**\n * Issue wraps the functionality to get issues for repositories\n */\nclass Issue extends Requestable {\n /**\n * Create a new Issue\n * @param {string} repository - the full name of the repository (`:user/:repo`) to get issues for\n * @param {Requestable.auth} [auth] - information required to authenticate to Github\n * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n */\n constructor(repository, auth, apiBase) {\n super(auth, apiBase);\n this.__repository = repository;\n }\n\n /**\n * Create a new issue\n * @see https://developer.github.com/v3/issues/#create-an-issue\n * @param {Object} issueData - the issue to create\n * @param {Requestable.callback} [cb] - will receive the created issue\n * @return {Promise} - the promise for the http request\n */\n createIssue(issueData, cb) {\n return this._request('POST', `/repos/${this.__repository}/issues`, issueData, cb);\n }\n\n /**\n * List the issues for the repository\n * @see https://developer.github.com/v3/issues/#list-issues-for-a-repository\n * @param {Object} options - filtering options\n * @param {Requestable.callback} [cb] - will receive the array of issues\n * @return {Promise} - the promise for the http request\n */\n listIssues(options, cb) {\n return this._requestAllPages(`/repos/${this.__repository}/issues`, options, cb);\n }\n\n /**\n * List the events for an issue\n * @see https://developer.github.com/v3/issues/events/#list-events-for-an-issue\n * @param {number} issue - the issue to get events for\n * @param {Requestable.callback} [cb] - will receive the list of events\n * @return {Promise} - the promise for the http request\n */\n listIssueEvents(issue, cb) {\n return this._request('GET', `/repos/${this.__repository}/issues/${issue}/events`, null, cb);\n }\n\n /**\n * List comments on an issue\n * @see https://developer.github.com/v3/issues/comments/#list-comments-on-an-issue\n * @param {number} issue - the id of the issue to get comments from\n * @param {Requestable.callback} [cb] - will receive the comments\n * @return {Promise} - the promise for the http request\n */\n listIssueComments(issue, cb) {\n return this._request('GET', `/repos/${this.__repository}/issues/${issue}/comments`, null, cb);\n }\n\n /**\n * Get a single comment on an issue\n * @see https://developer.github.com/v3/issues/comments/#get-a-single-comment\n * @param {number} id - the comment id to get\n * @param {Requestable.callback} [cb] - will receive the comment\n * @return {Promise} - the promise for the http request\n */\n getIssueComment(id, cb) {\n return this._request('GET', `/repos/${this.__repository}/issues/comments/${id}`, null, cb);\n }\n\n /**\n * Comment on an issue\n * @see https://developer.github.com/v3/issues/comments/#create-a-comment\n * @param {number} issue - the id of the issue to comment on\n * @param {string} comment - the comment to add\n * @param {Requestable.callback} [cb] - will receive the created comment\n * @return {Promise} - the promise for the http request\n */\n createIssueComment(issue, comment, cb) {\n return this._request('POST', `/repos/${this.__repository}/issues/${issue}/comments`, {body: comment}, cb);\n }\n\n /**\n * Edit a comment on an issue\n * @see https://developer.github.com/v3/issues/comments/#edit-a-comment\n * @param {number} id - the comment id to edit\n * @param {string} comment - the comment to edit\n * @param {Requestable.callback} [cb] - will receive the edited comment\n * @return {Promise} - the promise for the http request\n */\n editIssueComment(id, comment, cb) {\n return this._request('PATCH', `/repos/${this.__repository}/issues/comments/${id}`, {body: comment}, cb);\n }\n\n /**\n * Delete a comment on an issue\n * @see https://developer.github.com/v3/issues/comments/#delete-a-comment\n * @param {number} id - the comment id to delete\n * @param {Requestable.callback} [cb] - will receive true if the request is successful\n * @return {Promise} - the promise for the http request\n */\n deleteIssueComment(id, cb) {\n return this._request('DELETE', `/repos/${this.__repository}/issues/comments/${id}`, null, cb);\n }\n\n /**\n * Edit an issue\n * @see https://developer.github.com/v3/issues/#edit-an-issue\n * @param {number} issue - the issue number to edit\n * @param {Object} issueData - the new issue data\n * @param {Requestable.callback} [cb] - will receive the modified issue\n * @return {Promise} - the promise for the http request\n */\n editIssue(issue, issueData, cb) {\n return this._request('PATCH', `/repos/${this.__repository}/issues/${issue}`, issueData, cb);\n }\n\n /**\n * Get a particular issue\n * @see https://developer.github.com/v3/issues/#get-a-single-issue\n * @param {number} issue - the issue number to fetch\n * @param {Requestable.callback} [cb] - will receive the issue\n * @return {Promise} - the promise for the http request\n */\n getIssue(issue, cb) {\n return this._request('GET', `/repos/${this.__repository}/issues/${issue}`, null, cb);\n }\n\n /**\n * List the milestones for the repository\n * @see https://developer.github.com/v3/issues/milestones/#list-milestones-for-a-repository\n * @param {Object} options - filtering options\n * @param {Requestable.callback} [cb] - will receive the array of milestones\n * @return {Promise} - the promise for the http request\n */\n listMilestones(options, cb) {\n return this._request('GET', `/repos/${this.__repository}/milestones`, options, cb);\n }\n\n /**\n * Get a milestone\n * @see https://developer.github.com/v3/issues/milestones/#get-a-single-milestone\n * @param {string} milestone - the id of the milestone to fetch\n * @param {Requestable.callback} [cb] - will receive the milestone\n * @return {Promise} - the promise for the http request\n */\n getMilestone(milestone, cb) {\n return this._request('GET', `/repos/${this.__repository}/milestones/${milestone}`, null, cb);\n }\n\n /**\n * Create a new milestone\n * @see https://developer.github.com/v3/issues/milestones/#create-a-milestone\n * @param {Object} milestoneData - the milestone definition\n * @param {Requestable.callback} [cb] - will receive the milestone\n * @return {Promise} - the promise for the http request\n */\n createMilestone(milestoneData, cb) {\n return this._request('POST', `/repos/${this.__repository}/milestones`, milestoneData, cb);\n }\n\n /**\n * Edit a milestone\n * @see https://developer.github.com/v3/issues/milestones/#update-a-milestone\n * @param {string} milestone - the id of the milestone to edit\n * @param {Object} milestoneData - the updates to make to the milestone\n * @param {Requestable.callback} [cb] - will receive the updated milestone\n * @return {Promise} - the promise for the http request\n */\n editMilestone(milestone, milestoneData, cb) {\n return this._request('PATCH', `/repos/${this.__repository}/milestones/${milestone}`, milestoneData, cb);\n }\n\n /**\n * Delete a milestone (this is distinct from closing a milestone)\n * @see https://developer.github.com/v3/issues/milestones/#delete-a-milestone\n * @param {string} milestone - the id of the milestone to delete\n * @param {Requestable.callback} [cb] - will receive the status\n * @return {Promise} - the promise for the http request\n */\n deleteMilestone(milestone, cb) {\n return this._request('DELETE', `/repos/${this.__repository}/milestones/${milestone}`, null, cb);\n }\n\n /**\n * Create a new label\n * @see https://developer.github.com/v3/issues/labels/#create-a-label\n * @param {Object} labelData - the label definition\n * @param {Requestable.callback} [cb] - will receive the object representing the label\n * @return {Promise} - the promise for the http request\n */\n createLabel(labelData, cb) {\n return this._request('POST', `/repos/${this.__repository}/labels`, labelData, cb);\n }\n\n /**\n * List the labels for the repository\n * @see https://developer.github.com/v3/issues/labels/#list-all-labels-for-this-repository\n * @param {Object} options - filtering options\n * @param {Requestable.callback} [cb] - will receive the array of labels\n * @return {Promise} - the promise for the http request\n */\n listLabels(options, cb) {\n return this._request('GET', `/repos/${this.__repository}/labels`, options, cb);\n }\n\n /**\n * Get a label\n * @see https://developer.github.com/v3/issues/labels/#get-a-single-label\n * @param {string} label - the name of the label to fetch\n * @param {Requestable.callback} [cb] - will receive the label\n * @return {Promise} - the promise for the http request\n */\n getLabel(label, cb) {\n return this._request('GET', `/repos/${this.__repository}/labels/${label}`, null, cb);\n }\n\n /**\n * Edit a label\n * @see https://developer.github.com/v3/issues/labels/#update-a-label\n * @param {string} label - the name of the label to edit\n * @param {Object} labelData - the updates to make to the label\n * @param {Requestable.callback} [cb] - will receive the updated label\n * @return {Promise} - the promise for the http request\n */\n editLabel(label, labelData, cb) {\n return this._request('PATCH', `/repos/${this.__repository}/labels/${label}`, labelData, cb);\n }\n\n /**\n * Delete a label\n * @see https://developer.github.com/v3/issues/labels/#delete-a-label\n * @param {string} label - the name of the label to delete\n * @param {Requestable.callback} [cb] - will receive the status\n * @return {Promise} - the promise for the http request\n */\n deleteLabel(label, cb) {\n return this._request('DELETE', `/repos/${this.__repository}/labels/${label}`, null, cb);\n }\n}\n\nmodule.exports = Issue;\n","/**\n * @file\n * @copyright 2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n * Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\n\n/**\n * Renders html from Markdown text\n */\nclass Markdown extends Requestable {\n /**\n * construct a Markdown\n * @param {Requestable.auth} auth - the credentials to authenticate to GitHub\n * @param {string} [apiBase] - the base Github API URL\n * @return {Promise} - the promise for the http request\n */\n constructor(auth, apiBase) {\n super(auth, apiBase);\n }\n\n /**\n * Render html from Markdown text.\n * @see https://developer.github.com/v3/markdown/#render-an-arbitrary-markdown-document\n * @param {Object} options - conversion options\n * @param {string} [options.text] - the markdown text to convert\n * @param {string} [options.mode=markdown] - can be either `markdown` or `gfm`\n * @param {string} [options.context] - repository name if mode is gfm\n * @param {Requestable.callback} [cb] - will receive the converted html\n * @return {Promise} - the promise for the http request\n */\n render(options, cb) {\n return this._request('POST', '/markdown', options, cb);\n }\n}\n\nmodule.exports = Markdown;\n","/**\n * @file\n * @copyright 2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n * Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\n\n/**\n * Organization encapsulates the functionality to create repositories in organizations\n */\nclass Organization extends Requestable {\n /**\n * Create a new Organization\n * @param {string} organization - the name of the organization\n * @param {Requestable.auth} [auth] - information required to authenticate to Github\n * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n */\n constructor(organization, auth, apiBase) {\n super(auth, apiBase);\n this.__name = organization;\n }\n\n /**\n * Create a repository in an organization\n * @see https://developer.github.com/v3/repos/#create\n * @param {Object} options - the repository definition\n * @param {Requestable.callback} [cb] - will receive the created repository\n * @return {Promise} - the promise for the http request\n */\n createRepo(options, cb) {\n return this._request('POST', `/orgs/${this.__name}/repos`, options, cb);\n }\n\n /**\n * List the repositories in an organization\n * @see https://developer.github.com/v3/repos/#list-organization-repositories\n * @param {Requestable.callback} [cb] - will receive the list of repositories\n * @return {Promise} - the promise for the http request\n */\n getRepos(cb) {\n let requestOptions = this._getOptionsWithDefaults({direction: 'desc'});\n\n return this._requestAllPages(`/orgs/${this.__name}/repos`, requestOptions, cb);\n }\n\n /**\n * Query if the user is a member or not\n * @param {string} username - the user in question\n * @param {Requestable.callback} [cb] - will receive true if the user is a member\n * @return {Promise} - the promise for the http request\n */\n isMember(username, cb) {\n return this._request204or404(`/orgs/${this.__name}/members/${username}`, null, cb);\n }\n\n /**\n * List the users who are members of the company\n * @see https://developer.github.com/v3/orgs/members/#members-list\n * @param {object} options - filtering options\n * @param {string} [options.filter=all] - can be either `2fa_disabled` or `all`\n * @param {string} [options.role=all] - can be one of: `all`, `admin`, or `member`\n * @param {Requestable.callback} [cb] - will receive the list of users\n * @return {Promise} - the promise for the http request\n */\n listMembers(options, cb) {\n return this._request('GET', `/orgs/${this.__name}/members`, options, cb);\n }\n\n /**\n * List the Teams in the Organization\n * @see https://developer.github.com/v3/orgs/teams/#list-teams\n * @param {Requestable.callback} [cb] - will receive the list of teams\n * @return {Promise} - the promise for the http request\n */\n getTeams(cb) {\n return this._requestAllPages(`/orgs/${this.__name}/teams`, undefined, cb);\n }\n\n /**\n * Create a team\n * @see https://developer.github.com/v3/orgs/teams/#create-team\n * @param {object} options - Team creation parameters\n * @param {string} options.name - The name of the team\n * @param {string} [options.description] - Team description\n * @param {string} [options.repo_names] - Repos to add the team to\n * @param {string} [options.privacy=secret] - The level of privacy the team should have. Can be either one\n * of: `secret`, or `closed`\n * @param {Requestable.callback} [cb] - will receive the created team\n * @return {Promise} - the promise for the http request\n */\n createTeam(options, cb) {\n return this._request('POST', `/orgs/${this.__name}/teams`, options, cb);\n }\n\n /**\n * Get information about all projects\n * @see https://developer.github.com/v3/projects/#list-organization-projects\n * @param {Requestable.callback} [cb] - will receive the list of projects\n * @return {Promise} - the promise for the http request\n */\n listProjects(cb) {\n return this._requestAllPages(`/orgs/${this.__name}/projects`, {AcceptHeader: 'inertia-preview'}, cb);\n }\n\n /**\n * Create a new project\n * @see https://developer.github.com/v3/repos/projects/#create-a-project\n * @param {Object} options - the description of the project\n * @param {Requestable.callback} cb - will receive the newly created project\n * @return {Promise} - the promise for the http request\n */\n createProject(options, cb) {\n options = options || {};\n options.AcceptHeader = 'inertia-preview';\n return this._request('POST', `/orgs/${this.__name}/projects`, options, cb);\n }\n}\n\nmodule.exports = Organization;\n","/**\n * @file\n * @copyright 2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n * Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\n\n/**\n * Project encapsulates the functionality to create, query, and modify cards and columns.\n */\nclass Project extends Requestable {\n /**\n * Create a Project.\n * @param {string} id - the id of the project\n * @param {Requestable.auth} [auth] - information required to authenticate to Github\n * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n */\n constructor(id, auth, apiBase) {\n super(auth, apiBase, 'inertia-preview');\n this.__id = id;\n }\n\n /**\n * Get information about a project\n * @see https://developer.github.com/v3/projects/#get-a-project\n * @param {Requestable.callback} cb - will receive the project information\n * @return {Promise} - the promise for the http request\n */\n getProject(cb) {\n return this._request('GET', `/projects/${this.__id}`, null, cb);\n }\n\n /**\n * Edit a project\n * @see https://developer.github.com/v3/projects/#update-a-project\n * @param {Object} options - the description of the project\n * @param {Requestable.callback} cb - will receive the modified project\n * @return {Promise} - the promise for the http request\n */\n updateProject(options, cb) {\n return this._request('PATCH', `/projects/${this.__id}`, options, cb);\n }\n\n /**\n * Delete a project\n * @see https://developer.github.com/v3/projects/#delete-a-project\n * @param {Requestable.callback} cb - will receive true if the operation is successful\n * @return {Promise} - the promise for the http request\n */\n deleteProject(cb) {\n return this._request('DELETE', `/projects/${this.__id}`, null, cb);\n }\n\n /**\n * Get information about all columns of a project\n * @see https://developer.github.com/v3/projects/columns/#list-project-columns\n * @param {Requestable.callback} [cb] - will receive the list of columns\n * @return {Promise} - the promise for the http request\n */\n listProjectColumns(cb) {\n return this._requestAllPages(`/projects/${this.__id}/columns`, null, cb);\n }\n\n /**\n * Get information about a column\n * @see https://developer.github.com/v3/projects/columns/#get-a-project-column\n * @param {string} colId - the id of the column\n * @param {Requestable.callback} cb - will receive the column information\n * @return {Promise} - the promise for the http request\n */\n getProjectColumn(colId, cb) {\n return this._request('GET', `/projects/columns/${colId}`, null, cb);\n }\n\n /**\n * Create a new column\n * @see https://developer.github.com/v3/projects/columns/#create-a-project-column\n * @param {Object} options - the description of the column\n * @param {Requestable.callback} cb - will receive the newly created column\n * @return {Promise} - the promise for the http request\n */\n createProjectColumn(options, cb) {\n return this._request('POST', `/projects/${this.__id}/columns`, options, cb);\n }\n\n /**\n * Edit a column\n * @see https://developer.github.com/v3/projects/columns/#update-a-project-column\n * @param {string} colId - the column id\n * @param {Object} options - the description of the column\n * @param {Requestable.callback} cb - will receive the modified column\n * @return {Promise} - the promise for the http request\n */\n updateProjectColumn(colId, options, cb) {\n return this._request('PATCH', `/projects/columns/${colId}`, options, cb);\n }\n\n /**\n * Delete a column\n * @see https://developer.github.com/v3/projects/columns/#delete-a-project-column\n * @param {string} colId - the column to be deleted\n * @param {Requestable.callback} cb - will receive true if the operation is successful\n * @return {Promise} - the promise for the http request\n */\n deleteProjectColumn(colId, cb) {\n return this._request('DELETE', `/projects/columns/${colId}`, null, cb);\n }\n\n /**\n * Move a column\n * @see https://developer.github.com/v3/projects/columns/#move-a-project-column\n * @param {string} colId - the column to be moved\n * @param {string} position - can be one of first, last, or after:,\n * where is the id value of a column in the same project.\n * @param {Requestable.callback} cb - will receive true if the operation is successful\n * @return {Promise} - the promise for the http request\n */\n moveProjectColumn(colId, position, cb) {\n return this._request(\n 'POST',\n `/projects/columns/${colId}/moves`,\n {position: position},\n cb\n );\n }\n\n /**\n * Get information about all cards of a project\n * @see https://developer.github.com/v3/projects/cards/#list-project-cards\n * @param {Requestable.callback} [cb] - will receive the list of cards\n * @return {Promise} - the promise for the http request\n */\n listProjectCards(cb) {\n return this.listProjectColumns()\n .then(({data}) => {\n return Promise.all(data.map((column) => {\n return this._requestAllPages(`/projects/columns/${column.id}/cards`, null);\n }));\n }).then((cardsInColumns) => {\n const cards = cardsInColumns.reduce((prev, {data}) => {\n prev.push(...data);\n return prev;\n }, []);\n if (cb) {\n cb(null, cards);\n }\n return cards;\n }).catch((err) => {\n if (cb) {\n cb(err);\n return;\n }\n throw err;\n });\n }\n\n /**\n * Get information about all cards of a column\n * @see https://developer.github.com/v3/projects/cards/#list-project-cards\n * @param {string} colId - the id of the column\n * @param {Requestable.callback} [cb] - will receive the list of cards\n * @return {Promise} - the promise for the http request\n */\n listColumnCards(colId, cb) {\n return this._requestAllPages(`/projects/columns/${colId}/cards`, null, cb);\n }\n\n /**\n * Get information about a card\n * @see https://developer.github.com/v3/projects/cards/#get-a-project-card\n * @param {string} cardId - the id of the card\n * @param {Requestable.callback} cb - will receive the card information\n * @return {Promise} - the promise for the http request\n */\n getProjectCard(cardId, cb) {\n return this._request('GET', `/projects/columns/cards/${cardId}`, null, cb);\n }\n\n /**\n * Create a new card\n * @see https://developer.github.com/v3/projects/cards/#create-a-project-card\n * @param {string} colId - the column id\n * @param {Object} options - the description of the card\n * @param {Requestable.callback} cb - will receive the newly created card\n * @return {Promise} - the promise for the http request\n */\n createProjectCard(colId, options, cb) {\n return this._request('POST', `/projects/columns/${colId}/cards`, options, cb);\n }\n\n /**\n * Edit a card\n * @see https://developer.github.com/v3/projects/cards/#update-a-project-card\n * @param {string} cardId - the card id\n * @param {Object} options - the description of the card\n * @param {Requestable.callback} cb - will receive the modified card\n * @return {Promise} - the promise for the http request\n */\n updateProjectCard(cardId, options, cb) {\n return this._request('PATCH', `/projects/columns/cards/${cardId}`, options, cb);\n }\n\n /**\n * Delete a card\n * @see https://developer.github.com/v3/projects/cards/#delete-a-project-card\n * @param {string} cardId - the card to be deleted\n * @param {Requestable.callback} cb - will receive true if the operation is successful\n * @return {Promise} - the promise for the http request\n */\n deleteProjectCard(cardId, cb) {\n return this._request('DELETE', `/projects/columns/cards/${cardId}`, null, cb);\n }\n\n /**\n * Move a card\n * @see https://developer.github.com/v3/projects/cards/#move-a-project-card\n * @param {string} cardId - the card to be moved\n * @param {string} position - can be one of top, bottom, or after:,\n * where is the id value of a card in the same project.\n * @param {string} colId - the id value of a column in the same project.\n * @param {Requestable.callback} cb - will receive true if the operation is successful\n * @return {Promise} - the promise for the http request\n */\n moveProjectCard(cardId, position, colId, cb) {\n return this._request(\n 'POST',\n `/projects/columns/cards/${cardId}/moves`,\n {position: position, column_id: colId}, // eslint-disable-line camelcase\n cb\n );\n }\n}\n\nmodule.exports = Project;\n","/**\n * @file\n * @copyright 2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n * Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\n\n/**\n * RateLimit allows users to query their rate-limit status\n */\nclass RateLimit extends Requestable {\n /**\n * construct a RateLimit\n * @param {Requestable.auth} auth - the credentials to authenticate to GitHub\n * @param {string} [apiBase] - the base Github API URL\n * @return {Promise} - the promise for the http request\n */\n constructor(auth, apiBase) {\n super(auth, apiBase);\n }\n\n /**\n * Query the current rate limit\n * @see https://developer.github.com/v3/rate_limit/\n * @param {Requestable.callback} [cb] - will receive the rate-limit data\n * @return {Promise} - the promise for the http request\n */\n getRateLimit(cb) {\n return this._request('GET', '/rate_limit', null, cb);\n }\n}\n\nmodule.exports = RateLimit;\n","/**\n * @file\n * @copyright 2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n * Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\nimport Utf8 from 'utf8';\nimport {\n Base64,\n} from 'js-base64';\nimport debug from 'debug';\nconst log = debug('github:repository');\n\n/**\n * Respository encapsulates the functionality to create, query, and modify files.\n */\nclass Repository extends Requestable {\n /**\n * Create a Repository.\n * @param {string} fullname - the full name of the repository\n * @param {Requestable.auth} [auth] - information required to authenticate to Github\n * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n */\n constructor(fullname, auth, apiBase) {\n super(auth, apiBase);\n this.__fullname = fullname;\n this.__currentTree = {\n branch: null,\n sha: null,\n };\n }\n\n /**\n * Get a reference\n * @see https://developer.github.com/v3/git/refs/#get-a-reference\n * @param {string} ref - the reference to get\n * @param {Requestable.callback} [cb] - will receive the reference's refSpec or a list of refSpecs that match `ref`\n * @return {Promise} - the promise for the http request\n */\n getRef(ref, cb) {\n return this._request('GET', `/repos/${this.__fullname}/git/refs/${ref}`, null, cb);\n }\n\n /**\n * Create a reference\n * @see https://developer.github.com/v3/git/refs/#create-a-reference\n * @param {Object} options - the object describing the ref\n * @param {Requestable.callback} [cb] - will receive the ref\n * @return {Promise} - the promise for the http request\n */\n createRef(options, cb) {\n return this._request('POST', `/repos/${this.__fullname}/git/refs`, options, cb);\n }\n\n /**\n * Delete a reference\n * @see https://developer.github.com/v3/git/refs/#delete-a-reference\n * @param {string} ref - the name of the ref to delte\n * @param {Requestable.callback} [cb] - will receive true if the request is successful\n * @return {Promise} - the promise for the http request\n */\n deleteRef(ref, cb) {\n return this._request('DELETE', `/repos/${this.__fullname}/git/refs/${ref}`, null, cb);\n }\n\n /**\n * Delete a repository\n * @see https://developer.github.com/v3/repos/#delete-a-repository\n * @param {Requestable.callback} [cb] - will receive true if the request is successful\n * @return {Promise} - the promise for the http request\n */\n deleteRepo(cb) {\n return this._request('DELETE', `/repos/${this.__fullname}`, null, cb);\n }\n\n /**\n * List the tags on a repository\n * @see https://developer.github.com/v3/repos/#list-tags\n * @param {Requestable.callback} [cb] - will receive the tag data\n * @return {Promise} - the promise for the http request\n */\n listTags(cb) {\n return this._request('GET', `/repos/${this.__fullname}/tags`, null, cb);\n }\n\n /**\n * List the open pull requests on the repository\n * @see https://developer.github.com/v3/pulls/#list-pull-requests\n * @param {Object} options - options to filter the search\n * @param {Requestable.callback} [cb] - will receive the list of PRs\n * @return {Promise} - the promise for the http request\n */\n listPullRequests(options, cb) {\n options = options || {};\n return this._request('GET', `/repos/${this.__fullname}/pulls`, options, cb);\n }\n\n /**\n * Get information about a specific pull request\n * @see https://developer.github.com/v3/pulls/#get-a-single-pull-request\n * @param {number} number - the PR you wish to fetch\n * @param {Requestable.callback} [cb] - will receive the PR from the API\n * @return {Promise} - the promise for the http request\n */\n getPullRequest(number, cb) {\n return this._request('GET', `/repos/${this.__fullname}/pulls/${number}`, null, cb);\n }\n\n /**\n * List the files of a specific pull request\n * @see https://developer.github.com/v3/pulls/#list-pull-requests-files\n * @param {number|string} number - the PR you wish to fetch\n * @param {Requestable.callback} [cb] - will receive the list of files from the API\n * @return {Promise} - the promise for the http request\n */\n listPullRequestFiles(number, cb) {\n return this._request('GET', `/repos/${this.__fullname}/pulls/${number}/files`, null, cb);\n }\n\n /**\n * Compare two branches/commits/repositories\n * @see https://developer.github.com/v3/repos/commits/#compare-two-commits\n * @param {string} base - the base commit\n * @param {string} head - the head commit\n * @param {Requestable.callback} cb - will receive the comparison\n * @return {Promise} - the promise for the http request\n */\n compareBranches(base, head, cb) {\n return this._request('GET', `/repos/${this.__fullname}/compare/${base}...${head}`, null, cb);\n }\n\n /**\n * List all the branches for the repository\n * @see https://developer.github.com/v3/repos/#list-branches\n * @param {Requestable.callback} cb - will receive the list of branches\n * @return {Promise} - the promise for the http request\n */\n listBranches(cb) {\n return this._request('GET', `/repos/${this.__fullname}/branches`, null, cb);\n }\n\n /**\n * Get a raw blob from the repository\n * @see https://developer.github.com/v3/git/blobs/#get-a-blob\n * @param {string} sha - the sha of the blob to fetch\n * @param {Requestable.callback} cb - will receive the blob from the API\n * @return {Promise} - the promise for the http request\n */\n getBlob(sha, cb) {\n return this._request('GET', `/repos/${this.__fullname}/git/blobs/${sha}`, null, cb, 'raw');\n }\n\n /**\n * Get a single branch\n * @see https://developer.github.com/v3/repos/branches/#get-branch\n * @param {string} branch - the name of the branch to fetch\n * @param {Requestable.callback} cb - will receive the branch from the API\n * @returns {Promise} - the promise for the http request\n */\n getBranch(branch, cb) {\n return this._request('GET', `/repos/${this.__fullname}/branches/${branch}`, null, cb);\n }\n\n /**\n * Get a commit from the repository\n * @see https://developer.github.com/v3/repos/commits/#get-a-single-commit\n * @param {string} sha - the sha for the commit to fetch\n * @param {Requestable.callback} cb - will receive the commit data\n * @return {Promise} - the promise for the http request\n */\n getCommit(sha, cb) {\n return this._request('GET', `/repos/${this.__fullname}/git/commits/${sha}`, null, cb);\n }\n\n /**\n * List the commits on a repository, optionally filtering by path, author or time range\n * @see https://developer.github.com/v3/repos/commits/#list-commits-on-a-repository\n * @param {Object} [options] - the filtering options for commits\n * @param {string} [options.sha] - the SHA or branch to start from\n * @param {string} [options.path] - the path to search on\n * @param {string} [options.author] - the commit author\n * @param {(Date|string)} [options.since] - only commits after this date will be returned\n * @param {(Date|string)} [options.until] - only commits before this date will be returned\n * @param {Requestable.callback} cb - will receive the list of commits found matching the criteria\n * @return {Promise} - the promise for the http request\n */\n listCommits(options, cb) {\n options = options || {};\n\n options.since = this._dateToISO(options.since);\n options.until = this._dateToISO(options.until);\n\n return this._request('GET', `/repos/${this.__fullname}/commits`, options, cb);\n }\n\n /**\n * Gets a single commit information for a repository\n * @see https://developer.github.com/v3/repos/commits/#get-a-single-commit\n * @param {string} ref - the reference for the commit-ish\n * @param {Requestable.callback} cb - will receive the commit information\n * @return {Promise} - the promise for the http request\n */\n getSingleCommit(ref, cb) {\n ref = ref || '';\n return this._request('GET', `/repos/${this.__fullname}/commits/${ref}`, null, cb);\n }\n\n /**\n * Get tha sha for a particular object in the repository. This is a convenience function\n * @see https://developer.github.com/v3/repos/contents/#get-contents\n * @param {string} [branch] - the branch to look in, or the repository's default branch if omitted\n * @param {string} path - the path of the file or directory\n * @param {Requestable.callback} cb - will receive a description of the requested object, including a `SHA` property\n * @return {Promise} - the promise for the http request\n */\n getSha(branch, path, cb) {\n branch = branch ? `?ref=${branch}` : '';\n return this._request('GET', `/repos/${this.__fullname}/contents/${path}${branch}`, null, cb);\n }\n\n /**\n * List the commit statuses for a particular sha, branch, or tag\n * @see https://developer.github.com/v3/repos/statuses/#list-statuses-for-a-specific-ref\n * @param {string} sha - the sha, branch, or tag to get statuses for\n * @param {Requestable.callback} cb - will receive the list of statuses\n * @return {Promise} - the promise for the http request\n */\n listStatuses(sha, cb) {\n return this._request('GET', `/repos/${this.__fullname}/commits/${sha}/statuses`, null, cb);\n }\n\n /**\n * Get a description of a git tree\n * @see https://developer.github.com/v3/git/trees/#get-a-tree\n * @param {string} treeSHA - the SHA of the tree to fetch\n * @param {Requestable.callback} cb - will receive the callback data\n * @return {Promise} - the promise for the http request\n */\n getTree(treeSHA, cb) {\n return this._request('GET', `/repos/${this.__fullname}/git/trees/${treeSHA}`, null, cb);\n }\n\n /**\n * Create a blob\n * @see https://developer.github.com/v3/git/blobs/#create-a-blob\n * @param {(string|Buffer|Blob)} content - the content to add to the repository\n * @param {Requestable.callback} cb - will receive the details of the created blob\n * @return {Promise} - the promise for the http request\n */\n createBlob(content, cb) {\n let postBody = this._getContentObject(content);\n\n log('sending content', postBody);\n return this._request('POST', `/repos/${this.__fullname}/git/blobs`, postBody, cb);\n }\n\n /**\n * Get the object that represents the provided content\n * @param {string|Buffer|Blob} content - the content to send to the server\n * @return {Object} the representation of `content` for the GitHub API\n */\n _getContentObject(content) {\n if (typeof content === 'string') {\n log('contet is a string');\n return {\n content: Utf8.encode(content),\n encoding: 'utf-8',\n };\n\n } else if (typeof Buffer !== 'undefined' && content instanceof Buffer) {\n log('We appear to be in Node');\n return {\n content: content.toString('base64'),\n encoding: 'base64',\n };\n\n } else if (typeof Blob !== 'undefined' && content instanceof Blob) {\n log('We appear to be in the browser');\n return {\n content: Base64.encode(content),\n encoding: 'base64',\n };\n\n } else { // eslint-disable-line\n log(`Not sure what this content is: ${typeof content}, ${JSON.stringify(content)}`);\n throw new Error('Unknown content passed to postBlob. Must be string or Buffer (node) or Blob (web)');\n }\n }\n\n /**\n * Update a tree in Git\n * @see https://developer.github.com/v3/git/trees/#create-a-tree\n * @param {string} baseTreeSHA - the SHA of the tree to update\n * @param {string} path - the path for the new file\n * @param {string} blobSHA - the SHA for the blob to put at `path`\n * @param {Requestable.callback} cb - will receive the new tree that is created\n * @return {Promise} - the promise for the http request\n * @deprecated use {@link Repository#createTree} instead\n */\n updateTree(baseTreeSHA, path, blobSHA, cb) {\n let newTree = {\n base_tree: baseTreeSHA, // eslint-disable-line\n tree: [{\n path: path,\n sha: blobSHA,\n mode: '100644',\n type: 'blob',\n }],\n };\n\n return this._request('POST', `/repos/${this.__fullname}/git/trees`, newTree, cb);\n }\n\n /**\n * Create a new tree in git\n * @see https://developer.github.com/v3/git/trees/#create-a-tree\n * @param {Object} tree - the tree to create\n * @param {string} baseSHA - the root sha of the tree\n * @param {Requestable.callback} cb - will receive the new tree that is created\n * @return {Promise} - the promise for the http request\n */\n createTree(tree, baseSHA, cb) {\n return this._request('POST', `/repos/${this.__fullname}/git/trees`, {\n tree,\n base_tree: baseSHA, // eslint-disable-line camelcase\n }, cb);\n }\n\n /**\n * Add a commit to the repository\n * @see https://developer.github.com/v3/git/commits/#create-a-commit\n * @param {string} parent - the SHA of the parent commit\n * @param {string} tree - the SHA of the tree for this commit\n * @param {string} message - the commit message\n * @param {Requestable.callback} cb - will receive the commit that is created\n * @return {Promise} - the promise for the http request\n */\n commit(parent, tree, message, cb) {\n let data = {\n message,\n tree,\n parents: [parent],\n };\n\n return this._request('POST', `/repos/${this.__fullname}/git/commits`, data, cb)\n .then((response) => {\n this.__currentTree.sha = response.data.sha; // Update latest commit\n return response;\n });\n }\n\n /**\n * Update a ref\n * @see https://developer.github.com/v3/git/refs/#update-a-reference\n * @param {string} ref - the ref to update\n * @param {string} commitSHA - the SHA to point the reference to\n * @param {boolean} force - indicates whether to force or ensure a fast-forward update\n * @param {Requestable.callback} cb - will receive the updated ref back\n * @return {Promise} - the promise for the http request\n */\n updateHead(ref, commitSHA, force, cb) {\n return this._request('PATCH', `/repos/${this.__fullname}/git/refs/${ref}`, {\n sha: commitSHA,\n force: force,\n }, cb);\n }\n\n /**\n * Update commit status\n * @see https://developer.github.com/v3/repos/statuses/\n * @param {string} commitSHA - the SHA of the commit that should be updated\n * @param {object} options - Commit status parameters\n * @param {string} options.state - The state of the status. Can be one of: pending, success, error, or failure.\n * @param {string} [options.target_url] - The target URL to associate with this status.\n * @param {string} [options.description] - A short description of the status.\n * @param {string} [options.context] - A string label to differentiate this status among CI systems.\n * @param {Requestable.callback} cb - will receive the updated commit back\n * @return {Promise} - the promise for the http request\n */\n updateStatus(commitSHA, options, cb) {\n return this._request('POST', `/repos/${this.__fullname}/statuses/${commitSHA}`, options, cb);\n }\n\n /**\n * Update repository information\n * @see https://developer.github.com/v3/repos/#edit\n * @param {object} options - New parameters that will be set to the repository\n * @param {string} options.name - Name of the repository\n * @param {string} [options.description] - A short description of the repository\n * @param {string} [options.homepage] - A URL with more information about the repository\n * @param {boolean} [options.private] - Either true to make the repository private, or false to make it public.\n * @param {boolean} [options.has_issues] - Either true to enable issues for this repository, false to disable them.\n * @param {boolean} [options.has_wiki] - Either true to enable the wiki for this repository, false to disable it.\n * @param {boolean} [options.has_downloads] - Either true to enable downloads, false to disable them.\n * @param {string} [options.default_branch] - Updates the default branch for this repository.\n * @param {Requestable.callback} cb - will receive the updated repository back\n * @return {Promise} - the promise for the http request\n */\n updateRepository(options, cb) {\n return this._request('PATCH', `/repos/${this.__fullname}`, options, cb);\n }\n\n /**\n * Get information about the repository\n * @see https://developer.github.com/v3/repos/#get\n * @param {Requestable.callback} cb - will receive the information about the repository\n * @return {Promise} - the promise for the http request\n */\n getDetails(cb) {\n return this._request('GET', `/repos/${this.__fullname}`, null, cb);\n }\n\n /**\n * List the contributors to the repository\n * @see https://developer.github.com/v3/repos/#list-contributors\n * @param {Requestable.callback} cb - will receive the list of contributors\n * @return {Promise} - the promise for the http request\n */\n getContributors(cb) {\n return this._request('GET', `/repos/${this.__fullname}/contributors`, null, cb);\n }\n\n /**\n * List the contributor stats to the repository\n * @see https://developer.github.com/v3/repos/#list-contributors\n * @param {Requestable.callback} cb - will receive the list of contributors\n * @return {Promise} - the promise for the http request\n */\n getContributorStats(cb) {\n return this._request('GET', `/repos/${this.__fullname}/stats/contributors`, null, cb);\n }\n\n /**\n * List the users who are collaborators on the repository. The currently authenticated user must have\n * push access to use this method\n * @see https://developer.github.com/v3/repos/collaborators/#list-collaborators\n * @param {Requestable.callback} cb - will receive the list of collaborators\n * @return {Promise} - the promise for the http request\n */\n getCollaborators(cb) {\n return this._request('GET', `/repos/${this.__fullname}/collaborators`, null, cb);\n }\n\n /**\n * Check if a user is a collaborator on the repository\n * @see https://developer.github.com/v3/repos/collaborators/#check-if-a-user-is-a-collaborator\n * @param {string} username - the user to check\n * @param {Requestable.callback} cb - will receive true if the user is a collaborator and false if they are not\n * @return {Promise} - the promise for the http request {Boolean} [description]\n */\n isCollaborator(username, cb) {\n return this._request('GET', `/repos/${this.__fullname}/collaborators/${username}`, null, cb);\n }\n\n /**\n * Get the contents of a repository\n * @see https://developer.github.com/v3/repos/contents/#get-contents\n * @param {string} ref - the ref to check\n * @param {string} path - the path containing the content to fetch\n * @param {boolean} raw - `true` if the results should be returned raw instead of GitHub's normalized format\n * @param {Requestable.callback} cb - will receive the fetched data\n * @return {Promise} - the promise for the http request\n */\n getContents(ref, path, raw, cb) {\n path = path ? `${encodeURI(path)}` : '';\n return this._request('GET', `/repos/${this.__fullname}/contents/${path}`, {\n ref,\n }, cb, raw);\n }\n\n /**\n * Get the README of a repository\n * @see https://developer.github.com/v3/repos/contents/#get-the-readme\n * @param {string} ref - the ref to check\n * @param {boolean} raw - `true` if the results should be returned raw instead of GitHub's normalized format\n * @param {Requestable.callback} cb - will receive the fetched data\n * @return {Promise} - the promise for the http request\n */\n getReadme(ref, raw, cb) {\n return this._request('GET', `/repos/${this.__fullname}/readme`, {\n ref,\n }, cb, raw);\n }\n\n /**\n * Fork a repository\n * @see https://developer.github.com/v3/repos/forks/#create-a-fork\n * @param {Requestable.callback} cb - will receive the information about the newly created fork\n * @return {Promise} - the promise for the http request\n */\n fork(cb) {\n return this._request('POST', `/repos/${this.__fullname}/forks`, null, cb);\n }\n\n /**\n * List a repository's forks\n * @see https://developer.github.com/v3/repos/forks/#list-forks\n * @param {Requestable.callback} cb - will receive the list of repositories forked from this one\n * @return {Promise} - the promise for the http request\n */\n listForks(cb) {\n return this._request('GET', `/repos/${this.__fullname}/forks`, null, cb);\n }\n\n /**\n * Create a new branch from an existing branch.\n * @param {string} [oldBranch=master] - the name of the existing branch\n * @param {string} newBranch - the name of the new branch\n * @param {Requestable.callback} cb - will receive the commit data for the head of the new branch\n * @return {Promise} - the promise for the http request\n */\n createBranch(oldBranch, newBranch, cb) {\n if (typeof newBranch === 'function') {\n cb = newBranch;\n newBranch = oldBranch;\n oldBranch = 'master';\n }\n\n return this.getRef(`heads/${oldBranch}`)\n .then((response) => {\n let sha = response.data.object.sha;\n return this.createRef({\n sha,\n ref: `refs/heads/${newBranch}`,\n }, cb);\n });\n }\n\n /**\n * Create a new pull request\n * @see https://developer.github.com/v3/pulls/#create-a-pull-request\n * @param {Object} options - the pull request description\n * @param {Requestable.callback} cb - will receive the new pull request\n * @return {Promise} - the promise for the http request\n */\n createPullRequest(options, cb) {\n return this._request('POST', `/repos/${this.__fullname}/pulls`, options, cb);\n }\n\n /**\n * Update a pull request\n * @see https://developer.github.com/v3/pulls/#update-a-pull-request\n * @param {number|string} number - the number of the pull request to update\n * @param {Object} options - the pull request description\n * @param {Requestable.callback} [cb] - will receive the pull request information\n * @return {Promise} - the promise for the http request\n */\n updatePullRequest(number, options, cb) {\n return this._request('PATCH', `/repos/${this.__fullname}/pulls/${number}`, options, cb);\n }\n\n /**\n * List the hooks for the repository\n * @see https://developer.github.com/v3/repos/hooks/#list-hooks\n * @param {Requestable.callback} cb - will receive the list of hooks\n * @return {Promise} - the promise for the http request\n */\n listHooks(cb) {\n return this._request('GET', `/repos/${this.__fullname}/hooks`, null, cb);\n }\n\n /**\n * Get a hook for the repository\n * @see https://developer.github.com/v3/repos/hooks/#get-single-hook\n * @param {number} id - the id of the webook\n * @param {Requestable.callback} cb - will receive the details of the webook\n * @return {Promise} - the promise for the http request\n */\n getHook(id, cb) {\n return this._request('GET', `/repos/${this.__fullname}/hooks/${id}`, null, cb);\n }\n\n /**\n * Add a new hook to the repository\n * @see https://developer.github.com/v3/repos/hooks/#create-a-hook\n * @param {Object} options - the configuration describing the new hook\n * @param {Requestable.callback} cb - will receive the new webhook\n * @return {Promise} - the promise for the http request\n */\n createHook(options, cb) {\n return this._request('POST', `/repos/${this.__fullname}/hooks`, options, cb);\n }\n\n /**\n * Edit an existing webhook\n * @see https://developer.github.com/v3/repos/hooks/#edit-a-hook\n * @param {number} id - the id of the webhook\n * @param {Object} options - the new description of the webhook\n * @param {Requestable.callback} cb - will receive the updated webhook\n * @return {Promise} - the promise for the http request\n */\n updateHook(id, options, cb) {\n return this._request('PATCH', `/repos/${this.__fullname}/hooks/${id}`, options, cb);\n }\n\n /**\n * Delete a webhook\n * @see https://developer.github.com/v3/repos/hooks/#delete-a-hook\n * @param {number} id - the id of the webhook to be deleted\n * @param {Requestable.callback} cb - will receive true if the call is successful\n * @return {Promise} - the promise for the http request\n */\n deleteHook(id, cb) {\n return this._request('DELETE', `/repos/${this.__fullname}/hooks/${id}`, null, cb);\n }\n\n /**\n * List the deploy keys for the repository\n * @see https://developer.github.com/v3/repos/keys/#list-deploy-keys\n * @param {Requestable.callback} cb - will receive the list of deploy keys\n * @return {Promise} - the promise for the http request\n */\n listKeys(cb) {\n return this._request('GET', `/repos/${this.__fullname}/keys`, null, cb);\n }\n\n /**\n * Get a deploy key for the repository\n * @see https://developer.github.com/v3/repos/keys/#get-a-deploy-key\n * @param {number} id - the id of the deploy key\n * @param {Requestable.callback} cb - will receive the details of the deploy key\n * @return {Promise} - the promise for the http request\n */\n getKey(id, cb) {\n return this._request('GET', `/repos/${this.__fullname}/keys/${id}`, null, cb);\n }\n\n /**\n * Add a new deploy key to the repository\n * @see https://developer.github.com/v3/repos/keys/#add-a-new-deploy-key\n * @param {Object} options - the configuration describing the new deploy key\n * @param {Requestable.callback} cb - will receive the new deploy key\n * @return {Promise} - the promise for the http request\n */\n createKey(options, cb) {\n return this._request('POST', `/repos/${this.__fullname}/keys`, options, cb);\n }\n\n /**\n * Delete a deploy key\n * @see https://developer.github.com/v3/repos/keys/#remove-a-deploy-key\n * @param {number} id - the id of the deploy key to be deleted\n * @param {Requestable.callback} cb - will receive true if the call is successful\n * @return {Promise} - the promise for the http request\n */\n deleteKey(id, cb) {\n return this._request('DELETE', `/repos/${this.__fullname}/keys/${id}`, null, cb);\n }\n\n /**\n * Delete a file from a branch\n * @see https://developer.github.com/v3/repos/contents/#delete-a-file\n * @param {string} branch - the branch to delete from, or the default branch if not specified\n * @param {string} path - the path of the file to remove\n * @param {Requestable.callback} cb - will receive the commit in which the delete occurred\n * @return {Promise} - the promise for the http request\n */\n deleteFile(branch, path, cb) {\n return this.getSha(branch, path)\n .then((response) => {\n const deleteCommit = {\n message: `Delete the file at '${path}'`,\n sha: response.data.sha,\n branch,\n };\n return this._request('DELETE', `/repos/${this.__fullname}/contents/${path}`, deleteCommit, cb);\n });\n }\n\n /**\n * Change all references in a repo from oldPath to new_path\n * @param {string} branch - the branch to carry out the reference change, or the default branch if not specified\n * @param {string} oldPath - original path\n * @param {string} newPath - new reference path\n * @param {Requestable.callback} cb - will receive the commit in which the move occurred\n * @return {Promise} - the promise for the http request\n */\n move(branch, oldPath, newPath, cb) {\n let oldSha;\n return this.getRef(`heads/${branch}`)\n .then(({data: {object}}) => this.getTree(`${object.sha}?recursive=true`))\n .then(({data: {tree, sha}}) => {\n oldSha = sha;\n let newTree = tree.map((ref) => {\n if (ref.path === oldPath) {\n ref.path = newPath;\n }\n if (ref.type === 'tree') {\n delete ref.sha;\n }\n return ref;\n });\n return this.createTree(newTree);\n })\n .then(({data: tree}) => this.commit(oldSha, tree.sha, `Renamed '${oldPath}' to '${newPath}'`))\n .then(({data: commit}) => this.updateHead(`heads/${branch}`, commit.sha, true, cb));\n }\n\n /**\n * Write a file to the repository\n * @see https://developer.github.com/v3/repos/contents/#update-a-file\n * @param {string} branch - the name of the branch\n * @param {string} path - the path for the file\n * @param {string} content - the contents of the file\n * @param {string} message - the commit message\n * @param {Object} [options] - commit options\n * @param {Object} [options.author] - the author of the commit\n * @param {Object} [options.commiter] - the committer\n * @param {boolean} [options.encode] - true if the content should be base64 encoded\n * @param {Requestable.callback} cb - will receive the new commit\n * @return {Promise} - the promise for the http request\n */\n writeFile(branch, path, content, message, options, cb) {\n if (typeof options === 'function') {\n cb = options;\n options = {};\n }\n let filePath = path ? encodeURI(path) : '';\n let shouldEncode = options.encode !== false;\n let commit = {\n branch,\n message,\n author: options.author,\n committer: options.committer,\n content: shouldEncode ? Base64.encode(content) : content,\n };\n\n return this.getSha(branch, filePath)\n .then((response) => {\n commit.sha = response.data.sha;\n return this._request('PUT', `/repos/${this.__fullname}/contents/${filePath}`, commit, cb);\n }, () => {\n return this._request('PUT', `/repos/${this.__fullname}/contents/${filePath}`, commit, cb);\n });\n }\n\n /**\n * Check if a repository is starred by you\n * @see https://developer.github.com/v3/activity/starring/#check-if-you-are-starring-a-repository\n * @param {Requestable.callback} cb - will receive true if the repository is starred and false if the repository\n * is not starred\n * @return {Promise} - the promise for the http request {Boolean} [description]\n */\n isStarred(cb) {\n return this._request204or404(`/user/starred/${this.__fullname}`, null, cb);\n }\n\n /**\n * Star a repository\n * @see https://developer.github.com/v3/activity/starring/#star-a-repository\n * @param {Requestable.callback} cb - will receive true if the repository is starred\n * @return {Promise} - the promise for the http request\n */\n star(cb) {\n return this._request('PUT', `/user/starred/${this.__fullname}`, null, cb);\n }\n\n /**\n * Unstar a repository\n * @see https://developer.github.com/v3/activity/starring/#unstar-a-repository\n * @param {Requestable.callback} cb - will receive true if the repository is unstarred\n * @return {Promise} - the promise for the http request\n */\n unstar(cb) {\n return this._request('DELETE', `/user/starred/${this.__fullname}`, null, cb);\n }\n\n /**\n * Create a new release\n * @see https://developer.github.com/v3/repos/releases/#create-a-release\n * @param {Object} options - the description of the release\n * @param {Requestable.callback} cb - will receive the newly created release\n * @return {Promise} - the promise for the http request\n */\n createRelease(options, cb) {\n return this._request('POST', `/repos/${this.__fullname}/releases`, options, cb);\n }\n\n /**\n * Edit a release\n * @see https://developer.github.com/v3/repos/releases/#edit-a-release\n * @param {string} id - the id of the release\n * @param {Object} options - the description of the release\n * @param {Requestable.callback} cb - will receive the modified release\n * @return {Promise} - the promise for the http request\n */\n updateRelease(id, options, cb) {\n return this._request('PATCH', `/repos/${this.__fullname}/releases/${id}`, options, cb);\n }\n\n /**\n * Get information about all releases\n * @see https://developer.github.com/v3/repos/releases/#list-releases-for-a-repository\n * @param {Requestable.callback} cb - will receive the release information\n * @return {Promise} - the promise for the http request\n */\n listReleases(cb) {\n return this._request('GET', `/repos/${this.__fullname}/releases`, null, cb);\n }\n\n /**\n * Get information about a release\n * @see https://developer.github.com/v3/repos/releases/#get-a-single-release\n * @param {string} id - the id of the release\n * @param {Requestable.callback} cb - will receive the release information\n * @return {Promise} - the promise for the http request\n */\n getRelease(id, cb) {\n return this._request('GET', `/repos/${this.__fullname}/releases/${id}`, null, cb);\n }\n\n /**\n * Delete a release\n * @see https://developer.github.com/v3/repos/releases/#delete-a-release\n * @param {string} id - the release to be deleted\n * @param {Requestable.callback} cb - will receive true if the operation is successful\n * @return {Promise} - the promise for the http request\n */\n deleteRelease(id, cb) {\n return this._request('DELETE', `/repos/${this.__fullname}/releases/${id}`, null, cb);\n }\n\n /**\n * Merge a pull request\n * @see https://developer.github.com/v3/pulls/#merge-a-pull-request-merge-button\n * @param {number|string} number - the number of the pull request to merge\n * @param {Object} options - the merge options for the pull request\n * @param {Requestable.callback} [cb] - will receive the merge information if the operation is successful\n * @return {Promise} - the promise for the http request\n */\n mergePullRequest(number, options, cb) {\n return this._request('PUT', `/repos/${this.__fullname}/pulls/${number}/merge`, options, cb);\n }\n\n /**\n * Get information about all projects\n * @see https://developer.github.com/v3/projects/#list-repository-projects\n * @param {Requestable.callback} [cb] - will receive the list of projects\n * @return {Promise} - the promise for the http request\n */\n listProjects(cb) {\n return this._requestAllPages(`/repos/${this.__fullname}/projects`, {AcceptHeader: 'inertia-preview'}, cb);\n }\n\n /**\n * Create a new project\n * @see https://developer.github.com/v3/projects/#create-a-repository-project\n * @param {Object} options - the description of the project\n * @param {Requestable.callback} cb - will receive the newly created project\n * @return {Promise} - the promise for the http request\n */\n createProject(options, cb) {\n options = options || {};\n options.AcceptHeader = 'inertia-preview';\n return this._request('POST', `/repos/${this.__fullname}/projects`, options, cb);\n }\n\n}\n\nmodule.exports = Repository;\n","/**\n * @file\n * @copyright 2016 Yahoo Inc.\n * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n * Github.js is freely distributable.\n */\n\nimport axios from 'axios';\nimport debug from 'debug';\nimport {Base64} from 'js-base64';\n\nconst log = debug('github:request');\n\n/**\n * The error structure returned when a network call fails\n */\nclass ResponseError extends Error {\n /**\n * Construct a new ResponseError\n * @param {string} message - an message to return instead of the the default error message\n * @param {string} path - the requested path\n * @param {Object} response - the object returned by Axios\n */\n constructor(message, path, response) {\n super(message);\n this.path = path;\n this.request = response.config;\n this.response = (response || {}).response || response;\n this.status = response.status;\n }\n}\n\n/**\n * Requestable wraps the logic for making http requests to the API\n */\nclass Requestable {\n /**\n * Either a username and password or an oauth token for Github\n * @typedef {Object} Requestable.auth\n * @prop {string} [username] - the Github username\n * @prop {string} [password] - the user's password\n * @prop {token} [token] - an OAuth token\n */\n /**\n * Initialize the http internals.\n * @param {Requestable.auth} [auth] - the credentials to authenticate to Github. If auth is\n * not provided request will be made unauthenticated\n * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n * @param {string} [AcceptHeader=v3] - the accept header for the requests\n */\n constructor(auth, apiBase, AcceptHeader) {\n this.__apiBase = apiBase || 'https://api.github.com';\n this.__auth = {\n token: auth.token,\n username: auth.username,\n password: auth.password,\n };\n this.__AcceptHeader = AcceptHeader || 'v3';\n\n if (auth.token) {\n this.__authorizationHeader = 'token ' + auth.token;\n } else if (auth.username && auth.password) {\n this.__authorizationHeader = 'Basic ' + Base64.encode(auth.username + ':' + auth.password);\n }\n }\n\n /**\n * Compute the URL to use to make a request.\n * @private\n * @param {string} path - either a URL relative to the API base or an absolute URL\n * @return {string} - the URL to use\n */\n __getURL(path) {\n let url = path;\n\n if (path.indexOf('//') === -1) {\n url = this.__apiBase + path;\n }\n\n let newCacheBuster = 'timestamp=' + new Date().getTime();\n return url.replace(/(timestamp=\\d+)/, newCacheBuster);\n }\n\n /**\n * Compute the headers required for an API request.\n * @private\n * @param {boolean} raw - if the request should be treated as JSON or as a raw request\n * @param {string} AcceptHeader - the accept header for the request\n * @return {Object} - the headers to use in the request\n */\n __getRequestHeaders(raw, AcceptHeader) {\n let headers = {\n 'Content-Type': 'application/json;charset=UTF-8',\n 'Accept': 'application/vnd.github.' + (AcceptHeader || this.__AcceptHeader),\n };\n\n if (raw) {\n headers.Accept += '.raw';\n }\n headers.Accept += '+json';\n\n if (this.__authorizationHeader) {\n headers.Authorization = this.__authorizationHeader;\n }\n\n return headers;\n }\n\n /**\n * Sets the default options for API requests\n * @protected\n * @param {Object} [requestOptions={}] - the current options for the request\n * @return {Object} - the options to pass to the request\n */\n _getOptionsWithDefaults(requestOptions = {}) {\n if (!(requestOptions.visibility || requestOptions.affiliation)) {\n requestOptions.type = requestOptions.type || 'all';\n }\n requestOptions.sort = requestOptions.sort || 'updated';\n requestOptions.per_page = requestOptions.per_page || '100'; // eslint-disable-line\n\n return requestOptions;\n }\n\n /**\n * if a `Date` is passed to this function it will be converted to an ISO string\n * @param {*} date - the object to attempt to cooerce into an ISO date string\n * @return {string} - the ISO representation of `date` or whatever was passed in if it was not a date\n */\n _dateToISO(date) {\n if (date && (date instanceof Date)) {\n date = date.toISOString();\n }\n\n return date;\n }\n\n /**\n * A function that receives the result of the API request.\n * @callback Requestable.callback\n * @param {Requestable.Error} error - the error returned by the API or `null`\n * @param {(Object|true)} result - the data returned by the API or `true` if the API returns `204 No Content`\n * @param {Object} request - the raw {@linkcode https://github.com/mzabriskie/axios#response-schema Response}\n */\n /**\n * Make a request.\n * @param {string} method - the method for the request (GET, PUT, POST, DELETE)\n * @param {string} path - the path for the request\n * @param {*} [data] - the data to send to the server. For HTTP methods that don't have a body the data\n * will be sent as query parameters\n * @param {Requestable.callback} [cb] - the callback for the request\n * @param {boolean} [raw=false] - if the request should be sent as raw. If this is a falsy value then the\n * request will be made as JSON\n * @return {Promise} - the Promise for the http request\n */\n _request(method, path, data, cb, raw) {\n const url = this.__getURL(path);\n\n const AcceptHeader = (data || {}).AcceptHeader;\n if (AcceptHeader) {\n delete data.AcceptHeader;\n }\n const headers = this.__getRequestHeaders(raw, AcceptHeader);\n\n let queryParams = {};\n\n const shouldUseDataAsParams = data && (typeof data === 'object') && methodHasNoBody(method);\n if (shouldUseDataAsParams) {\n queryParams = data;\n data = undefined;\n }\n\n const config = {\n url: url,\n method: method,\n headers: headers,\n params: queryParams,\n data: data,\n responseType: raw ? 'text' : 'json',\n };\n\n log(`${config.method} to ${config.url}`);\n const requestPromise = axios(config).catch(callbackErrorOrThrow(cb, path));\n\n if (cb) {\n requestPromise.then((response) => {\n if (response.data && Object.keys(response.data).length > 0) {\n // When data has results\n cb(null, response.data, response);\n } else if (config.method !== 'GET' && Object.keys(response.data).length < 1) {\n // True when successful submit a request and receive a empty object\n cb(null, (response.status < 300), response);\n } else {\n cb(null, response.data, response);\n }\n });\n }\n\n return requestPromise;\n }\n\n /**\n * Make a request to an endpoint the returns 204 when true and 404 when false\n * @param {string} path - the path to request\n * @param {Object} data - any query parameters for the request\n * @param {Requestable.callback} cb - the callback that will receive `true` or `false`\n * @param {method} [method=GET] - HTTP Method to use\n * @return {Promise} - the promise for the http request\n */\n _request204or404(path, data, cb, method = 'GET') {\n return this._request(method, path, data)\n .then(function success(response) {\n if (cb) {\n cb(null, true, response);\n }\n return true;\n }, function failure(response) {\n if (response.response.status === 404) {\n if (cb) {\n cb(null, false, response);\n }\n return false;\n }\n\n if (cb) {\n cb(response);\n }\n throw response;\n });\n }\n\n /**\n * Make a request and fetch all the available data. Github will paginate responses so for queries\n * that might span multiple pages this method is preferred to {@link Requestable#request}\n * @param {string} path - the path to request\n * @param {Object} options - the query parameters to include\n * @param {Requestable.callback} [cb] - the function to receive the data. The returned data will always be an array.\n * @param {Object[]} results - the partial results. This argument is intended for interal use only.\n * @return {Promise} - a promise which will resolve when all pages have been fetched\n * @deprecated This will be folded into {@link Requestable#_request} in the 2.0 release.\n */\n _requestAllPages(path, options, cb, results) {\n results = results || [];\n\n return this._request('GET', path, options)\n .then((response) => {\n let thisGroup;\n if (response.data instanceof Array) {\n thisGroup = response.data;\n } else if (response.data.items instanceof Array) {\n thisGroup = response.data.items;\n } else {\n let message = `cannot figure out how to append ${response.data} to the result set`;\n throw new ResponseError(message, path, response);\n }\n results.push(...thisGroup);\n\n const nextUrl = getNextPage(response.headers.link);\n if (nextUrl && typeof options.page !== 'number') {\n log(`getting next page: ${nextUrl}`);\n return this._requestAllPages(nextUrl, options, cb, results);\n }\n\n if (cb) {\n cb(null, results, response);\n }\n\n response.data = results;\n return response;\n }).catch(callbackErrorOrThrow(cb, path));\n }\n}\n\nmodule.exports = Requestable;\n\n// ////////////////////////// //\n// Private helper functions //\n// ////////////////////////// //\nconst METHODS_WITH_NO_BODY = ['GET', 'HEAD', 'DELETE'];\nfunction methodHasNoBody(method) {\n return METHODS_WITH_NO_BODY.indexOf(method) !== -1;\n}\n\nfunction getNextPage(linksHeader = '') {\n const links = linksHeader.split(/\\s*,\\s*/); // splits and strips the urls\n return links.reduce(function(nextUrl, link) {\n if (link.search(/rel=\"next\"/) !== -1) {\n return (link.match(/<(.*)>/) || [])[1];\n }\n\n return nextUrl;\n }, undefined);\n}\n\nfunction callbackErrorOrThrow(cb, path) {\n return function handler(object) {\n let error;\n if (object.hasOwnProperty('config')) {\n const {response: {status, statusText}, config: {method, url}} = object;\n let message = (`${status} error making request ${method} ${url}: \"${statusText}\"`);\n error = new ResponseError(message, path, object);\n log(`${message} ${JSON.stringify(object.data)}`);\n } else {\n error = object;\n }\n if (cb) {\n log('going to error callback');\n cb(error);\n } else {\n log('throwing error');\n throw error;\n }\n };\n}\n","/**\n * @file\n * @copyright 2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n * Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\nimport debug from 'debug';\nconst log = debug('github:search');\n\n/**\n * Wrap the Search API\n */\nclass Search extends Requestable {\n /**\n * Create a Search\n * @param {Object} defaults - defaults for the search\n * @param {Requestable.auth} [auth] - information required to authenticate to Github\n * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n */\n constructor(defaults, auth, apiBase) {\n super(auth, apiBase);\n this.__defaults = this._getOptionsWithDefaults(defaults);\n }\n\n /**\n * Available search options\n * @see https://developer.github.com/v3/search/#parameters\n * @typedef {Object} Search.Params\n * @param {string} q - the query to make\n * @param {string} sort - the sort field, one of `stars`, `forks`, or `updated`.\n * Default is [best match](https://developer.github.com/v3/search/#ranking-search-results)\n * @param {string} order - the ordering, either `asc` or `desc`\n */\n /**\n * Perform a search on the GitHub API\n * @private\n * @param {string} path - the scope of the search\n * @param {Search.Params} [withOptions] - additional parameters for the search\n * @param {Requestable.callback} [cb] - will receive the results of the search\n * @return {Promise} - the promise for the http request\n */\n _search(path, withOptions = {}, cb = undefined) {\n let requestOptions = {};\n Object.keys(this.__defaults).forEach((prop) => {\n requestOptions[prop] = this.__defaults[prop];\n });\n Object.keys(withOptions).forEach((prop) => {\n requestOptions[prop] = withOptions[prop];\n });\n\n log(`searching ${path} with options:`, requestOptions);\n return this._requestAllPages(`/search/${path}`, requestOptions, cb);\n }\n\n /**\n * Search for repositories\n * @see https://developer.github.com/v3/search/#search-repositories\n * @param {Search.Params} [options] - additional parameters for the search\n * @param {Requestable.callback} [cb] - will receive the results of the search\n * @return {Promise} - the promise for the http request\n */\n forRepositories(options, cb) {\n return this._search('repositories', options, cb);\n }\n\n /**\n * Search for code\n * @see https://developer.github.com/v3/search/#search-code\n * @param {Search.Params} [options] - additional parameters for the search\n * @param {Requestable.callback} [cb] - will receive the results of the search\n * @return {Promise} - the promise for the http request\n */\n forCode(options, cb) {\n return this._search('code', options, cb);\n }\n\n /**\n * Search for issues\n * @see https://developer.github.com/v3/search/#search-issues\n * @param {Search.Params} [options] - additional parameters for the search\n * @param {Requestable.callback} [cb] - will receive the results of the search\n * @return {Promise} - the promise for the http request\n */\n forIssues(options, cb) {\n return this._search('issues', options, cb);\n }\n\n /**\n * Search for users\n * @see https://developer.github.com/v3/search/#search-users\n * @param {Search.Params} [options] - additional parameters for the search\n * @param {Requestable.callback} [cb] - will receive the results of the search\n * @return {Promise} - the promise for the http request\n */\n forUsers(options, cb) {\n return this._search('users', options, cb);\n }\n}\n\nmodule.exports = Search;\n","/**\n * @file\n * @copyright 2016 Matt Smith (Development Seed)\n * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n * Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\nimport debug from 'debug';\nconst log = debug('github:team');\n\n/**\n * A Team allows scoping of API requests to a particular Github Organization Team.\n */\nclass Team extends Requestable {\n /**\n * Create a Team.\n * @param {string} [teamId] - the id for the team\n * @param {Requestable.auth} [auth] - information required to authenticate to Github\n * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n */\n constructor(teamId, auth, apiBase) {\n super(auth, apiBase);\n this.__teamId = teamId;\n }\n\n /**\n * Get Team information\n * @see https://developer.github.com/v3/orgs/teams/#get-team\n * @param {Requestable.callback} [cb] - will receive the team\n * @return {Promise} - the promise for the http request\n */\n getTeam(cb) {\n log(`Fetching Team ${this.__teamId}`);\n return this._request('Get', `/teams/${this.__teamId}`, undefined, cb);\n }\n\n /**\n * List the Team's repositories\n * @see https://developer.github.com/v3/orgs/teams/#list-team-repos\n * @param {Requestable.callback} [cb] - will receive the list of repositories\n * @return {Promise} - the promise for the http request\n */\n listRepos(cb) {\n log(`Fetching repositories for Team ${this.__teamId}`);\n return this._requestAllPages(`/teams/${this.__teamId}/repos`, undefined, cb);\n }\n\n /**\n * Edit Team information\n * @see https://developer.github.com/v3/orgs/teams/#edit-team\n * @param {object} options - Parameters for team edit\n * @param {string} options.name - The name of the team\n * @param {string} [options.description] - Team description\n * @param {string} [options.repo_names] - Repos to add the team to\n * @param {string} [options.privacy=secret] - The level of privacy the team should have. Can be either one\n * of: `secret`, or `closed`\n * @param {Requestable.callback} [cb] - will receive the updated team\n * @return {Promise} - the promise for the http request\n */\n editTeam(options, cb) {\n log(`Editing Team ${this.__teamId}`);\n return this._request('PATCH', `/teams/${this.__teamId}`, options, cb);\n }\n\n /**\n * List the users who are members of the Team\n * @see https://developer.github.com/v3/orgs/teams/#list-team-members\n * @param {object} options - Parameters for listing team users\n * @param {string} [options.role=all] - can be one of: `all`, `maintainer`, or `member`\n * @param {Requestable.callback} [cb] - will receive the list of users\n * @return {Promise} - the promise for the http request\n */\n listMembers(options, cb) {\n log(`Getting members of Team ${this.__teamId}`);\n return this._requestAllPages(`/teams/${this.__teamId}/members`, options, cb);\n }\n\n /**\n * Get Team membership status for a user\n * @see https://developer.github.com/v3/orgs/teams/#get-team-membership\n * @param {string} username - can be one of: `all`, `maintainer`, or `member`\n * @param {Requestable.callback} [cb] - will receive the membership status of a user\n * @return {Promise} - the promise for the http request\n */\n getMembership(username, cb) {\n log(`Getting membership of user ${username} in Team ${this.__teamId}`);\n return this._request('GET', `/teams/${this.__teamId}/memberships/${username}`, undefined, cb);\n }\n\n /**\n * Add a member to the Team\n * @see https://developer.github.com/v3/orgs/teams/#add-team-membership\n * @param {string} username - can be one of: `all`, `maintainer`, or `member`\n * @param {object} options - Parameters for adding a team member\n * @param {string} [options.role=member] - The role that this user should have in the team. Can be one\n * of: `member`, or `maintainer`\n * @param {Requestable.callback} [cb] - will receive the membership status of added user\n * @return {Promise} - the promise for the http request\n */\n addMembership(username, options, cb) {\n log(`Adding user ${username} to Team ${this.__teamId}`);\n return this._request('PUT', `/teams/${this.__teamId}/memberships/${username}`, options, cb);\n }\n\n /**\n * Get repo management status for team\n * @see https://developer.github.com/v3/orgs/teams/#remove-team-membership\n * @param {string} owner - Organization name\n * @param {string} repo - Repo name\n * @param {Requestable.callback} [cb] - will receive the membership status of added user\n * @return {Promise} - the promise for the http request\n */\n isManagedRepo(owner, repo, cb) {\n log(`Getting repo management by Team ${this.__teamId} for repo ${owner}/${repo}`);\n return this._request204or404(`/teams/${this.__teamId}/repos/${owner}/${repo}`, undefined, cb);\n }\n\n /**\n * Add or Update repo management status for team\n * @see https://developer.github.com/v3/orgs/teams/#add-or-update-team-repository\n * @param {string} owner - Organization name\n * @param {string} repo - Repo name\n * @param {object} options - Parameters for adding or updating repo management for the team\n * @param {string} [options.permission] - The permission to grant the team on this repository. Can be one\n * of: `pull`, `push`, or `admin`\n * @param {Requestable.callback} [cb] - will receive the membership status of added user\n * @return {Promise} - the promise for the http request\n */\n manageRepo(owner, repo, options, cb) {\n log(`Adding or Updating repo management by Team ${this.__teamId} for repo ${owner}/${repo}`);\n return this._request204or404(`/teams/${this.__teamId}/repos/${owner}/${repo}`, options, cb, 'PUT');\n }\n\n /**\n * Remove repo management status for team\n * @see https://developer.github.com/v3/orgs/teams/#remove-team-repository\n * @param {string} owner - Organization name\n * @param {string} repo - Repo name\n * @param {Requestable.callback} [cb] - will receive the membership status of added user\n * @return {Promise} - the promise for the http request\n */\n unmanageRepo(owner, repo, cb) {\n log(`Remove repo management by Team ${this.__teamId} for repo ${owner}/${repo}`);\n return this._request204or404(`/teams/${this.__teamId}/repos/${owner}/${repo}`, undefined, cb, 'DELETE');\n }\n\n /**\n * Delete Team\n * @see https://developer.github.com/v3/orgs/teams/#delete-team\n * @param {Requestable.callback} [cb] - will receive the list of repositories\n * @return {Promise} - the promise for the http request\n */\n deleteTeam(cb) {\n log(`Deleting Team ${this.__teamId}`);\n return this._request204or404(`/teams/${this.__teamId}`, undefined, cb, 'DELETE');\n }\n}\n\nmodule.exports = Team;\n","/**\n * @file\n * @copyright 2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n * Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\nimport debug from 'debug';\nconst log = debug('github:user');\n\n/**\n * A User allows scoping of API requests to a particular Github user.\n */\nclass User extends Requestable {\n /**\n * Create a User.\n * @param {string} [username] - the user to use for user-scoped queries\n * @param {Requestable.auth} [auth] - information required to authenticate to Github\n * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n */\n constructor(username, auth, apiBase) {\n super(auth, apiBase);\n this.__user = username;\n }\n\n /**\n * Get the url for the request. (dependent on if we're requesting for the authenticated user or not)\n * @private\n * @param {string} endpoint - the endpoint being requested\n * @return {string} - the resolved endpoint\n */\n __getScopedUrl(endpoint) {\n if (this.__user) {\n return endpoint ?\n `/users/${this.__user}/${endpoint}` :\n `/users/${this.__user}`\n ;\n\n } else { // eslint-disable-line\n switch (endpoint) {\n case '':\n return '/user';\n\n case 'notifications':\n case 'gists':\n return `/${endpoint}`;\n\n default:\n return `/user/${endpoint}`;\n }\n }\n }\n\n /**\n * List the user's repositories\n * @see https://developer.github.com/v3/repos/#list-user-repositories\n * @param {Object} [options={}] - any options to refine the search\n * @param {Requestable.callback} [cb] - will receive the list of repositories\n * @return {Promise} - the promise for the http request\n */\n listRepos(options, cb) {\n if (typeof options === 'function') {\n cb = options;\n options = {};\n }\n\n options = this._getOptionsWithDefaults(options);\n\n log(`Fetching repositories with options: ${JSON.stringify(options)}`);\n return this._requestAllPages(this.__getScopedUrl('repos'), options, cb);\n }\n\n /**\n * List the orgs that the user belongs to\n * @see https://developer.github.com/v3/orgs/#list-user-organizations\n * @param {Requestable.callback} [cb] - will receive the list of organizations\n * @return {Promise} - the promise for the http request\n */\n listOrgs(cb) {\n return this._request('GET', this.__getScopedUrl('orgs'), null, cb);\n }\n\n /**\n * List the user's gists\n * @see https://developer.github.com/v3/gists/#list-a-users-gists\n * @param {Requestable.callback} [cb] - will receive the list of gists\n * @return {Promise} - the promise for the http request\n */\n listGists(cb) {\n return this._request('GET', this.__getScopedUrl('gists'), null, cb);\n }\n\n /**\n * List the user's starred gists\n * @see https://developer.github.com/v3/gists/#list-starred-gists\n * @param {Requestable.callback} [cb] - will receive the list of gists\n * @return {Promise} - the promise for the http request\n */\n listStarredGists(cb) {\n return this._request('GET', this.__getScopedUrl('gists/starred'), null, cb);\n }\n\n /**\n * List the user's gists\n * @see https://developer.github.com/v3/gists/#list-a-users-gists\n * @param {Requestable.callback} [cb] - will receive the list of gists\n * @return {Promise} - the promise for the http request\n */\n listStarredGists(cb) {\n return this._request('GET', this.__getScopedUrl('gists'), null, cb);\n }\n\n /**\n * List the user's notifications\n * @see https://developer.github.com/v3/activity/notifications/#list-your-notifications\n * @param {Object} [options={}] - any options to refine the search\n * @param {Requestable.callback} [cb] - will receive the list of repositories\n * @return {Promise} - the promise for the http request\n */\n listNotifications(options, cb) {\n options = options || {};\n if (typeof options === 'function') {\n cb = options;\n options = {};\n }\n\n options.since = this._dateToISO(options.since);\n options.before = this._dateToISO(options.before);\n\n return this._request('GET', this.__getScopedUrl('notifications'), options, cb);\n }\n\n /**\n * Show the user's profile\n * @see https://developer.github.com/v3/users/#get-a-single-user\n * @param {Requestable.callback} [cb] - will receive the user's information\n * @return {Promise} - the promise for the http request\n */\n getProfile(cb) {\n return this._request('GET', this.__getScopedUrl(''), null, cb);\n }\n\n /**\n * Gets the list of starred repositories for the user\n * @see https://developer.github.com/v3/activity/starring/#list-repositories-being-starred\n * @param {Requestable.callback} [cb] - will receive the list of starred repositories\n * @return {Promise} - the promise for the http request\n */\n listStarredRepos(cb) {\n let requestOptions = this._getOptionsWithDefaults();\n return this._requestAllPages(this.__getScopedUrl('starred'), requestOptions, cb);\n }\n\n /**\n * List email addresses for a user\n * @see https://developer.github.com/v3/users/emails/#list-email-addresses-for-a-user\n * @param {Requestable.callback} [cb] - will receive the list of emails\n * @return {Promise} - the promise for the http request\n */\n getEmails(cb) {\n return this._request('GET', '/user/emails', null, cb);\n }\n\n /**\n * Have the authenticated user follow this user\n * @see https://developer.github.com/v3/users/followers/#follow-a-user\n * @param {string} username - the user to follow\n * @param {Requestable.callback} [cb] - will receive true if the request succeeds\n * @return {Promise} - the promise for the http request\n */\n follow(username, cb) {\n return this._request('PUT', `/user/following/${this.__user}`, null, cb);\n }\n\n /**\n * Have the currently authenticated user unfollow this user\n * @see https://developer.github.com/v3/users/followers/#follow-a-user\n * @param {string} username - the user to unfollow\n * @param {Requestable.callback} [cb] - receives true if the request succeeds\n * @return {Promise} - the promise for the http request\n */\n unfollow(username, cb) {\n return this._request('DELETE', `/user/following/${this.__user}`, null, cb);\n }\n\n /**\n * Create a new repository for the currently authenticated user\n * @see https://developer.github.com/v3/repos/#create\n * @param {object} options - the repository definition\n * @param {Requestable.callback} [cb] - will receive the API response\n * @return {Promise} - the promise for the http request\n */\n createRepo(options, cb) {\n return this._request('POST', '/user/repos', options, cb);\n }\n}\n\nmodule.exports = User;\n"],"preExistingComment":"//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["node_modules/browser-pack/_prelude.js","lib/Gist.js","lib/GitHub.js","lib/Issue.js","lib/Markdown.js","lib/Organization.js","lib/Project.js","lib/RateLimit.js","lib/Repository.js","lib/Requestable.js","lib/Search.js","lib/Team.js","lib/User.js"],"names":[],"mappings":"AAAA;;;;;ACOA;;;;;;;;;;+eAPA;;;;;;;AASA;;;IAGM,I;;;AACH;;;;;;AAMA,gBAAY,EAAZ,EAAgB,IAAhB,EAAsB,OAAtB,EAA+B;AAAA;;AAAA,4GACtB,IADsB,EAChB,OADgB;;AAE5B,UAAK,IAAL,GAAY,EAAZ;AAF4B;AAG9B;;AAED;;;;;;;;;;yBAMK,E,EAAI;AACN,aAAO,KAAK,QAAL,CAAc,KAAd,cAA+B,KAAK,IAApC,EAA4C,IAA5C,EAAkD,EAAlD,CAAP;AACF;;AAED;;;;;;;;;;2BAOO,I,EAAM,E,EAAI;AAAA;;AACd,aAAO,KAAK,QAAL,CAAc,MAAd,EAAsB,QAAtB,EAAgC,IAAhC,EAAsC,EAAtC,EACH,IADG,CACE,UAAC,QAAD,EAAc;AACjB,eAAK,IAAL,GAAY,SAAS,IAAT,CAAc,EAA1B;AACA,eAAO,QAAP;AACF,OAJG,CAAP;AAKF;;AAED;;;;;;;;;4BAMO,E,EAAI;AACR,aAAO,KAAK,QAAL,CAAc,QAAd,cAAkC,KAAK,IAAvC,EAA+C,IAA/C,EAAqD,EAArD,CAAP;AACF;;AAED;;;;;;;;;yBAMK,E,EAAI;AACN,aAAO,KAAK,QAAL,CAAc,MAAd,cAAgC,KAAK,IAArC,aAAmD,IAAnD,EAAyD,EAAzD,CAAP;AACF;;AAED;;;;;;;;;;2BAOO,I,EAAM,E,EAAI;AACd,aAAO,KAAK,QAAL,CAAc,OAAd,cAAiC,KAAK,IAAtC,EAA8C,IAA9C,EAAoD,EAApD,CAAP;AACF;;AAED;;;;;;;;;yBAMK,E,EAAI;AACN,aAAO,KAAK,QAAL,CAAc,KAAd,cAA+B,KAAK,IAApC,YAAiD,IAAjD,EAAuD,EAAvD,CAAP;AACF;;AAED;;;;;;;;;2BAMO,E,EAAI;AACR,aAAO,KAAK,QAAL,CAAc,QAAd,cAAkC,KAAK,IAAvC,YAAoD,IAApD,EAA0D,EAA1D,CAAP;AACF;;AAED;;;;;;;;;8BAMU,E,EAAI;AACX,aAAO,KAAK,gBAAL,aAAgC,KAAK,IAArC,YAAkD,IAAlD,EAAwD,EAAxD,CAAP;AACF;;AAED;;;;;;;;;gCAMY,E,EAAI;AACb,aAAO,KAAK,gBAAL,aAAgC,KAAK,IAArC,eAAqD,IAArD,EAA2D,EAA3D,CAAP;AACF;;AAED;;;;;;;;;;gCAOY,Q,EAAU,E,EAAI;AACvB,aAAO,KAAK,QAAL,CAAc,KAAd,cAA+B,KAAK,IAApC,SAA4C,QAA5C,EAAwD,IAAxD,EAA8D,EAA9D,CAAP;AACF;;AAED;;;;;;;;;iCAMa,E,EAAI;AACd,aAAO,KAAK,gBAAL,aAAgC,KAAK,IAArC,gBAAsD,IAAtD,EAA4D,EAA5D,CAAP;AACF;;AAED;;;;;;;;;;+BAOW,O,EAAS,E,EAAI;AACrB,aAAO,KAAK,QAAL,CAAc,KAAd,cAA+B,KAAK,IAApC,kBAAqD,OAArD,EAAgE,IAAhE,EAAsE,EAAtE,CAAP;AACF;;AAED;;;;;;;;;;kCAOc,O,EAAS,E,EAAI;AACxB,aAAO,KAAK,QAAL,CAAc,MAAd,cAAgC,KAAK,IAArC,gBAAsD,EAAC,MAAM,OAAP,EAAtD,EAAuE,EAAvE,CAAP;AACF;;AAED;;;;;;;;;;;gCAQY,O,EAAS,I,EAAM,E,EAAI;AAC5B,aAAO,KAAK,QAAL,CAAc,OAAd,cAAiC,KAAK,IAAtC,kBAAuD,OAAvD,EAAkE,EAAC,MAAM,IAAP,EAAlE,EAAgF,EAAhF,CAAP;AACF;;AAED;;;;;;;;;;kCAOc,O,EAAS,E,EAAI;AACxB,aAAO,KAAK,QAAL,CAAc,QAAd,cAAkC,KAAK,IAAvC,kBAAwD,OAAxD,EAAmE,IAAnE,EAAyE,EAAzE,CAAP;AACF;;;;;;AAGJ,OAAO,OAAP,GAAiB,IAAjB;;;;;qjBC3LA;;;;;;AAMA;;AAEA;;;;AACA;;;;AACA;;;;AACA;;;;AACA;;;;AACA;;;;AACA;;;;AACA;;;;AACA;;;;AACA;;;;;;;;AAEA;;;IAGM,M;AACH;;;;;;AAMA,kBAAY,IAAZ,EAAsD;AAAA,QAApC,OAAoC,uEAA1B,wBAA0B;;AAAA;;AACnD,SAAK,SAAL,GAAiB,OAAjB;AACA,SAAK,MAAL,GAAc,QAAQ,EAAtB;AACF;;AAED;;;;;;;;;4BAKQ,E,EAAI;AACT,aAAO,mBAAS,EAAT,EAAa,KAAK,MAAlB,EAA0B,KAAK,SAA/B,CAAP;AACF;;AAED;;;;;;;;;4BAMQ,I,EAAM;AACX,aAAO,mBAAS,IAAT,EAAe,KAAK,MAApB,EAA4B,KAAK,SAAjC,CAAP;AACF;;AAED;;;;;;;;oCAKgB,Y,EAAc;AAC3B,aAAO,2BAAiB,YAAjB,EAA+B,KAAK,MAApC,EAA4C,KAAK,SAAjD,CAAP;AACF;;AAED;;;;;;;;4BAKQ,M,EAAQ;AACb,aAAO,mBAAS,MAAT,EAAiB,KAAK,MAAtB,EAA8B,KAAK,SAAnC,CAAP;AACF;;AAED;;;;;;;;;4BAMQ,I,EAAM,I,EAAM;AACjB,aAAO,yBAAe,KAAK,YAAL,CAAkB,IAAlB,EAAwB,IAAxB,CAAf,EAA8C,KAAK,MAAnD,EAA2D,KAAK,SAAhE,CAAP;AACF;;AAED;;;;;;;;;8BAMU,I,EAAM,I,EAAM;AACnB,aAAO,oBAAU,KAAK,YAAL,CAAkB,IAAlB,EAAwB,IAAxB,CAAV,EAAyC,KAAK,MAA9C,EAAsD,KAAK,SAA3D,CAAP;AACF;;AAED;;;;;;;;2BAKO,K,EAAO;AACX,aAAO,qBAAW,KAAX,EAAkB,KAAK,MAAvB,EAA+B,KAAK,SAApC,CAAP;AACF;;AAED;;;;;;;mCAIe;AACZ,aAAO,wBAAc,KAAK,MAAnB,EAA2B,KAAK,SAAhC,CAAP;AACF;;AAED;;;;;;;kCAIc;AACX,aAAO,uBAAa,KAAK,MAAlB,EAA0B,KAAK,SAA/B,CAAP;AACF;;AAED;;;;;;;;+BAKW,E,EAAI;AACZ,aAAO,sBAAY,EAAZ,EAAgB,KAAK,MAArB,EAA6B,KAAK,SAAlC,CAAP;AACF;;AAED;;;;;;;;;iCAMa,I,EAAM,I,EAAM;AACtB,UAAI,WAAW,IAAf;;AAEA,UAAI,IAAJ,EAAU;AACP,mBAAc,IAAd,SAAsB,IAAtB;AACF;;AAED,aAAO,QAAP;AACF;;;;;;AAGJ,OAAO,OAAP,GAAiB,MAAjB;;;;;;;ACvIA;;;;;;;;;;+eAPA;;;;;;;AASA;;;IAGM,K;;;AACH;;;;;;AAMA,iBAAY,UAAZ,EAAwB,IAAxB,EAA8B,OAA9B,EAAuC;AAAA;;AAAA,8GAC9B,IAD8B,EACxB,OADwB;;AAEpC,UAAK,YAAL,GAAoB,UAApB;AAFoC;AAGtC;;AAED;;;;;;;;;;;gCAOY,S,EAAW,E,EAAI;AACxB,aAAO,KAAK,QAAL,CAAc,MAAd,cAAgC,KAAK,YAArC,cAA4D,SAA5D,EAAuE,EAAvE,CAAP;AACF;;AAED;;;;;;;;;;+BAOW,O,EAAS,E,EAAI;AACrB,aAAO,KAAK,gBAAL,aAAgC,KAAK,YAArC,cAA4D,OAA5D,EAAqE,EAArE,CAAP;AACF;;AAED;;;;;;;;;;oCAOgB,K,EAAO,E,EAAI;AACxB,aAAO,KAAK,QAAL,CAAc,KAAd,cAA+B,KAAK,YAApC,gBAA2D,KAA3D,cAA2E,IAA3E,EAAiF,EAAjF,CAAP;AACF;;AAED;;;;;;;;;;sCAOkB,K,EAAO,E,EAAI;AAC1B,aAAO,KAAK,QAAL,CAAc,KAAd,cAA+B,KAAK,YAApC,gBAA2D,KAA3D,gBAA6E,IAA7E,EAAmF,EAAnF,CAAP;AACF;;AAED;;;;;;;;;;oCAOgB,E,EAAI,E,EAAI;AACrB,aAAO,KAAK,QAAL,CAAc,KAAd,cAA+B,KAAK,YAApC,yBAAoE,EAApE,EAA0E,IAA1E,EAAgF,EAAhF,CAAP;AACF;;AAED;;;;;;;;;;;uCAQmB,K,EAAO,O,EAAS,E,EAAI;AACpC,aAAO,KAAK,QAAL,CAAc,MAAd,cAAgC,KAAK,YAArC,gBAA4D,KAA5D,gBAA8E,EAAC,MAAM,OAAP,EAA9E,EAA+F,EAA/F,CAAP;AACF;;AAED;;;;;;;;;;;qCAQiB,E,EAAI,O,EAAS,E,EAAI;AAC/B,aAAO,KAAK,QAAL,CAAc,OAAd,cAAiC,KAAK,YAAtC,yBAAsE,EAAtE,EAA4E,EAAC,MAAM,OAAP,EAA5E,EAA6F,EAA7F,CAAP;AACF;;AAED;;;;;;;;;;uCAOmB,E,EAAI,E,EAAI;AACxB,aAAO,KAAK,QAAL,CAAc,QAAd,cAAkC,KAAK,YAAvC,yBAAuE,EAAvE,EAA6E,IAA7E,EAAmF,EAAnF,CAAP;AACF;;AAED;;;;;;;;;;;8BAQU,K,EAAO,S,EAAW,E,EAAI;AAC7B,aAAO,KAAK,QAAL,CAAc,OAAd,cAAiC,KAAK,YAAtC,gBAA6D,KAA7D,EAAsE,SAAtE,EAAiF,EAAjF,CAAP;AACF;;AAED;;;;;;;;;;6BAOS,K,EAAO,E,EAAI;AACjB,aAAO,KAAK,QAAL,CAAc,KAAd,cAA+B,KAAK,YAApC,gBAA2D,KAA3D,EAAoE,IAApE,EAA0E,EAA1E,CAAP;AACF;;AAED;;;;;;;;;;mCAOe,O,EAAS,E,EAAI;AACzB,aAAO,KAAK,QAAL,CAAc,KAAd,cAA+B,KAAK,YAApC,kBAA+D,OAA/D,EAAwE,EAAxE,CAAP;AACF;;AAED;;;;;;;;;;iCAOa,S,EAAW,E,EAAI;AACzB,aAAO,KAAK,QAAL,CAAc,KAAd,cAA+B,KAAK,YAApC,oBAA+D,SAA/D,EAA4E,IAA5E,EAAkF,EAAlF,CAAP;AACF;;AAED;;;;;;;;;;oCAOgB,a,EAAe,E,EAAI;AAChC,aAAO,KAAK,QAAL,CAAc,MAAd,cAAgC,KAAK,YAArC,kBAAgE,aAAhE,EAA+E,EAA/E,CAAP;AACF;;AAED;;;;;;;;;;;kCAQc,S,EAAW,a,EAAe,E,EAAI;AACzC,aAAO,KAAK,QAAL,CAAc,OAAd,cAAiC,KAAK,YAAtC,oBAAiE,SAAjE,EAA8E,aAA9E,EAA6F,EAA7F,CAAP;AACF;;AAED;;;;;;;;;;oCAOgB,S,EAAW,E,EAAI;AAC5B,aAAO,KAAK,QAAL,CAAc,QAAd,cAAkC,KAAK,YAAvC,oBAAkE,SAAlE,EAA+E,IAA/E,EAAqF,EAArF,CAAP;AACF;;AAED;;;;;;;;;;gCAOY,S,EAAW,E,EAAI;AACxB,aAAO,KAAK,QAAL,CAAc,MAAd,cAAgC,KAAK,YAArC,cAA4D,SAA5D,EAAuE,EAAvE,CAAP;AACF;;AAEF;;;;;;;;;;+BAOY,O,EAAS,E,EAAI;AACrB,aAAO,KAAK,QAAL,CAAc,KAAd,cAA+B,KAAK,YAApC,cAA2D,OAA3D,EAAoE,EAApE,CAAP;AACF;;AAEF;;;;;;;;;;6BAOU,K,EAAO,E,EAAI;AACjB,aAAO,KAAK,QAAL,CAAc,KAAd,cAA+B,KAAK,YAApC,gBAA2D,KAA3D,EAAoE,IAApE,EAA0E,EAA1E,CAAP;AACF;;AAEF;;;;;;;;;;;8BAQW,K,EAAO,S,EAAW,E,EAAI;AAC7B,aAAO,KAAK,QAAL,CAAc,OAAd,cAAiC,KAAK,YAAtC,gBAA6D,KAA7D,EAAsE,SAAtE,EAAiF,EAAjF,CAAP;AACF;;AAEF;;;;;;;;;;gCAOa,K,EAAO,E,EAAI;AACpB,aAAO,KAAK,QAAL,CAAc,QAAd,cAAkC,KAAK,YAAvC,gBAA8D,KAA9D,EAAuE,IAAvE,EAA6E,EAA7E,CAAP;AACF;;;;;;AAGJ,OAAO,OAAP,GAAiB,KAAjB;;;;;;;ACnPA;;;;;;;;;;+eAPA;;;;;;;AASA;;;IAGM,Q;;;AACH;;;;;;AAMA,oBAAY,IAAZ,EAAkB,OAAlB,EAA2B;AAAA;;AAAA,+GAClB,IADkB,EACZ,OADY;AAE1B;;AAED;;;;;;;;;;;;;;2BAUO,O,EAAS,E,EAAI;AACjB,aAAO,KAAK,QAAL,CAAc,MAAd,EAAsB,WAAtB,EAAmC,OAAnC,EAA4C,EAA5C,CAAP;AACF;;;;;;AAGJ,OAAO,OAAP,GAAiB,QAAjB;;;;;;;AC/BA;;;;;;;;;;+eAPA;;;;;;;AASA;;;IAGM,Y;;;AACH;;;;;;AAMA,wBAAY,YAAZ,EAA0B,IAA1B,EAAgC,OAAhC,EAAyC;AAAA;;AAAA,4HAChC,IADgC,EAC1B,OAD0B;;AAEtC,UAAK,MAAL,GAAc,YAAd;AAFsC;AAGxC;;AAED;;;;;;;;;;;+BAOW,O,EAAS,E,EAAI;AACrB,aAAO,KAAK,QAAL,CAAc,MAAd,aAA+B,KAAK,MAApC,aAAoD,OAApD,EAA6D,EAA7D,CAAP;AACF;;AAED;;;;;;;;;6BAMS,E,EAAI;AACV,UAAI,iBAAiB,KAAK,uBAAL,CAA6B,EAAC,WAAW,MAAZ,EAA7B,CAArB;;AAEA,aAAO,KAAK,gBAAL,YAA+B,KAAK,MAApC,aAAoD,cAApD,EAAoE,EAApE,CAAP;AACF;;AAED;;;;;;;;;6BAMS,Q,EAAU,E,EAAI;AACpB,aAAO,KAAK,gBAAL,YAA+B,KAAK,MAApC,iBAAsD,QAAtD,EAAkE,IAAlE,EAAwE,EAAxE,CAAP;AACF;;AAED;;;;;;;;;;;;gCASY,O,EAAS,E,EAAI;AACtB,aAAO,KAAK,QAAL,CAAc,KAAd,aAA8B,KAAK,MAAnC,eAAqD,OAArD,EAA8D,EAA9D,CAAP;AACF;;AAED;;;;;;;;;6BAMS,E,EAAI;AACV,aAAO,KAAK,gBAAL,YAA+B,KAAK,MAApC,aAAoD,SAApD,EAA+D,EAA/D,CAAP;AACF;;AAED;;;;;;;;;;;;;;;+BAYW,O,EAAS,E,EAAI;AACrB,aAAO,KAAK,QAAL,CAAc,MAAd,aAA+B,KAAK,MAApC,aAAoD,OAApD,EAA6D,EAA7D,CAAP;AACF;;AAED;;;;;;;;;iCAMa,E,EAAI;AACd,aAAO,KAAK,gBAAL,YAA+B,KAAK,MAApC,gBAAuD,EAAC,cAAc,iBAAf,EAAvD,EAA0F,EAA1F,CAAP;AACF;;AAED;;;;;;;;;;kCAOc,O,EAAS,E,EAAI;AACxB,gBAAU,WAAW,EAArB;AACA,cAAQ,YAAR,GAAuB,iBAAvB;AACA,aAAO,KAAK,QAAL,CAAc,MAAd,aAA+B,KAAK,MAApC,gBAAuD,OAAvD,EAAgE,EAAhE,CAAP;AACF;;;;;;AAGJ,OAAO,OAAP,GAAiB,YAAjB;;;;;;;ACjHA;;;;;;;;;;;;+eAPA;;;;;;;AASA;;;IAGM,O;;;AACH;;;;;;AAMA,oBAAY,EAAZ,EAAgB,IAAhB,EAAsB,OAAtB,EAA+B;AAAA;;AAAA,oHACtB,IADsB,EAChB,OADgB,EACP,iBADO;;AAE5B,YAAK,IAAL,GAAY,EAAZ;AAF4B;AAG9B;;AAED;;;;;;;;;;iCAMW,E,EAAI;AACZ,gBAAO,KAAK,QAAL,CAAc,KAAd,iBAAkC,KAAK,IAAvC,EAA+C,IAA/C,EAAqD,EAArD,CAAP;AACF;;AAED;;;;;;;;;;oCAOc,O,EAAS,E,EAAI;AACxB,gBAAO,KAAK,QAAL,CAAc,OAAd,iBAAoC,KAAK,IAAzC,EAAiD,OAAjD,EAA0D,EAA1D,CAAP;AACF;;AAED;;;;;;;;;oCAMc,E,EAAI;AACf,gBAAO,KAAK,QAAL,CAAc,QAAd,iBAAqC,KAAK,IAA1C,EAAkD,IAAlD,EAAwD,EAAxD,CAAP;AACF;;AAED;;;;;;;;;yCAMmB,E,EAAI;AACpB,gBAAO,KAAK,gBAAL,gBAAmC,KAAK,IAAxC,eAAwD,IAAxD,EAA8D,EAA9D,CAAP;AACF;;AAED;;;;;;;;;;uCAOiB,K,EAAO,E,EAAI;AACzB,gBAAO,KAAK,QAAL,CAAc,KAAd,yBAA0C,KAA1C,EAAmD,IAAnD,EAAyD,EAAzD,CAAP;AACF;;AAED;;;;;;;;;;0CAOoB,O,EAAS,E,EAAI;AAC9B,gBAAO,KAAK,QAAL,CAAc,MAAd,iBAAmC,KAAK,IAAxC,eAAwD,OAAxD,EAAiE,EAAjE,CAAP;AACF;;AAED;;;;;;;;;;;0CAQoB,K,EAAO,O,EAAS,E,EAAI;AACrC,gBAAO,KAAK,QAAL,CAAc,OAAd,yBAA4C,KAA5C,EAAqD,OAArD,EAA8D,EAA9D,CAAP;AACF;;AAED;;;;;;;;;;0CAOoB,K,EAAO,E,EAAI;AAC5B,gBAAO,KAAK,QAAL,CAAc,QAAd,yBAA6C,KAA7C,EAAsD,IAAtD,EAA4D,EAA5D,CAAP;AACF;;AAED;;;;;;;;;;;;wCASkB,K,EAAO,Q,EAAU,E,EAAI;AACpC,gBAAO,KAAK,QAAL,CACJ,MADI,yBAEiB,KAFjB,aAGJ,EAAC,UAAU,QAAX,EAHI,EAIJ,EAJI,CAAP;AAMF;;AAEF;;;;;;;;;uCAMkB,E,EAAI;AAAA;;AAClB,gBAAO,KAAK,kBAAL,GACJ,IADI,CACC,gBAAY;AAAA,gBAAV,IAAU,QAAV,IAAU;;AACf,mBAAO,QAAQ,GAAR,CAAY,KAAK,GAAL,CAAS,UAAC,MAAD,EAAY;AACrC,sBAAO,OAAK,gBAAL,wBAA2C,OAAO,EAAlD,aAA8D,IAA9D,CAAP;AACF,aAFkB,CAAZ,CAAP;AAGF,UALI,EAKF,IALE,CAKG,UAAC,cAAD,EAAoB;AACzB,gBAAM,QAAQ,eAAe,MAAf,CAAsB,UAAC,IAAD,SAAkB;AAAA,mBAAV,IAAU,SAAV,IAAU;;AACnD,oBAAK,IAAL,gCAAa,IAAb;AACA,sBAAO,IAAP;AACF,aAHa,EAGX,EAHW,CAAd;AAIA,gBAAI,EAAJ,EAAQ;AACL,kBAAG,IAAH,EAAS,KAAT;AACF;AACD,mBAAO,KAAP;AACF,UAdI,EAcF,KAdE,CAcI,UAAC,GAAD,EAAS;AACf,gBAAI,EAAJ,EAAQ;AACL,kBAAG,GAAH;AACA;AACF;AACD,kBAAM,GAAN;AACF,UApBI,CAAP;AAqBF;;AAED;;;;;;;;;;sCAOgB,K,EAAO,E,EAAI;AACxB,gBAAO,KAAK,gBAAL,wBAA2C,KAA3C,aAA0D,IAA1D,EAAgE,EAAhE,CAAP;AACF;;AAED;;;;;;;;;;qCAOe,M,EAAQ,E,EAAI;AACxB,gBAAO,KAAK,QAAL,CAAc,KAAd,+BAAgD,MAAhD,EAA0D,IAA1D,EAAgE,EAAhE,CAAP;AACF;;AAED;;;;;;;;;;;wCAQkB,K,EAAO,O,EAAS,E,EAAI;AACnC,gBAAO,KAAK,QAAL,CAAc,MAAd,yBAA2C,KAA3C,aAA0D,OAA1D,EAAmE,EAAnE,CAAP;AACF;;AAED;;;;;;;;;;;wCAQkB,M,EAAQ,O,EAAS,E,EAAI;AACpC,gBAAO,KAAK,QAAL,CAAc,OAAd,+BAAkD,MAAlD,EAA4D,OAA5D,EAAqE,EAArE,CAAP;AACF;;AAED;;;;;;;;;;wCAOkB,M,EAAQ,E,EAAI;AAC3B,gBAAO,KAAK,QAAL,CAAc,QAAd,+BAAmD,MAAnD,EAA6D,IAA7D,EAAmE,EAAnE,CAAP;AACF;;AAED;;;;;;;;;;;;;sCAUgB,M,EAAQ,Q,EAAU,K,EAAO,E,EAAI;AAC1C,gBAAO,KAAK,QAAL,CACJ,MADI,+BAEuB,MAFvB,aAGJ,EAAC,UAAU,QAAX,EAAqB,WAAW,KAAhC,EAHI,EAGoC;AACxC,WAJI,CAAP;AAMF;;;;;;AAGJ,OAAO,OAAP,GAAiB,OAAjB;;;;;;;ACpOA;;;;;;;;;;+eAPA;;;;;;;AASA;;;IAGM,S;;;AACH;;;;;;AAMA,qBAAY,IAAZ,EAAkB,OAAlB,EAA2B;AAAA;;AAAA,iHAClB,IADkB,EACZ,OADY;AAE1B;;AAED;;;;;;;;;;iCAMa,E,EAAI;AACd,aAAO,KAAK,QAAL,CAAc,KAAd,EAAqB,aAArB,EAAoC,IAApC,EAA0C,EAA1C,CAAP;AACF;;;;;;AAGJ,OAAO,OAAP,GAAiB,SAAjB;;;;;;;;;;AC3BA;;;;AACA;;;;AACA;;AAGA;;;;;;;;;;+eAZA;;;;;;;AAaA,IAAM,MAAM,qBAAM,mBAAN,CAAZ;;AAEA;;;;IAGM,U;;;AACH;;;;;;AAMA,uBAAY,QAAZ,EAAsB,IAAtB,EAA4B,OAA5B,EAAqC;AAAA;;AAAA,0HAC5B,IAD4B,EACtB,OADsB;;AAElC,YAAK,UAAL,GAAkB,QAAlB;AACA,YAAK,aAAL,GAAqB;AAClB,iBAAQ,IADU;AAElB,cAAK;AAFa,OAArB;AAHkC;AAOpC;;AAED;;;;;;;;;;;6BAOO,G,EAAK,E,EAAI;AACb,gBAAO,KAAK,QAAL,CAAc,KAAd,cAA+B,KAAK,UAApC,kBAA2D,GAA3D,EAAkE,IAAlE,EAAwE,EAAxE,CAAP;AACF;;AAED;;;;;;;;;;gCAOU,O,EAAS,E,EAAI;AACpB,gBAAO,KAAK,QAAL,CAAc,MAAd,cAAgC,KAAK,UAArC,gBAA4D,OAA5D,EAAqE,EAArE,CAAP;AACF;;AAED;;;;;;;;;;gCAOU,G,EAAK,E,EAAI;AAChB,gBAAO,KAAK,QAAL,CAAc,QAAd,cAAkC,KAAK,UAAvC,kBAA8D,GAA9D,EAAqE,IAArE,EAA2E,EAA3E,CAAP;AACF;;AAED;;;;;;;;;iCAMW,E,EAAI;AACZ,gBAAO,KAAK,QAAL,CAAc,QAAd,cAAkC,KAAK,UAAvC,EAAqD,IAArD,EAA2D,EAA3D,CAAP;AACF;;AAED;;;;;;;;;+BAMS,E,EAAI;AACV,gBAAO,KAAK,QAAL,CAAc,KAAd,cAA+B,KAAK,UAApC,YAAuD,IAAvD,EAA6D,EAA7D,CAAP;AACF;;AAED;;;;;;;;;;uCAOiB,O,EAAS,E,EAAI;AAC3B,mBAAU,WAAW,EAArB;AACA,gBAAO,KAAK,QAAL,CAAc,KAAd,cAA+B,KAAK,UAApC,aAAwD,OAAxD,EAAiE,EAAjE,CAAP;AACF;;AAED;;;;;;;;;;qCAOe,M,EAAQ,E,EAAI;AACxB,gBAAO,KAAK,QAAL,CAAc,KAAd,cAA+B,KAAK,UAApC,eAAwD,MAAxD,EAAkE,IAAlE,EAAwE,EAAxE,CAAP;AACF;;AAED;;;;;;;;;;2CAOqB,M,EAAQ,E,EAAI;AAC9B,gBAAO,KAAK,QAAL,CAAc,KAAd,cAA+B,KAAK,UAApC,eAAwD,MAAxD,aAAwE,IAAxE,EAA8E,EAA9E,CAAP;AACF;;AAED;;;;;;;;;;;sCAQgB,I,EAAM,I,EAAM,E,EAAI;AAC7B,gBAAO,KAAK,QAAL,CAAc,KAAd,cAA+B,KAAK,UAApC,iBAA0D,IAA1D,WAAoE,IAApE,EAA4E,IAA5E,EAAkF,EAAlF,CAAP;AACF;;AAED;;;;;;;;;mCAMa,E,EAAI;AACd,gBAAO,KAAK,QAAL,CAAc,KAAd,cAA+B,KAAK,UAApC,gBAA2D,IAA3D,EAAiE,EAAjE,CAAP;AACF;;AAED;;;;;;;;;;8BAOQ,G,EAAK,E,EAAI;AACd,gBAAO,KAAK,QAAL,CAAc,KAAd,cAA+B,KAAK,UAApC,mBAA4D,GAA5D,EAAmE,IAAnE,EAAyE,EAAzE,EAA6E,KAA7E,CAAP;AACF;;AAED;;;;;;;;;;gCAOU,M,EAAQ,E,EAAI;AACnB,gBAAO,KAAK,QAAL,CAAc,KAAd,cAA+B,KAAK,UAApC,kBAA2D,MAA3D,EAAqE,IAArE,EAA2E,EAA3E,CAAP;AACF;;AAED;;;;;;;;;;gCAOU,G,EAAK,E,EAAI;AAChB,gBAAO,KAAK,QAAL,CAAc,KAAd,cAA+B,KAAK,UAApC,qBAA8D,GAA9D,EAAqE,IAArE,EAA2E,EAA3E,CAAP;AACF;;AAED;;;;;;;;;;;;;;;kCAYY,O,EAAS,E,EAAI;AACtB,mBAAU,WAAW,EAArB;;AAEA,iBAAQ,KAAR,GAAgB,KAAK,UAAL,CAAgB,QAAQ,KAAxB,CAAhB;AACA,iBAAQ,KAAR,GAAgB,KAAK,UAAL,CAAgB,QAAQ,KAAxB,CAAhB;;AAEA,gBAAO,KAAK,QAAL,CAAc,KAAd,cAA+B,KAAK,UAApC,eAA0D,OAA1D,EAAmE,EAAnE,CAAP;AACF;;AAEA;;;;;;;;;;sCAOe,G,EAAK,E,EAAI;AACtB,eAAM,OAAO,EAAb;AACA,gBAAO,KAAK,QAAL,CAAc,KAAd,cAA+B,KAAK,UAApC,iBAA0D,GAA1D,EAAiE,IAAjE,EAAuE,EAAvE,CAAP;AACF;;AAED;;;;;;;;;;;6BAQO,M,EAAQ,I,EAAM,E,EAAI;AACtB,kBAAS,mBAAiB,MAAjB,GAA4B,EAArC;AACA,gBAAO,KAAK,QAAL,CAAc,KAAd,cAA+B,KAAK,UAApC,kBAA2D,IAA3D,GAAkE,MAAlE,EAA4E,IAA5E,EAAkF,EAAlF,CAAP;AACF;;AAED;;;;;;;;;;mCAOa,G,EAAK,E,EAAI;AACnB,gBAAO,KAAK,QAAL,CAAc,KAAd,cAA+B,KAAK,UAApC,iBAA0D,GAA1D,gBAA0E,IAA1E,EAAgF,EAAhF,CAAP;AACF;;AAED;;;;;;;;;;8BAOQ,O,EAAS,E,EAAI;AAClB,gBAAO,KAAK,QAAL,CAAc,KAAd,cAA+B,KAAK,UAApC,mBAA4D,OAA5D,EAAuE,IAAvE,EAA6E,EAA7E,CAAP;AACF;;AAED;;;;;;;;;;iCAOW,O,EAAS,E,EAAI;AACrB,aAAI,WAAW,KAAK,iBAAL,CAAuB,OAAvB,CAAf;;AAEA,aAAI,iBAAJ,EAAuB,QAAvB;AACA,gBAAO,KAAK,QAAL,CAAc,MAAd,cAAgC,KAAK,UAArC,iBAA6D,QAA7D,EAAuE,EAAvE,CAAP;AACF;;AAED;;;;;;;;wCAKkB,O,EAAS;AACxB,aAAI,OAAO,OAAP,KAAmB,QAAvB,EAAiC;AAC9B,gBAAI,oBAAJ;AACA,mBAAO;AACJ,wBAAS,cAAK,MAAL,CAAY,OAAZ,CADL;AAEJ,yBAAU;AAFN,aAAP;AAKF,UAPD,MAOO,IAAI,OAAO,MAAP,KAAkB,WAAlB,IAAiC,mBAAmB,MAAxD,EAAgE;AACpE,gBAAI,yBAAJ;AACA,mBAAO;AACJ,wBAAS,QAAQ,QAAR,CAAiB,QAAjB,CADL;AAEJ,yBAAU;AAFN,aAAP;AAKF,UAPM,MAOA,IAAI,OAAO,IAAP,KAAgB,WAAhB,IAA+B,mBAAmB,IAAtD,EAA4D;AAChE,gBAAI,gCAAJ;AACA,mBAAO;AACJ,wBAAS,eAAO,MAAP,CAAc,OAAd,CADL;AAEJ,yBAAU;AAFN,aAAP;AAKF,UAPM,MAOA;AAAE;AACN,4DAA6C,OAA7C,yCAA6C,OAA7C,YAAyD,KAAK,SAAL,CAAe,OAAf,CAAzD;AACA,kBAAM,IAAI,KAAJ,CAAU,mFAAV,CAAN;AACF;AACH;;AAED;;;;;;;;;;;;;iCAUW,W,EAAa,I,EAAM,O,EAAS,E,EAAI;AACxC,aAAI,UAAU;AACX,uBAAW,WADA,EACa;AACxB,kBAAM,CAAC;AACJ,qBAAM,IADF;AAEJ,oBAAK,OAFD;AAGJ,qBAAM,QAHF;AAIJ,qBAAM;AAJF,aAAD;AAFK,UAAd;;AAUA,gBAAO,KAAK,QAAL,CAAc,MAAd,cAAgC,KAAK,UAArC,iBAA6D,OAA7D,EAAsE,EAAtE,CAAP;AACF;;AAED;;;;;;;;;;;iCAQW,I,EAAM,O,EAAS,E,EAAI;AAC3B,gBAAO,KAAK,QAAL,CAAc,MAAd,cAAgC,KAAK,UAArC,iBAA6D;AACjE,sBADiE;AAEjE,uBAAW,OAFsD,EAA7D,EAGJ,EAHI,CAAP;AAIF;;AAED;;;;;;;;;;;;6BASO,M,EAAQ,I,EAAM,O,EAAS,E,EAAI;AAAA;;AAC/B,aAAI,OAAO;AACR,4BADQ;AAER,sBAFQ;AAGR,qBAAS,CAAC,MAAD;AAHD,UAAX;;AAMA,gBAAO,KAAK,QAAL,CAAc,MAAd,cAAgC,KAAK,UAArC,mBAA+D,IAA/D,EAAqE,EAArE,EACH,IADG,CACE,UAAC,QAAD,EAAc;AACjB,mBAAK,aAAL,CAAmB,GAAnB,GAAyB,SAAS,IAAT,CAAc,GAAvC,CADiB,CAC2B;AAC5C,mBAAO,QAAP;AACF,UAJG,CAAP;AAKF;;AAED;;;;;;;;;;;;iCASW,G,EAAK,S,EAAW,K,EAAO,E,EAAI;AACnC,gBAAO,KAAK,QAAL,CAAc,OAAd,cAAiC,KAAK,UAAtC,kBAA6D,GAA7D,EAAoE;AACxE,iBAAK,SADmE;AAExE,mBAAO;AAFiE,UAApE,EAGJ,EAHI,CAAP;AAIF;;AAED;;;;;;;;;;;;;;;mCAYa,S,EAAW,O,EAAS,E,EAAI;AAClC,gBAAO,KAAK,QAAL,CAAc,MAAd,cAAgC,KAAK,UAArC,kBAA4D,SAA5D,EAAyE,OAAzE,EAAkF,EAAlF,CAAP;AACF;;AAED;;;;;;;;;;;;;;;;;;uCAeiB,O,EAAS,E,EAAI;AAC3B,gBAAO,KAAK,QAAL,CAAc,OAAd,cAAiC,KAAK,UAAtC,EAAoD,OAApD,EAA6D,EAA7D,CAAP;AACF;;AAEF;;;;;;;;;iCAMY,E,EAAI;AACZ,gBAAO,KAAK,QAAL,CAAc,KAAd,cAA+B,KAAK,UAApC,EAAkD,IAAlD,EAAwD,EAAxD,CAAP;AACF;;AAED;;;;;;;;;sCAMgB,E,EAAI;AACjB,gBAAO,KAAK,QAAL,CAAc,KAAd,cAA+B,KAAK,UAApC,oBAA+D,IAA/D,EAAqE,EAArE,CAAP;AACF;;AAED;;;;;;;;;0CAMoB,E,EAAI;AACrB,gBAAO,KAAK,QAAL,CAAc,KAAd,cAA+B,KAAK,UAApC,0BAAqE,IAArE,EAA2E,EAA3E,CAAP;AACF;;AAED;;;;;;;;;;uCAOiB,E,EAAI;AAClB,gBAAO,KAAK,QAAL,CAAc,KAAd,cAA+B,KAAK,UAApC,qBAAgE,IAAhE,EAAsE,EAAtE,CAAP;AACF;;AAED;;;;;;;;;;qCAOe,Q,EAAU,E,EAAI;AAC1B,gBAAO,KAAK,QAAL,CAAc,KAAd,cAA+B,KAAK,UAApC,uBAAgE,QAAhE,EAA4E,IAA5E,EAAkF,EAAlF,CAAP;AACF;;AAED;;;;;;;;;;;;kCASY,G,EAAK,I,EAAM,G,EAAK,E,EAAI;AAC7B,gBAAO,YAAU,UAAU,IAAV,CAAV,GAA8B,EAArC;AACA,gBAAO,KAAK,QAAL,CAAc,KAAd,cAA+B,KAAK,UAApC,kBAA2D,IAA3D,EAAmE;AACvE;AADuE,UAAnE,EAEJ,EAFI,EAEA,GAFA,CAAP;AAGF;;AAED;;;;;;;;;;;gCAQU,G,EAAK,G,EAAK,E,EAAI;AACrB,gBAAO,KAAK,QAAL,CAAc,KAAd,cAA+B,KAAK,UAApC,cAAyD;AAC7D;AAD6D,UAAzD,EAEJ,EAFI,EAEA,GAFA,CAAP;AAGF;;AAED;;;;;;;;;2BAMK,E,EAAI;AACN,gBAAO,KAAK,QAAL,CAAc,MAAd,cAAgC,KAAK,UAArC,aAAyD,IAAzD,EAA+D,EAA/D,CAAP;AACF;;AAED;;;;;;;;;gCAMU,E,EAAI;AACX,gBAAO,KAAK,QAAL,CAAc,KAAd,cAA+B,KAAK,UAApC,aAAwD,IAAxD,EAA8D,EAA9D,CAAP;AACF;;AAED;;;;;;;;;;mCAOa,S,EAAW,S,EAAW,E,EAAI;AAAA;;AACpC,aAAI,OAAO,SAAP,KAAqB,UAAzB,EAAqC;AAClC,iBAAK,SAAL;AACA,wBAAY,SAAZ;AACA,wBAAY,QAAZ;AACF;;AAED,gBAAO,KAAK,MAAL,YAAqB,SAArB,EACH,IADG,CACE,UAAC,QAAD,EAAc;AACjB,gBAAI,MAAM,SAAS,IAAT,CAAc,MAAd,CAAqB,GAA/B;AACA,mBAAO,OAAK,SAAL,CAAe;AACnB,uBADmB;AAEnB,oCAAmB;AAFA,aAAf,EAGJ,EAHI,CAAP;AAIF,UAPG,CAAP;AAQF;;AAED;;;;;;;;;;wCAOkB,O,EAAS,E,EAAI;AAC5B,gBAAO,KAAK,QAAL,CAAc,MAAd,cAAgC,KAAK,UAArC,aAAyD,OAAzD,EAAkE,EAAlE,CAAP;AACF;;AAED;;;;;;;;;;;wCAQkB,M,EAAQ,O,EAAS,E,EAAI;AACpC,gBAAO,KAAK,QAAL,CAAc,OAAd,cAAiC,KAAK,UAAtC,eAA0D,MAA1D,EAAoE,OAApE,EAA6E,EAA7E,CAAP;AACF;;AAED;;;;;;;;;gCAMU,E,EAAI;AACX,gBAAO,KAAK,QAAL,CAAc,KAAd,cAA+B,KAAK,UAApC,aAAwD,IAAxD,EAA8D,EAA9D,CAAP;AACF;;AAED;;;;;;;;;;8BAOQ,E,EAAI,E,EAAI;AACb,gBAAO,KAAK,QAAL,CAAc,KAAd,cAA+B,KAAK,UAApC,eAAwD,EAAxD,EAA8D,IAA9D,EAAoE,EAApE,CAAP;AACF;;AAED;;;;;;;;;;iCAOW,O,EAAS,E,EAAI;AACrB,gBAAO,KAAK,QAAL,CAAc,MAAd,cAAgC,KAAK,UAArC,aAAyD,OAAzD,EAAkE,EAAlE,CAAP;AACF;;AAED;;;;;;;;;;;iCAQW,E,EAAI,O,EAAS,E,EAAI;AACzB,gBAAO,KAAK,QAAL,CAAc,OAAd,cAAiC,KAAK,UAAtC,eAA0D,EAA1D,EAAgE,OAAhE,EAAyE,EAAzE,CAAP;AACF;;AAED;;;;;;;;;;iCAOW,E,EAAI,E,EAAI;AAChB,gBAAO,KAAK,QAAL,CAAc,QAAd,cAAkC,KAAK,UAAvC,eAA2D,EAA3D,EAAiE,IAAjE,EAAuE,EAAvE,CAAP;AACF;;AAED;;;;;;;;;+BAMS,E,EAAI;AACV,gBAAO,KAAK,QAAL,CAAc,KAAd,cAA+B,KAAK,UAApC,YAAuD,IAAvD,EAA6D,EAA7D,CAAP;AACF;;AAED;;;;;;;;;;6BAOO,E,EAAI,E,EAAI;AACZ,gBAAO,KAAK,QAAL,CAAc,KAAd,cAA+B,KAAK,UAApC,cAAuD,EAAvD,EAA6D,IAA7D,EAAmE,EAAnE,CAAP;AACF;;AAED;;;;;;;;;;gCAOU,O,EAAS,E,EAAI;AACpB,gBAAO,KAAK,QAAL,CAAc,MAAd,cAAgC,KAAK,UAArC,YAAwD,OAAxD,EAAiE,EAAjE,CAAP;AACF;;AAED;;;;;;;;;;gCAOU,E,EAAI,E,EAAI;AACf,gBAAO,KAAK,QAAL,CAAc,QAAd,cAAkC,KAAK,UAAvC,cAA0D,EAA1D,EAAgE,IAAhE,EAAsE,EAAtE,CAAP;AACF;;AAED;;;;;;;;;;;iCAQW,M,EAAQ,I,EAAM,E,EAAI;AAAA;;AAC1B,gBAAO,KAAK,MAAL,CAAY,MAAZ,EAAoB,IAApB,EACH,IADG,CACE,UAAC,QAAD,EAAc;AACjB,gBAAM,eAAe;AAClB,kDAAgC,IAAhC,OADkB;AAElB,oBAAK,SAAS,IAAT,CAAc,GAFD;AAGlB;AAHkB,aAArB;AAKA,mBAAO,OAAK,QAAL,CAAc,QAAd,cAAkC,OAAK,UAAvC,kBAA8D,IAA9D,EAAsE,YAAtE,EAAoF,EAApF,CAAP;AACF,UARG,CAAP;AASF;;AAED;;;;;;;;;;;2BAQK,M,EAAQ,O,EAAS,O,EAAS,E,EAAI;AAAA;;AAChC,aAAI,eAAJ;AACA,gBAAO,KAAK,MAAL,YAAqB,MAArB,EACH,IADG,CACE;AAAA,gBAAS,MAAT,QAAE,IAAF,CAAS,MAAT;AAAA,mBAAsB,OAAK,OAAL,CAAgB,OAAO,GAAvB,qBAAtB;AAAA,UADF,EAEH,IAFG,CAEE,iBAAyB;AAAA,mCAAvB,IAAuB;AAAA,gBAAhB,IAAgB,cAAhB,IAAgB;AAAA,gBAAV,GAAU,cAAV,GAAU;;AAC5B,qBAAS,GAAT;AACA,gBAAI,UAAU,KAAK,GAAL,CAAS,UAAC,GAAD,EAAS;AAC7B,mBAAI,IAAI,IAAJ,KAAa,OAAjB,EAA0B;AACvB,sBAAI,IAAJ,GAAW,OAAX;AACF;AACD,mBAAI,IAAI,IAAJ,KAAa,MAAjB,EAAyB;AACtB,yBAAO,IAAI,GAAX;AACF;AACD,sBAAO,GAAP;AACF,aARa,CAAd;AASA,mBAAO,OAAK,UAAL,CAAgB,OAAhB,CAAP;AACF,UAdG,EAeH,IAfG,CAeE;AAAA,gBAAQ,IAAR,SAAE,IAAF;AAAA,mBAAkB,OAAK,MAAL,CAAY,MAAZ,EAAoB,KAAK,GAAzB,iBAA0C,OAA1C,gBAA0D,OAA1D,QAAlB;AAAA,UAfF,EAgBH,IAhBG,CAgBE;AAAA,gBAAQ,MAAR,SAAE,IAAF;AAAA,mBAAoB,OAAK,UAAL,YAAyB,MAAzB,EAAmC,OAAO,GAA1C,EAA+C,IAA/C,EAAqD,EAArD,CAApB;AAAA,UAhBF,CAAP;AAiBF;;AAED;;;;;;;;;;;;;;;;;gCAcU,M,EAAQ,I,EAAM,O,EAAS,O,EAAS,O,EAAS,E,EAAI;AAAA;;AACpD,aAAI,OAAO,OAAP,KAAmB,UAAvB,EAAmC;AAChC,iBAAK,OAAL;AACA,sBAAU,EAAV;AACF;AACD,aAAI,WAAW,OAAO,UAAU,IAAV,CAAP,GAAyB,EAAxC;AACA,aAAI,eAAe,QAAQ,MAAR,KAAmB,KAAtC;AACA,aAAI,SAAS;AACV,0BADU;AAEV,4BAFU;AAGV,oBAAQ,QAAQ,MAHN;AAIV,uBAAW,QAAQ,SAJT;AAKV,qBAAS,eAAe,eAAO,MAAP,CAAc,OAAd,CAAf,GAAwC;AALvC,UAAb;;AAQA,gBAAO,KAAK,MAAL,CAAY,MAAZ,EAAoB,QAApB,EACH,IADG,CACE,UAAC,QAAD,EAAc;AACjB,mBAAO,GAAP,GAAa,SAAS,IAAT,CAAc,GAA3B;AACA,mBAAO,OAAK,QAAL,CAAc,KAAd,cAA+B,OAAK,UAApC,kBAA2D,QAA3D,EAAuE,MAAvE,EAA+E,EAA/E,CAAP;AACF,UAJG,EAID,YAAM;AACN,mBAAO,OAAK,QAAL,CAAc,KAAd,cAA+B,OAAK,UAApC,kBAA2D,QAA3D,EAAuE,MAAvE,EAA+E,EAA/E,CAAP;AACF,UANG,CAAP;AAOF;;AAED;;;;;;;;;;gCAOU,E,EAAI;AACX,gBAAO,KAAK,gBAAL,oBAAuC,KAAK,UAA5C,EAA0D,IAA1D,EAAgE,EAAhE,CAAP;AACF;;AAED;;;;;;;;;2BAMK,E,EAAI;AACN,gBAAO,KAAK,QAAL,CAAc,KAAd,qBAAsC,KAAK,UAA3C,EAAyD,IAAzD,EAA+D,EAA/D,CAAP;AACF;;AAED;;;;;;;;;6BAMO,E,EAAI;AACR,gBAAO,KAAK,QAAL,CAAc,QAAd,qBAAyC,KAAK,UAA9C,EAA4D,IAA5D,EAAkE,EAAlE,CAAP;AACF;;AAED;;;;;;;;;;oCAOc,O,EAAS,E,EAAI;AACxB,gBAAO,KAAK,QAAL,CAAc,MAAd,cAAgC,KAAK,UAArC,gBAA4D,OAA5D,EAAqE,EAArE,CAAP;AACF;;AAED;;;;;;;;;;;oCAQc,E,EAAI,O,EAAS,E,EAAI;AAC5B,gBAAO,KAAK,QAAL,CAAc,OAAd,cAAiC,KAAK,UAAtC,kBAA6D,EAA7D,EAAmE,OAAnE,EAA4E,EAA5E,CAAP;AACF;;AAED;;;;;;;;;mCAMa,E,EAAI;AACd,gBAAO,KAAK,QAAL,CAAc,KAAd,cAA+B,KAAK,UAApC,gBAA2D,IAA3D,EAAiE,EAAjE,CAAP;AACF;;AAED;;;;;;;;;;iCAOW,E,EAAI,E,EAAI;AAChB,gBAAO,KAAK,QAAL,CAAc,KAAd,cAA+B,KAAK,UAApC,kBAA2D,EAA3D,EAAiE,IAAjE,EAAuE,EAAvE,CAAP;AACF;;AAED;;;;;;;;;;oCAOc,E,EAAI,E,EAAI;AACnB,gBAAO,KAAK,QAAL,CAAc,QAAd,cAAkC,KAAK,UAAvC,kBAA8D,EAA9D,EAAoE,IAApE,EAA0E,EAA1E,CAAP;AACF;;AAED;;;;;;;;;;;uCAQiB,M,EAAQ,O,EAAS,E,EAAI;AACnC,gBAAO,KAAK,QAAL,CAAc,KAAd,cAA+B,KAAK,UAApC,eAAwD,MAAxD,aAAwE,OAAxE,EAAiF,EAAjF,CAAP;AACF;;AAED;;;;;;;;;mCAMa,E,EAAI;AACd,gBAAO,KAAK,gBAAL,aAAgC,KAAK,UAArC,gBAA4D,EAAC,cAAc,iBAAf,EAA5D,EAA+F,EAA/F,CAAP;AACF;;AAED;;;;;;;;;;oCAOc,O,EAAS,E,EAAI;AACxB,mBAAU,WAAW,EAArB;AACA,iBAAQ,YAAR,GAAuB,iBAAvB;AACA,gBAAO,KAAK,QAAL,CAAc,MAAd,cAAgC,KAAK,UAArC,gBAA4D,OAA5D,EAAqE,EAArE,CAAP;AACF;;;;;;AAIJ,OAAO,OAAP,GAAiB,UAAjB;;;;;;;;;;;ACt1BA;;;;AACA;;;;AACA;;;;;;;;;;+eATA;;;;;;;AAWA,IAAM,MAAM,qBAAM,gBAAN,CAAZ;;AAEA;;;;IAGM,a;;;AACH;;;;;;AAMA,0BAAY,OAAZ,EAAqB,IAArB,EAA2B,QAA3B,EAAqC;AAAA;;AAAA,gIAC5B,OAD4B;;AAElC,YAAK,IAAL,GAAY,IAAZ;AACA,YAAK,OAAL,GAAe,SAAS,MAAxB;AACA,YAAK,QAAL,GAAgB,CAAC,YAAY,EAAb,EAAiB,QAAjB,IAA6B,QAA7C;AACA,YAAK,MAAL,GAAc,SAAS,MAAvB;AALkC;AAMpC;;;EAbwB,K;;AAgB5B;;;;;IAGM,W;AACH;;;;;;;AAOA;;;;;;;AAOA,wBAAY,IAAZ,EAAkB,OAAlB,EAA2B,YAA3B,EAAyC;AAAA;;AACtC,WAAK,SAAL,GAAiB,WAAW,wBAA5B;AACA,WAAK,MAAL,GAAc;AACX,gBAAO,KAAK,KADD;AAEX,mBAAU,KAAK,QAFJ;AAGX,mBAAU,KAAK;AAHJ,OAAd;AAKA,WAAK,cAAL,GAAsB,gBAAgB,IAAtC;;AAEA,UAAI,KAAK,KAAT,EAAgB;AACb,cAAK,qBAAL,GAA6B,WAAW,KAAK,KAA7C;AACF,OAFD,MAEO,IAAI,KAAK,QAAL,IAAiB,KAAK,QAA1B,EAAoC;AACxC,cAAK,qBAAL,GAA6B,WAAW,eAAO,MAAP,CAAc,KAAK,QAAL,GAAgB,GAAhB,GAAsB,KAAK,QAAzC,CAAxC;AACF;AACH;;AAED;;;;;;;;;;+BAMS,I,EAAM;AACZ,aAAI,MAAM,IAAV;;AAEA,aAAI,KAAK,OAAL,CAAa,IAAb,MAAuB,CAAC,CAA5B,EAA+B;AAC5B,kBAAM,KAAK,SAAL,GAAiB,IAAvB;AACF;;AAED,aAAI,iBAAiB,eAAe,IAAI,IAAJ,GAAW,OAAX,EAApC;AACA,gBAAO,IAAI,OAAJ,CAAY,iBAAZ,EAA+B,cAA/B,CAAP;AACF;;AAED;;;;;;;;;;0CAOoB,G,EAAK,Y,EAAc;AACpC,aAAI,UAAU;AACX,4BAAgB,gCADL;AAEX,sBAAU,6BAA6B,gBAAgB,KAAK,cAAlD;AAFC,UAAd;;AAKA,aAAI,GAAJ,EAAS;AACN,oBAAQ,MAAR,IAAkB,MAAlB;AACF;AACD,iBAAQ,MAAR,IAAkB,OAAlB;;AAEA,aAAI,KAAK,qBAAT,EAAgC;AAC7B,oBAAQ,aAAR,GAAwB,KAAK,qBAA7B;AACF;;AAED,gBAAO,OAAP;AACF;;AAED;;;;;;;;;gDAM6C;AAAA,aAArB,cAAqB,uEAAJ,EAAI;;AAC1C,aAAI,EAAE,eAAe,UAAf,IAA6B,eAAe,WAA9C,CAAJ,EAAgE;AAC7D,2BAAe,IAAf,GAAsB,eAAe,IAAf,IAAuB,KAA7C;AACF;AACD,wBAAe,IAAf,GAAsB,eAAe,IAAf,IAAuB,SAA7C;AACA,wBAAe,QAAf,GAA0B,eAAe,QAAf,IAA2B,KAArD,CAL0C,CAKkB;;AAE5D,gBAAO,cAAP;AACF;;AAED;;;;;;;;iCAKW,I,EAAM;AACd,aAAI,QAAS,gBAAgB,IAA7B,EAAoC;AACjC,mBAAO,KAAK,WAAL,EAAP;AACF;;AAED,gBAAO,IAAP;AACF;;AAED;;;;;;;AAOA;;;;;;;;;;;;;;+BAWS,M,EAAQ,I,EAAM,I,EAAM,E,EAAI,G,EAAK;AACnC,aAAM,MAAM,KAAK,QAAL,CAAc,IAAd,CAAZ;;AAEA,aAAM,eAAe,CAAC,QAAQ,EAAT,EAAa,YAAlC;AACA,aAAI,YAAJ,EAAkB;AACf,mBAAO,KAAK,YAAZ;AACF;AACD,aAAM,UAAU,KAAK,mBAAL,CAAyB,GAAzB,EAA8B,YAA9B,CAAhB;;AAEA,aAAI,cAAc,EAAlB;;AAEA,aAAM,wBAAwB,QAAS,QAAO,IAAP,yCAAO,IAAP,OAAgB,QAAzB,IAAsC,gBAAgB,MAAhB,CAApE;AACA,aAAI,qBAAJ,EAA2B;AACxB,0BAAc,IAAd;AACA,mBAAO,SAAP;AACF;;AAED,aAAM,SAAS;AACZ,iBAAK,GADO;AAEZ,oBAAQ,MAFI;AAGZ,qBAAS,OAHG;AAIZ,oBAAQ,WAJI;AAKZ,kBAAM,IALM;AAMZ,0BAAc,MAAM,MAAN,GAAe;AANjB,UAAf;;AASA,aAAO,OAAO,MAAd,YAA2B,OAAO,GAAlC;AACA,aAAM,iBAAiB,qBAAM,MAAN,EAAc,KAAd,CAAoB,qBAAqB,EAArB,EAAyB,IAAzB,CAApB,CAAvB;;AAEA,aAAI,EAAJ,EAAQ;AACL,2BAAe,IAAf,CAAoB,UAAC,QAAD,EAAc;AAC/B,mBAAI,SAAS,IAAT,IAAiB,OAAO,IAAP,CAAY,SAAS,IAArB,EAA2B,MAA3B,GAAoC,CAAzD,EAA4D;AACzD;AACA,qBAAG,IAAH,EAAS,SAAS,IAAlB,EAAwB,QAAxB;AACF,gBAHD,MAGO,IAAI,OAAO,MAAP,KAAkB,KAAlB,IAA2B,OAAO,IAAP,CAAY,SAAS,IAArB,EAA2B,MAA3B,GAAoC,CAAnE,EAAsE;AAC1E;AACA,qBAAG,IAAH,EAAU,SAAS,MAAT,GAAkB,GAA5B,EAAkC,QAAlC;AACF,gBAHM,MAGA;AACJ,qBAAG,IAAH,EAAS,SAAS,IAAlB,EAAwB,QAAxB;AACF;AACH,aAVD;AAWF;;AAED,gBAAO,cAAP;AACF;;AAED;;;;;;;;;;;uCAQiB,I,EAAM,I,EAAM,E,EAAoB;AAAA,aAAhB,MAAgB,uEAAP,KAAO;;AAC9C,gBAAO,KAAK,QAAL,CAAc,MAAd,EAAsB,IAAtB,EAA4B,IAA5B,EACH,IADG,CACE,SAAS,OAAT,CAAiB,QAAjB,EAA2B;AAC9B,gBAAI,EAAJ,EAAQ;AACL,kBAAG,IAAH,EAAS,IAAT,EAAe,QAAf;AACF;AACD,mBAAO,IAAP;AACF,UANG,EAMD,SAAS,OAAT,CAAiB,QAAjB,EAA2B;AAC3B,gBAAI,SAAS,QAAT,CAAkB,MAAlB,KAA6B,GAAjC,EAAsC;AACnC,mBAAI,EAAJ,EAAQ;AACL,qBAAG,IAAH,EAAS,KAAT,EAAgB,QAAhB;AACF;AACD,sBAAO,KAAP;AACF;;AAED,gBAAI,EAAJ,EAAQ;AACL,kBAAG,QAAH;AACF;AACD,kBAAM,QAAN;AACF,UAlBG,CAAP;AAmBF;;AAED;;;;;;;;;;;;;uCAUiB,I,EAAM,O,EAAS,E,EAAI,O,EAAS;AAAA;;AAC1C,mBAAU,WAAW,EAArB;;AAEA,gBAAO,KAAK,QAAL,CAAc,KAAd,EAAqB,IAArB,EAA2B,OAA3B,EACH,IADG,CACE,UAAC,QAAD,EAAc;AAAA;;AACjB,gBAAI,kBAAJ;AACA,gBAAI,SAAS,IAAT,YAAyB,KAA7B,EAAoC;AACjC,2BAAY,SAAS,IAArB;AACF,aAFD,MAEO,IAAI,SAAS,IAAT,CAAc,KAAd,YAA+B,KAAnC,EAA0C;AAC9C,2BAAY,SAAS,IAAT,CAAc,KAA1B;AACF,aAFM,MAEA;AACJ,mBAAI,+CAA6C,SAAS,IAAtD,uBAAJ;AACA,qBAAM,IAAI,aAAJ,CAAkB,OAAlB,EAA2B,IAA3B,EAAiC,QAAjC,CAAN;AACF;AACD,iCAAQ,IAAR,oCAAgB,SAAhB;;AAEA,gBAAM,UAAU,YAAY,SAAS,OAAT,CAAiB,IAA7B,CAAhB;AACA,gBAAI,WAAW,OAAO,QAAQ,IAAf,KAAwB,QAAvC,EAAiD;AAC9C,2CAA0B,OAA1B;AACA,sBAAO,OAAK,gBAAL,CAAsB,OAAtB,EAA+B,OAA/B,EAAwC,EAAxC,EAA4C,OAA5C,CAAP;AACF;;AAED,gBAAI,EAAJ,EAAQ;AACL,kBAAG,IAAH,EAAS,OAAT,EAAkB,QAAlB;AACF;;AAED,qBAAS,IAAT,GAAgB,OAAhB;AACA,mBAAO,QAAP;AACF,UAzBG,EAyBD,KAzBC,CAyBK,qBAAqB,EAArB,EAAyB,IAAzB,CAzBL,CAAP;AA0BF;;;;;;AAGJ,OAAO,OAAP,GAAiB,WAAjB;;AAEA;AACA;AACA;AACA,IAAM,uBAAuB,CAAC,KAAD,EAAQ,MAAR,EAAgB,QAAhB,CAA7B;AACA,SAAS,eAAT,CAAyB,MAAzB,EAAiC;AAC9B,UAAO,qBAAqB,OAArB,CAA6B,MAA7B,MAAyC,CAAC,CAAjD;AACF;;AAED,SAAS,WAAT,GAAuC;AAAA,OAAlB,WAAkB,uEAAJ,EAAI;;AACpC,OAAM,QAAQ,YAAY,KAAZ,CAAkB,SAAlB,CAAd,CADoC,CACQ;AAC5C,UAAO,MAAM,MAAN,CAAa,UAAS,OAAT,EAAkB,IAAlB,EAAwB;AACzC,UAAI,KAAK,MAAL,CAAY,YAAZ,MAA8B,CAAC,CAAnC,EAAsC;AACnC,gBAAO,CAAC,KAAK,KAAL,CAAW,QAAX,KAAwB,EAAzB,EAA6B,CAA7B,CAAP;AACF;;AAED,aAAO,OAAP;AACF,IANM,EAMJ,SANI,CAAP;AAOF;;AAED,SAAS,oBAAT,CAA8B,EAA9B,EAAkC,IAAlC,EAAwC;AACrC,UAAO,SAAS,OAAT,CAAiB,MAAjB,EAAyB;AAC7B,UAAI,cAAJ;AACA,UAAI,OAAO,cAAP,CAAsB,QAAtB,CAAJ,EAAqC;AAAA,gCAC8B,MAD9B,CAC3B,QAD2B;AAAA,aAChB,MADgB,oBAChB,MADgB;AAAA,aACR,UADQ,oBACR,UADQ;AAAA,8BAC8B,MAD9B,CACK,MADL;AAAA,aACc,MADd,kBACc,MADd;AAAA,aACsB,GADtB,kBACsB,GADtB;;AAElC,aAAI,UAAc,MAAd,8BAA6C,MAA7C,SAAuD,GAAvD,WAAgE,UAAhE,MAAJ;AACA,iBAAQ,IAAI,aAAJ,CAAkB,OAAlB,EAA2B,IAA3B,EAAiC,MAAjC,CAAR;AACA,aAAO,OAAP,SAAkB,KAAK,SAAL,CAAe,OAAO,IAAtB,CAAlB;AACF,OALD,MAKO;AACJ,iBAAQ,MAAR;AACF;AACD,UAAI,EAAJ,EAAQ;AACL,aAAI,yBAAJ;AACA,YAAG,KAAH;AACF,OAHD,MAGO;AACJ,aAAI,gBAAJ;AACA,eAAM,KAAN;AACF;AACH,IAjBD;AAkBF;;;;;;;AClTD;;;;AACA;;;;;;;;;;+eARA;;;;;;;AASA,IAAM,MAAM,qBAAM,eAAN,CAAZ;;AAEA;;;;IAGM,M;;;AACH;;;;;;AAMA,kBAAY,QAAZ,EAAsB,IAAtB,EAA4B,OAA5B,EAAqC;AAAA;;AAAA,gHAC5B,IAD4B,EACtB,OADsB;;AAElC,UAAK,UAAL,GAAkB,MAAK,uBAAL,CAA6B,QAA7B,CAAlB;AAFkC;AAGpC;;AAED;;;;;;;;;AASA;;;;;;;;;;;;4BAQQ,I,EAAwC;AAAA;;AAAA,UAAlC,WAAkC,uEAApB,EAAoB;AAAA,UAAhB,EAAgB,uEAAX,SAAW;;AAC7C,UAAI,iBAAiB,EAArB;AACA,aAAO,IAAP,CAAY,KAAK,UAAjB,EAA6B,OAA7B,CAAqC,UAAC,IAAD,EAAU;AAC5C,uBAAe,IAAf,IAAuB,OAAK,UAAL,CAAgB,IAAhB,CAAvB;AACF,OAFD;AAGA,aAAO,IAAP,CAAY,WAAZ,EAAyB,OAAzB,CAAiC,UAAC,IAAD,EAAU;AACxC,uBAAe,IAAf,IAAuB,YAAY,IAAZ,CAAvB;AACF,OAFD;;AAIA,yBAAiB,IAAjB,qBAAuC,cAAvC;AACA,aAAO,KAAK,gBAAL,cAAiC,IAAjC,EAAyC,cAAzC,EAAyD,EAAzD,CAAP;AACF;;AAED;;;;;;;;;;oCAOgB,O,EAAS,E,EAAI;AAC1B,aAAO,KAAK,OAAL,CAAa,cAAb,EAA6B,OAA7B,EAAsC,EAAtC,CAAP;AACF;;AAED;;;;;;;;;;4BAOQ,O,EAAS,E,EAAI;AAClB,aAAO,KAAK,OAAL,CAAa,MAAb,EAAqB,OAArB,EAA8B,EAA9B,CAAP;AACF;;AAED;;;;;;;;;;8BAOU,O,EAAS,E,EAAI;AACpB,aAAO,KAAK,OAAL,CAAa,QAAb,EAAuB,OAAvB,EAAgC,EAAhC,CAAP;AACF;;AAED;;;;;;;;;;6BAOS,O,EAAS,E,EAAI;AACnB,aAAO,KAAK,OAAL,CAAa,OAAb,EAAsB,OAAtB,EAA+B,EAA/B,CAAP;AACF;;;;;;AAGJ,OAAO,OAAP,GAAiB,MAAjB;;;;;;;AC9FA;;;;AACA;;;;;;;;;;+eARA;;;;;;;AASA,IAAM,MAAM,qBAAM,aAAN,CAAZ;;AAEA;;;;IAGM,I;;;AACH;;;;;;AAMA,gBAAY,MAAZ,EAAoB,IAApB,EAA0B,OAA1B,EAAmC;AAAA;;AAAA,4GAC1B,IAD0B,EACpB,OADoB;;AAEhC,UAAK,QAAL,GAAgB,MAAhB;AAFgC;AAGlC;;AAED;;;;;;;;;;4BAMQ,E,EAAI;AACT,6BAAqB,KAAK,QAA1B;AACA,aAAO,KAAK,QAAL,CAAc,KAAd,cAA+B,KAAK,QAApC,EAAgD,SAAhD,EAA2D,EAA3D,CAAP;AACF;;AAED;;;;;;;;;8BAMU,E,EAAI;AACX,8CAAsC,KAAK,QAA3C;AACA,aAAO,KAAK,gBAAL,aAAgC,KAAK,QAArC,aAAuD,SAAvD,EAAkE,EAAlE,CAAP;AACF;;AAED;;;;;;;;;;;;;;;6BAYS,O,EAAS,E,EAAI;AACnB,4BAAoB,KAAK,QAAzB;AACA,aAAO,KAAK,QAAL,CAAc,OAAd,cAAiC,KAAK,QAAtC,EAAkD,OAAlD,EAA2D,EAA3D,CAAP;AACF;;AAED;;;;;;;;;;;gCAQY,O,EAAS,E,EAAI;AACtB,uCAA+B,KAAK,QAApC;AACA,aAAO,KAAK,gBAAL,aAAgC,KAAK,QAArC,eAAyD,OAAzD,EAAkE,EAAlE,CAAP;AACF;;AAED;;;;;;;;;;kCAOc,Q,EAAU,E,EAAI;AACzB,0CAAkC,QAAlC,iBAAsD,KAAK,QAA3D;AACA,aAAO,KAAK,QAAL,CAAc,KAAd,cAA+B,KAAK,QAApC,qBAA4D,QAA5D,EAAwE,SAAxE,EAAmF,EAAnF,CAAP;AACF;;AAED;;;;;;;;;;;;;kCAUc,Q,EAAU,O,EAAS,E,EAAI;AAClC,2BAAmB,QAAnB,iBAAuC,KAAK,QAA5C;AACA,aAAO,KAAK,QAAL,CAAc,KAAd,cAA+B,KAAK,QAApC,qBAA4D,QAA5D,EAAwE,OAAxE,EAAiF,EAAjF,CAAP;AACF;;AAED;;;;;;;;;;;kCAQc,K,EAAO,I,EAAM,E,EAAI;AAC5B,+CAAuC,KAAK,QAA5C,kBAAiE,KAAjE,SAA0E,IAA1E;AACA,aAAO,KAAK,gBAAL,aAAgC,KAAK,QAArC,eAAuD,KAAvD,SAAgE,IAAhE,EAAwE,SAAxE,EAAmF,EAAnF,CAAP;AACF;;AAED;;;;;;;;;;;;;;+BAWW,K,EAAO,I,EAAM,O,EAAS,E,EAAI;AAClC,0DAAkD,KAAK,QAAvD,kBAA4E,KAA5E,SAAqF,IAArF;AACA,aAAO,KAAK,gBAAL,aAAgC,KAAK,QAArC,eAAuD,KAAvD,SAAgE,IAAhE,EAAwE,OAAxE,EAAiF,EAAjF,EAAqF,KAArF,CAAP;AACF;;AAED;;;;;;;;;;;iCAQa,K,EAAO,I,EAAM,E,EAAI;AAC3B,8CAAsC,KAAK,QAA3C,kBAAgE,KAAhE,SAAyE,IAAzE;AACA,aAAO,KAAK,gBAAL,aAAgC,KAAK,QAArC,eAAuD,KAAvD,SAAgE,IAAhE,EAAwE,SAAxE,EAAmF,EAAnF,EAAuF,QAAvF,CAAP;AACF;;AAED;;;;;;;;;+BAMW,E,EAAI;AACZ,6BAAqB,KAAK,QAA1B;AACA,aAAO,KAAK,gBAAL,aAAgC,KAAK,QAArC,EAAiD,SAAjD,EAA4D,EAA5D,EAAgE,QAAhE,CAAP;AACF;;;;;;AAGJ,OAAO,OAAP,GAAiB,IAAjB;;;;;;;ACxJA;;;;AACA;;;;;;;;;;+eARA;;;;;;;AASA,IAAM,MAAM,qBAAM,aAAN,CAAZ;;AAEA;;;;IAGM,I;;;AACH;;;;;;AAMA,iBAAY,QAAZ,EAAsB,IAAtB,EAA4B,OAA5B,EAAqC;AAAA;;AAAA,8GAC5B,IAD4B,EACtB,OADsB;;AAElC,YAAK,MAAL,GAAc,QAAd;AAFkC;AAGpC;;AAED;;;;;;;;;;qCAMe,Q,EAAU;AACtB,aAAI,KAAK,MAAT,EAAiB;AACd,mBAAO,uBACM,KAAK,MADX,SACqB,QADrB,eAEM,KAAK,MAFlB;AAKF,UAND,MAMO;AAAE;AACN,oBAAQ,QAAR;AACG,oBAAK,EAAL;AACG,yBAAO,OAAP;;AAEH,oBAAK,eAAL;AACA,oBAAK,OAAL;AACG,+BAAW,QAAX;;AAEH;AACG,oCAAgB,QAAhB;AATN;AAWF;AACH;;AAED;;;;;;;;;;gCAOU,O,EAAS,E,EAAI;AACpB,aAAI,OAAO,OAAP,KAAmB,UAAvB,EAAmC;AAChC,iBAAK,OAAL;AACA,sBAAU,EAAV;AACF;;AAED,mBAAU,KAAK,uBAAL,CAA6B,OAA7B,CAAV;;AAEA,sDAA2C,KAAK,SAAL,CAAe,OAAf,CAA3C;AACA,gBAAO,KAAK,gBAAL,CAAsB,KAAK,cAAL,CAAoB,OAApB,CAAtB,EAAoD,OAApD,EAA6D,EAA7D,CAAP;AACF;;AAED;;;;;;;;;+BAMS,E,EAAI;AACV,gBAAO,KAAK,QAAL,CAAc,KAAd,EAAqB,KAAK,cAAL,CAAoB,MAApB,CAArB,EAAkD,IAAlD,EAAwD,EAAxD,CAAP;AACF;;AAED;;;;;;;;;gCAMU,E,EAAI;AACX,gBAAO,KAAK,QAAL,CAAc,KAAd,EAAqB,KAAK,cAAL,CAAoB,OAApB,CAArB,EAAmD,IAAnD,EAAyD,EAAzD,CAAP;AACF;;AAED;;;;;;;;;uCAMiB,E,EAAI;AAClB,gBAAO,KAAK,QAAL,CAAc,KAAd,EAAqB,KAAK,cAAL,CAAoB,eAApB,CAArB,EAA2D,IAA3D,EAAiE,EAAjE,CAAP;AACF;;AAED;;;;;;;;;uCAMiB,E,EAAI;AAClB,gBAAO,KAAK,QAAL,CAAc,KAAd,EAAqB,KAAK,cAAL,CAAoB,OAApB,CAArB,EAAmD,IAAnD,EAAyD,EAAzD,CAAP;AACF;;AAED;;;;;;;;;;wCAOkB,O,EAAS,E,EAAI;AAC5B,mBAAU,WAAW,EAArB;AACA,aAAI,OAAO,OAAP,KAAmB,UAAvB,EAAmC;AAChC,iBAAK,OAAL;AACA,sBAAU,EAAV;AACF;;AAED,iBAAQ,KAAR,GAAgB,KAAK,UAAL,CAAgB,QAAQ,KAAxB,CAAhB;AACA,iBAAQ,MAAR,GAAiB,KAAK,UAAL,CAAgB,QAAQ,MAAxB,CAAjB;;AAEA,gBAAO,KAAK,QAAL,CAAc,KAAd,EAAqB,KAAK,cAAL,CAAoB,eAApB,CAArB,EAA2D,OAA3D,EAAoE,EAApE,CAAP;AACF;;AAED;;;;;;;;;iCAMW,E,EAAI;AACZ,gBAAO,KAAK,QAAL,CAAc,KAAd,EAAqB,KAAK,cAAL,CAAoB,EAApB,CAArB,EAA8C,IAA9C,EAAoD,EAApD,CAAP;AACF;;AAED;;;;;;;;;uCAMiB,E,EAAI;AAClB,aAAI,iBAAiB,KAAK,uBAAL,EAArB;AACA,gBAAO,KAAK,gBAAL,CAAsB,KAAK,cAAL,CAAoB,SAApB,CAAtB,EAAsD,cAAtD,EAAsE,EAAtE,CAAP;AACF;;AAED;;;;;;;;;gCAMU,E,EAAI;AACX,gBAAO,KAAK,QAAL,CAAc,KAAd,EAAqB,cAArB,EAAqC,IAArC,EAA2C,EAA3C,CAAP;AACF;;AAED;;;;;;;;;;6BAOO,Q,EAAU,E,EAAI;AAClB,gBAAO,KAAK,QAAL,CAAc,KAAd,uBAAwC,KAAK,MAA7C,EAAuD,IAAvD,EAA6D,EAA7D,CAAP;AACF;;AAED;;;;;;;;;;+BAOS,Q,EAAU,E,EAAI;AACpB,gBAAO,KAAK,QAAL,CAAc,QAAd,uBAA2C,KAAK,MAAhD,EAA0D,IAA1D,EAAgE,EAAhE,CAAP;AACF;;AAED;;;;;;;;;;iCAOW,O,EAAS,E,EAAI;AACrB,gBAAO,KAAK,QAAL,CAAc,MAAd,EAAsB,aAAtB,EAAqC,OAArC,EAA8C,EAA9C,CAAP;AACF;;;;;;AAGJ,OAAO,OAAP,GAAiB,IAAjB","file":"generated.js","sourceRoot":"","sourcesContent":["(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require==\"function\"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error(\"Cannot find module '\"+o+\"'\");throw f.code=\"MODULE_NOT_FOUND\",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require==\"function\"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})","/**\n * @file\n * @copyright  2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license    Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n *             Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\n\n/**\n * A Gist can retrieve and modify gists.\n */\nclass Gist extends Requestable {\n   /**\n    * Create a Gist.\n    * @param {string} id - the id of the gist (not required when creating a gist)\n    * @param {Requestable.auth} [auth] - information required to authenticate to Github\n    * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n    */\n   constructor(id, auth, apiBase) {\n      super(auth, apiBase);\n      this.__id = id;\n   }\n\n   /**\n    * Fetch a gist.\n    * @see https://developer.github.com/v3/gists/#get-a-single-gist\n    * @param {Requestable.callback} [cb] - will receive the gist\n    * @return {Promise} - the Promise for the http request\n    */\n   read(cb) {\n      return this._request('GET', `/gists/${this.__id}`, null, cb);\n   }\n\n   /**\n    * Create a new gist.\n    * @see https://developer.github.com/v3/gists/#create-a-gist\n    * @param {Object} gist - the data for the new gist\n    * @param {Requestable.callback} [cb] - will receive the new gist upon creation\n    * @return {Promise} - the Promise for the http request\n    */\n   create(gist, cb) {\n      return this._request('POST', '/gists', gist, cb)\n         .then((response) => {\n            this.__id = response.data.id;\n            return response;\n         });\n   }\n\n   /**\n    * Delete a gist.\n    * @see https://developer.github.com/v3/gists/#delete-a-gist\n    * @param {Requestable.callback} [cb] - will receive true if the request succeeds\n    * @return {Promise} - the Promise for the http request\n    */\n   delete(cb) {\n      return this._request('DELETE', `/gists/${this.__id}`, null, cb);\n   }\n\n   /**\n    * Fork a gist.\n    * @see https://developer.github.com/v3/gists/#fork-a-gist\n    * @param {Requestable.callback} [cb] - the function that will receive the gist\n    * @return {Promise} - the Promise for the http request\n    */\n   fork(cb) {\n      return this._request('POST', `/gists/${this.__id}/forks`, null, cb);\n   }\n\n   /**\n    * Update a gist.\n    * @see https://developer.github.com/v3/gists/#edit-a-gist\n    * @param {Object} gist - the new data for the gist\n    * @param {Requestable.callback} [cb] - the function that receives the API result\n    * @return {Promise} - the Promise for the http request\n    */\n   update(gist, cb) {\n      return this._request('PATCH', `/gists/${this.__id}`, gist, cb);\n   }\n\n   /**\n    * Star a gist.\n    * @see https://developer.github.com/v3/gists/#star-a-gist\n    * @param {Requestable.callback} [cb] - will receive true if the request is successful\n    * @return {Promise} - the Promise for the http request\n    */\n   star(cb) {\n      return this._request('PUT', `/gists/${this.__id}/star`, null, cb);\n   }\n\n   /**\n    * Unstar a gist.\n    * @see https://developer.github.com/v3/gists/#unstar-a-gist\n    * @param {Requestable.callback} [cb] - will receive true if the request is successful\n    * @return {Promise} - the Promise for the http request\n    */\n   unstar(cb) {\n      return this._request('DELETE', `/gists/${this.__id}/star`, null, cb);\n   }\n\n   /**\n    * Check if a gist is starred by the user.\n    * @see https://developer.github.com/v3/gists/#check-if-a-gist-is-starred\n    * @param {Requestable.callback} [cb] - will receive true if the gist is starred and false if the gist is not starred\n    * @return {Promise} - the Promise for the http request\n    */\n   isStarred(cb) {\n      return this._request204or404(`/gists/${this.__id}/star`, null, cb);\n   }\n\n   /**\n    * List the gist's commits\n    * @see https://developer.github.com/v3/gists/#list-gist-commits\n    * @param {Requestable.callback} [cb] - will receive the array of commits\n    * @return {Promise} - the Promise for the http request\n    */\n   listCommits(cb) {\n      return this._requestAllPages(`/gists/${this.__id}/commits`, null, cb);\n   }\n\n   /**\n    * Fetch one of the gist's revision.\n    * @see https://developer.github.com/v3/gists/#get-a-specific-revision-of-a-gist\n    * @param {string} revision - the id of the revision\n    * @param {Requestable.callback} [cb] - will receive the revision\n    * @return {Promise} - the Promise for the http request\n    */\n   getRevision(revision, cb) {\n      return this._request('GET', `/gists/${this.__id}/${revision}`, null, cb);\n   }\n\n   /**\n    * List the gist's comments\n    * @see https://developer.github.com/v3/gists/comments/#list-comments-on-a-gist\n    * @param {Requestable.callback} [cb] - will receive the array of comments\n    * @return {Promise} - the promise for the http request\n    */\n   listComments(cb) {\n      return this._requestAllPages(`/gists/${this.__id}/comments`, null, cb);\n   }\n\n   /**\n    * Fetch one of the gist's comments\n    * @see https://developer.github.com/v3/gists/comments/#get-a-single-comment\n    * @param {number} comment - the id of the comment\n    * @param {Requestable.callback} [cb] - will receive the comment\n    * @return {Promise} - the Promise for the http request\n    */\n   getComment(comment, cb) {\n      return this._request('GET', `/gists/${this.__id}/comments/${comment}`, null, cb);\n   }\n\n   /**\n    * Comment on a gist\n    * @see https://developer.github.com/v3/gists/comments/#create-a-comment\n    * @param {string} comment - the comment to add\n    * @param {Requestable.callback} [cb] - the function that receives the API result\n    * @return {Promise} - the Promise for the http request\n    */\n   createComment(comment, cb) {\n      return this._request('POST', `/gists/${this.__id}/comments`, {body: comment}, cb);\n   }\n\n   /**\n    * Edit a comment on the gist\n    * @see https://developer.github.com/v3/gists/comments/#edit-a-comment\n    * @param {number} comment - the id of the comment\n    * @param {string} body - the new comment\n    * @param {Requestable.callback} [cb] - will receive the modified comment\n    * @return {Promise} - the promise for the http request\n    */\n   editComment(comment, body, cb) {\n      return this._request('PATCH', `/gists/${this.__id}/comments/${comment}`, {body: body}, cb);\n   }\n\n   /**\n    * Delete a comment on the gist.\n    * @see https://developer.github.com/v3/gists/comments/#delete-a-comment\n    * @param {number} comment - the id of the comment\n    * @param {Requestable.callback} [cb] - will receive true if the request succeeds\n    * @return {Promise} - the Promise for the http request\n    */\n   deleteComment(comment, cb) {\n      return this._request('DELETE', `/gists/${this.__id}/comments/${comment}`, null, cb);\n   }\n}\n\nmodule.exports = Gist;\n","/**\n * @file\n * @copyright  2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license    Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n *             Github.js is freely distributable.\n */\n/* eslint valid-jsdoc: [\"error\", {\"requireReturnDescription\": false}] */\n\nimport Gist from './Gist';\nimport User from './User';\nimport Issue from './Issue';\nimport Search from './Search';\nimport RateLimit from './RateLimit';\nimport Repository from './Repository';\nimport Organization from './Organization';\nimport Team from './Team';\nimport Markdown from './Markdown';\nimport Project from './Project';\n\n/**\n * GitHub encapsulates the functionality to create various API wrapper objects.\n */\nclass GitHub {\n   /**\n    * Create a new GitHub.\n    * @param {Requestable.auth} [auth] - the credentials to authenticate to Github. If auth is\n    *                                  not provided requests will be made unauthenticated\n    * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n    */\n   constructor(auth, apiBase = 'https://api.github.com') {\n      this.__apiBase = apiBase;\n      this.__auth = auth || {};\n   }\n\n   /**\n    * Create a new Gist wrapper\n    * @param {number} [id] - the id for the gist, leave undefined when creating a new gist\n    * @return {Gist}\n    */\n   getGist(id) {\n      return new Gist(id, this.__auth, this.__apiBase);\n   }\n\n   /**\n    * Create a new User wrapper\n    * @param {string} [user] - the name of the user to get information about\n    *                        leave undefined for the authenticated user\n    * @return {User}\n    */\n   getUser(user) {\n      return new User(user, this.__auth, this.__apiBase);\n   }\n\n   /**\n    * Create a new Organization wrapper\n    * @param {string} organization - the name of the organization\n    * @return {Organization}\n    */\n   getOrganization(organization) {\n      return new Organization(organization, this.__auth, this.__apiBase);\n   }\n\n   /**\n    * create a new Team wrapper\n    * @param {string} teamId - the name of the team\n    * @return {team}\n    */\n   getTeam(teamId) {\n      return new Team(teamId, this.__auth, this.__apiBase);\n   }\n\n   /**\n    * Create a new Repository wrapper\n    * @param {string} user - the user who owns the respository\n    * @param {string} repo - the name of the repository\n    * @return {Repository}\n    */\n   getRepo(user, repo) {\n      return new Repository(this._getFullName(user, repo), this.__auth, this.__apiBase);\n   }\n\n   /**\n    * Create a new Issue wrapper\n    * @param {string} user - the user who owns the respository\n    * @param {string} repo - the name of the repository\n    * @return {Issue}\n    */\n   getIssues(user, repo) {\n      return new Issue(this._getFullName(user, repo), this.__auth, this.__apiBase);\n   }\n\n   /**\n    * Create a new Search wrapper\n    * @param {string} query - the query to search for\n    * @return {Search}\n    */\n   search(query) {\n      return new Search(query, this.__auth, this.__apiBase);\n   }\n\n   /**\n    * Create a new RateLimit wrapper\n    * @return {RateLimit}\n    */\n   getRateLimit() {\n      return new RateLimit(this.__auth, this.__apiBase);\n   }\n\n   /**\n    * Create a new Markdown wrapper\n    * @return {Markdown}\n    */\n   getMarkdown() {\n      return new Markdown(this.__auth, this.__apiBase);\n   }\n\n   /**\n    * Create a new Project wrapper\n    * @param {string} id - the id of the project\n    * @return {Markdown}\n    */\n   getProject(id) {\n      return new Project(id, this.__auth, this.__apiBase);\n   }\n\n   /**\n    * Computes the full repository name\n    * @param {string} user - the username (or the full name)\n    * @param {string} repo - the repository name, must not be passed if `user` is the full name\n    * @return {string} the repository's full name\n    */\n   _getFullName(user, repo) {\n      let fullname = user;\n\n      if (repo) {\n         fullname = `${user}/${repo}`;\n      }\n\n      return fullname;\n   }\n}\n\nmodule.exports = GitHub;\n","/**\n * @file\n * @copyright  2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license    Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n *             Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\n\n/**\n * Issue wraps the functionality to get issues for repositories\n */\nclass Issue extends Requestable {\n   /**\n    * Create a new Issue\n    * @param {string} repository - the full name of the repository (`:user/:repo`) to get issues for\n    * @param {Requestable.auth} [auth] - information required to authenticate to Github\n    * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n    */\n   constructor(repository, auth, apiBase) {\n      super(auth, apiBase);\n      this.__repository = repository;\n   }\n\n   /**\n    * Create a new issue\n    * @see https://developer.github.com/v3/issues/#create-an-issue\n    * @param {Object} issueData - the issue to create\n    * @param {Requestable.callback} [cb] - will receive the created issue\n    * @return {Promise} - the promise for the http request\n    */\n   createIssue(issueData, cb) {\n      return this._request('POST', `/repos/${this.__repository}/issues`, issueData, cb);\n   }\n\n   /**\n    * List the issues for the repository\n    * @see https://developer.github.com/v3/issues/#list-issues-for-a-repository\n    * @param {Object} options - filtering options\n    * @param {Requestable.callback} [cb] - will receive the array of issues\n    * @return {Promise} - the promise for the http request\n    */\n   listIssues(options, cb) {\n      return this._requestAllPages(`/repos/${this.__repository}/issues`, options, cb);\n   }\n\n   /**\n    * List the events for an issue\n    * @see https://developer.github.com/v3/issues/events/#list-events-for-an-issue\n    * @param {number} issue - the issue to get events for\n    * @param {Requestable.callback} [cb] - will receive the list of events\n    * @return {Promise} - the promise for the http request\n    */\n   listIssueEvents(issue, cb) {\n      return this._request('GET', `/repos/${this.__repository}/issues/${issue}/events`, null, cb);\n   }\n\n   /**\n    * List comments on an issue\n    * @see https://developer.github.com/v3/issues/comments/#list-comments-on-an-issue\n    * @param {number} issue - the id of the issue to get comments from\n    * @param {Requestable.callback} [cb] - will receive the comments\n    * @return {Promise} - the promise for the http request\n    */\n   listIssueComments(issue, cb) {\n      return this._request('GET', `/repos/${this.__repository}/issues/${issue}/comments`, null, cb);\n   }\n\n   /**\n    * Get a single comment on an issue\n    * @see https://developer.github.com/v3/issues/comments/#get-a-single-comment\n    * @param {number} id - the comment id to get\n    * @param {Requestable.callback} [cb] - will receive the comment\n    * @return {Promise} - the promise for the http request\n    */\n   getIssueComment(id, cb) {\n      return this._request('GET', `/repos/${this.__repository}/issues/comments/${id}`, null, cb);\n   }\n\n   /**\n    * Comment on an issue\n    * @see https://developer.github.com/v3/issues/comments/#create-a-comment\n    * @param {number} issue - the id of the issue to comment on\n    * @param {string} comment - the comment to add\n    * @param {Requestable.callback} [cb] - will receive the created comment\n    * @return {Promise} - the promise for the http request\n    */\n   createIssueComment(issue, comment, cb) {\n      return this._request('POST', `/repos/${this.__repository}/issues/${issue}/comments`, {body: comment}, cb);\n   }\n\n   /**\n    * Edit a comment on an issue\n    * @see https://developer.github.com/v3/issues/comments/#edit-a-comment\n    * @param {number} id - the comment id to edit\n    * @param {string} comment - the comment to edit\n    * @param {Requestable.callback} [cb] - will receive the edited comment\n    * @return {Promise} - the promise for the http request\n    */\n   editIssueComment(id, comment, cb) {\n      return this._request('PATCH', `/repos/${this.__repository}/issues/comments/${id}`, {body: comment}, cb);\n   }\n\n   /**\n    * Delete a comment on an issue\n    * @see https://developer.github.com/v3/issues/comments/#delete-a-comment\n    * @param {number} id - the comment id to delete\n    * @param {Requestable.callback} [cb] - will receive true if the request is successful\n    * @return {Promise} - the promise for the http request\n    */\n   deleteIssueComment(id, cb) {\n      return this._request('DELETE', `/repos/${this.__repository}/issues/comments/${id}`, null, cb);\n   }\n\n   /**\n    * Edit an issue\n    * @see https://developer.github.com/v3/issues/#edit-an-issue\n    * @param {number} issue - the issue number to edit\n    * @param {Object} issueData - the new issue data\n    * @param {Requestable.callback} [cb] - will receive the modified issue\n    * @return {Promise} - the promise for the http request\n    */\n   editIssue(issue, issueData, cb) {\n      return this._request('PATCH', `/repos/${this.__repository}/issues/${issue}`, issueData, cb);\n   }\n\n   /**\n    * Get a particular issue\n    * @see https://developer.github.com/v3/issues/#get-a-single-issue\n    * @param {number} issue - the issue number to fetch\n    * @param {Requestable.callback} [cb] - will receive the issue\n    * @return {Promise} - the promise for the http request\n    */\n   getIssue(issue, cb) {\n      return this._request('GET', `/repos/${this.__repository}/issues/${issue}`, null, cb);\n   }\n\n   /**\n    * List the milestones for the repository\n    * @see https://developer.github.com/v3/issues/milestones/#list-milestones-for-a-repository\n    * @param {Object} options - filtering options\n    * @param {Requestable.callback} [cb] - will receive the array of milestones\n    * @return {Promise} - the promise for the http request\n    */\n   listMilestones(options, cb) {\n      return this._request('GET', `/repos/${this.__repository}/milestones`, options, cb);\n   }\n\n   /**\n    * Get a milestone\n    * @see https://developer.github.com/v3/issues/milestones/#get-a-single-milestone\n    * @param {string} milestone - the id of the milestone to fetch\n    * @param {Requestable.callback} [cb] - will receive the milestone\n    * @return {Promise} - the promise for the http request\n    */\n   getMilestone(milestone, cb) {\n      return this._request('GET', `/repos/${this.__repository}/milestones/${milestone}`, null, cb);\n   }\n\n   /**\n    * Create a new milestone\n    * @see https://developer.github.com/v3/issues/milestones/#create-a-milestone\n    * @param {Object} milestoneData - the milestone definition\n    * @param {Requestable.callback} [cb] - will receive the milestone\n    * @return {Promise} - the promise for the http request\n    */\n   createMilestone(milestoneData, cb) {\n      return this._request('POST', `/repos/${this.__repository}/milestones`, milestoneData, cb);\n   }\n\n   /**\n    * Edit a milestone\n    * @see https://developer.github.com/v3/issues/milestones/#update-a-milestone\n    * @param {string} milestone - the id of the milestone to edit\n    * @param {Object} milestoneData - the updates to make to the milestone\n    * @param {Requestable.callback} [cb] - will receive the updated milestone\n    * @return {Promise} - the promise for the http request\n    */\n   editMilestone(milestone, milestoneData, cb) {\n      return this._request('PATCH', `/repos/${this.__repository}/milestones/${milestone}`, milestoneData, cb);\n   }\n\n   /**\n    * Delete a milestone (this is distinct from closing a milestone)\n    * @see https://developer.github.com/v3/issues/milestones/#delete-a-milestone\n    * @param {string} milestone - the id of the milestone to delete\n    * @param {Requestable.callback} [cb] - will receive the status\n    * @return {Promise} - the promise for the http request\n    */\n   deleteMilestone(milestone, cb) {\n      return this._request('DELETE', `/repos/${this.__repository}/milestones/${milestone}`, null, cb);\n   }\n\n   /**\n    * Create a new label\n    * @see https://developer.github.com/v3/issues/labels/#create-a-label\n    * @param {Object} labelData - the label definition\n    * @param {Requestable.callback} [cb] - will receive the object representing the label\n    * @return {Promise} - the promise for the http request\n    */\n   createLabel(labelData, cb) {\n      return this._request('POST', `/repos/${this.__repository}/labels`, labelData, cb);\n   }\n\n  /**\n   * List the labels for the repository\n   * @see https://developer.github.com/v3/issues/labels/#list-all-labels-for-this-repository\n   * @param {Object} options - filtering options\n   * @param {Requestable.callback} [cb] - will receive the array of labels\n   * @return {Promise} - the promise for the http request\n   */\n   listLabels(options, cb) {\n      return this._request('GET', `/repos/${this.__repository}/labels`, options, cb);\n   }\n\n  /**\n   * Get a label\n   * @see https://developer.github.com/v3/issues/labels/#get-a-single-label\n   * @param {string} label - the name of the label to fetch\n   * @param {Requestable.callback} [cb] - will receive the label\n   * @return {Promise} - the promise for the http request\n   */\n   getLabel(label, cb) {\n      return this._request('GET', `/repos/${this.__repository}/labels/${label}`, null, cb);\n   }\n\n  /**\n   * Edit a label\n   * @see https://developer.github.com/v3/issues/labels/#update-a-label\n   * @param {string} label - the name of the label to edit\n   * @param {Object} labelData - the updates to make to the label\n   * @param {Requestable.callback} [cb] - will receive the updated label\n   * @return {Promise} - the promise for the http request\n   */\n   editLabel(label, labelData, cb) {\n      return this._request('PATCH', `/repos/${this.__repository}/labels/${label}`, labelData, cb);\n   }\n\n  /**\n   * Delete a label\n   * @see https://developer.github.com/v3/issues/labels/#delete-a-label\n   * @param {string} label - the name of the label to delete\n   * @param {Requestable.callback} [cb] - will receive the status\n   * @return {Promise} - the promise for the http request\n   */\n   deleteLabel(label, cb) {\n      return this._request('DELETE', `/repos/${this.__repository}/labels/${label}`, null, cb);\n   }\n}\n\nmodule.exports = Issue;\n","/**\n * @file\n * @copyright  2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license    Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n *             Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\n\n/**\n * Renders html from Markdown text\n */\nclass Markdown extends Requestable {\n   /**\n    * construct a Markdown\n    * @param {Requestable.auth} auth - the credentials to authenticate to GitHub\n    * @param {string} [apiBase] - the base Github API URL\n    * @return {Promise} - the promise for the http request\n    */\n   constructor(auth, apiBase) {\n      super(auth, apiBase);\n   }\n\n   /**\n    * Render html from Markdown text.\n    * @see https://developer.github.com/v3/markdown/#render-an-arbitrary-markdown-document\n    * @param {Object} options - conversion options\n    * @param {string} [options.text] - the markdown text to convert\n    * @param {string} [options.mode=markdown] - can be either `markdown` or `gfm`\n    * @param {string} [options.context] - repository name if mode is gfm\n    * @param {Requestable.callback} [cb] - will receive the converted html\n    * @return {Promise} - the promise for the http request\n    */\n   render(options, cb) {\n      return this._request('POST', '/markdown', options, cb);\n   }\n}\n\nmodule.exports = Markdown;\n","/**\n * @file\n * @copyright  2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license    Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n *             Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\n\n/**\n * Organization encapsulates the functionality to create repositories in organizations\n */\nclass Organization extends Requestable {\n   /**\n    * Create a new Organization\n    * @param {string} organization - the name of the organization\n    * @param {Requestable.auth} [auth] - information required to authenticate to Github\n    * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n    */\n   constructor(organization, auth, apiBase) {\n      super(auth, apiBase);\n      this.__name = organization;\n   }\n\n   /**\n    * Create a repository in an organization\n    * @see https://developer.github.com/v3/repos/#create\n    * @param {Object} options - the repository definition\n    * @param {Requestable.callback} [cb] - will receive the created repository\n    * @return {Promise} - the promise for the http request\n    */\n   createRepo(options, cb) {\n      return this._request('POST', `/orgs/${this.__name}/repos`, options, cb);\n   }\n\n   /**\n    * List the repositories in an organization\n    * @see https://developer.github.com/v3/repos/#list-organization-repositories\n    * @param {Requestable.callback} [cb] - will receive the list of repositories\n    * @return {Promise} - the promise for the http request\n    */\n   getRepos(cb) {\n      let requestOptions = this._getOptionsWithDefaults({direction: 'desc'});\n\n      return this._requestAllPages(`/orgs/${this.__name}/repos`, requestOptions, cb);\n   }\n\n   /**\n    * Query if the user is a member or not\n    * @param {string} username - the user in question\n    * @param {Requestable.callback} [cb] - will receive true if the user is a member\n    * @return {Promise} - the promise for the http request\n    */\n   isMember(username, cb) {\n      return this._request204or404(`/orgs/${this.__name}/members/${username}`, null, cb);\n   }\n\n   /**\n    * List the users who are members of the company\n    * @see https://developer.github.com/v3/orgs/members/#members-list\n    * @param {object} options - filtering options\n    * @param {string} [options.filter=all] - can be either `2fa_disabled` or `all`\n    * @param {string} [options.role=all] - can be one of: `all`, `admin`, or `member`\n    * @param {Requestable.callback} [cb] - will receive the list of users\n    * @return {Promise} - the promise for the http request\n    */\n   listMembers(options, cb) {\n      return this._request('GET', `/orgs/${this.__name}/members`, options, cb);\n   }\n\n   /**\n    * List the Teams in the Organization\n    * @see https://developer.github.com/v3/orgs/teams/#list-teams\n    * @param {Requestable.callback} [cb] - will receive the list of teams\n    * @return {Promise} - the promise for the http request\n    */\n   getTeams(cb) {\n      return this._requestAllPages(`/orgs/${this.__name}/teams`, undefined, cb);\n   }\n\n   /**\n    * Create a team\n    * @see https://developer.github.com/v3/orgs/teams/#create-team\n    * @param {object} options - Team creation parameters\n    * @param {string} options.name - The name of the team\n    * @param {string} [options.description] - Team description\n    * @param {string} [options.repo_names] - Repos to add the team to\n    * @param {string} [options.privacy=secret] - The level of privacy the team should have. Can be either one\n    * of: `secret`, or `closed`\n    * @param {Requestable.callback} [cb] - will receive the created team\n    * @return {Promise} - the promise for the http request\n    */\n   createTeam(options, cb) {\n      return this._request('POST', `/orgs/${this.__name}/teams`, options, cb);\n   }\n\n   /**\n    * Get information about all projects\n    * @see https://developer.github.com/v3/projects/#list-organization-projects\n    * @param {Requestable.callback} [cb] - will receive the list of projects\n    * @return {Promise} - the promise for the http request\n    */\n   listProjects(cb) {\n      return this._requestAllPages(`/orgs/${this.__name}/projects`, {AcceptHeader: 'inertia-preview'}, cb);\n   }\n\n   /**\n    * Create a new project\n    * @see https://developer.github.com/v3/repos/projects/#create-a-project\n    * @param {Object} options - the description of the project\n    * @param {Requestable.callback} cb - will receive the newly created project\n    * @return {Promise} - the promise for the http request\n    */\n   createProject(options, cb) {\n      options = options || {};\n      options.AcceptHeader = 'inertia-preview';\n      return this._request('POST', `/orgs/${this.__name}/projects`, options, cb);\n   }\n}\n\nmodule.exports = Organization;\n","/**\n * @file\n * @copyright  2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license    Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n *             Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\n\n/**\n * Project encapsulates the functionality to create, query, and modify cards and columns.\n */\nclass Project extends Requestable {\n   /**\n    * Create a Project.\n    * @param {string} id - the id of the project\n    * @param {Requestable.auth} [auth] - information required to authenticate to Github\n    * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n    */\n   constructor(id, auth, apiBase) {\n      super(auth, apiBase, 'inertia-preview');\n      this.__id = id;\n   }\n\n   /**\n    * Get information about a project\n    * @see https://developer.github.com/v3/projects/#get-a-project\n    * @param {Requestable.callback} cb - will receive the project information\n    * @return {Promise} - the promise for the http request\n    */\n   getProject(cb) {\n      return this._request('GET', `/projects/${this.__id}`, null, cb);\n   }\n\n   /**\n    * Edit a project\n    * @see https://developer.github.com/v3/projects/#update-a-project\n    * @param {Object} options - the description of the project\n    * @param {Requestable.callback} cb - will receive the modified project\n    * @return {Promise} - the promise for the http request\n    */\n   updateProject(options, cb) {\n      return this._request('PATCH', `/projects/${this.__id}`, options, cb);\n   }\n\n   /**\n    * Delete a project\n    * @see https://developer.github.com/v3/projects/#delete-a-project\n    * @param {Requestable.callback} cb - will receive true if the operation is successful\n    * @return {Promise} - the promise for the http request\n    */\n   deleteProject(cb) {\n      return this._request('DELETE', `/projects/${this.__id}`, null, cb);\n   }\n\n   /**\n    * Get information about all columns of a project\n    * @see https://developer.github.com/v3/projects/columns/#list-project-columns\n    * @param {Requestable.callback} [cb] - will receive the list of columns\n    * @return {Promise} - the promise for the http request\n    */\n   listProjectColumns(cb) {\n      return this._requestAllPages(`/projects/${this.__id}/columns`, null, cb);\n   }\n\n   /**\n    * Get information about a column\n    * @see https://developer.github.com/v3/projects/columns/#get-a-project-column\n    * @param {string} colId - the id of the column\n    * @param {Requestable.callback} cb - will receive the column information\n    * @return {Promise} - the promise for the http request\n    */\n   getProjectColumn(colId, cb) {\n      return this._request('GET', `/projects/columns/${colId}`, null, cb);\n   }\n\n   /**\n    * Create a new column\n    * @see https://developer.github.com/v3/projects/columns/#create-a-project-column\n    * @param {Object} options - the description of the column\n    * @param {Requestable.callback} cb - will receive the newly created column\n    * @return {Promise} - the promise for the http request\n    */\n   createProjectColumn(options, cb) {\n      return this._request('POST', `/projects/${this.__id}/columns`, options, cb);\n   }\n\n   /**\n    * Edit a column\n    * @see https://developer.github.com/v3/projects/columns/#update-a-project-column\n    * @param {string} colId - the column id\n    * @param {Object} options - the description of the column\n    * @param {Requestable.callback} cb - will receive the modified column\n    * @return {Promise} - the promise for the http request\n    */\n   updateProjectColumn(colId, options, cb) {\n      return this._request('PATCH', `/projects/columns/${colId}`, options, cb);\n   }\n\n   /**\n    * Delete a column\n    * @see https://developer.github.com/v3/projects/columns/#delete-a-project-column\n    * @param {string} colId - the column to be deleted\n    * @param {Requestable.callback} cb - will receive true if the operation is successful\n    * @return {Promise} - the promise for the http request\n    */\n   deleteProjectColumn(colId, cb) {\n      return this._request('DELETE', `/projects/columns/${colId}`, null, cb);\n   }\n\n   /**\n    * Move a column\n    * @see https://developer.github.com/v3/projects/columns/#move-a-project-column\n    * @param {string} colId - the column to be moved\n    * @param {string} position - can be one of first, last, or after:<column-id>,\n    * where <column-id> is the id value of a column in the same project.\n    * @param {Requestable.callback} cb - will receive true if the operation is successful\n    * @return {Promise} - the promise for the http request\n    */\n   moveProjectColumn(colId, position, cb) {\n      return this._request(\n         'POST',\n         `/projects/columns/${colId}/moves`,\n         {position: position},\n         cb\n      );\n   }\n\n  /**\n   * Get information about all cards of a project\n   * @see https://developer.github.com/v3/projects/cards/#list-project-cards\n   * @param {Requestable.callback} [cb] - will receive the list of cards\n   * @return {Promise} - the promise for the http request\n   */\n   listProjectCards(cb) {\n      return this.listProjectColumns()\n        .then(({data}) => {\n           return Promise.all(data.map((column) => {\n              return this._requestAllPages(`/projects/columns/${column.id}/cards`, null);\n           }));\n        }).then((cardsInColumns) => {\n           const cards = cardsInColumns.reduce((prev, {data}) => {\n              prev.push(...data);\n              return prev;\n           }, []);\n           if (cb) {\n              cb(null, cards);\n           }\n           return cards;\n        }).catch((err) => {\n           if (cb) {\n              cb(err);\n              return;\n           }\n           throw err;\n        });\n   }\n\n   /**\n   * Get information about all cards of a column\n   * @see https://developer.github.com/v3/projects/cards/#list-project-cards\n   * @param {string} colId - the id of the column\n   * @param {Requestable.callback} [cb] - will receive the list of cards\n   * @return {Promise} - the promise for the http request\n   */\n   listColumnCards(colId, cb) {\n      return this._requestAllPages(`/projects/columns/${colId}/cards`, null, cb);\n   }\n\n   /**\n   * Get information about a card\n   * @see https://developer.github.com/v3/projects/cards/#get-a-project-card\n   * @param {string} cardId - the id of the card\n   * @param {Requestable.callback} cb - will receive the card information\n   * @return {Promise} - the promise for the http request\n   */\n   getProjectCard(cardId, cb) {\n      return this._request('GET', `/projects/columns/cards/${cardId}`, null, cb);\n   }\n\n   /**\n   * Create a new card\n   * @see https://developer.github.com/v3/projects/cards/#create-a-project-card\n   * @param {string} colId - the column id\n   * @param {Object} options - the description of the card\n   * @param {Requestable.callback} cb - will receive the newly created card\n   * @return {Promise} - the promise for the http request\n   */\n   createProjectCard(colId, options, cb) {\n      return this._request('POST', `/projects/columns/${colId}/cards`, options, cb);\n   }\n\n   /**\n   * Edit a card\n   * @see https://developer.github.com/v3/projects/cards/#update-a-project-card\n   * @param {string} cardId - the card id\n   * @param {Object} options - the description of the card\n   * @param {Requestable.callback} cb - will receive the modified card\n   * @return {Promise} - the promise for the http request\n   */\n   updateProjectCard(cardId, options, cb) {\n      return this._request('PATCH', `/projects/columns/cards/${cardId}`, options, cb);\n   }\n\n   /**\n   * Delete a card\n   * @see https://developer.github.com/v3/projects/cards/#delete-a-project-card\n   * @param {string} cardId - the card to be deleted\n   * @param {Requestable.callback} cb - will receive true if the operation is successful\n   * @return {Promise} - the promise for the http request\n   */\n   deleteProjectCard(cardId, cb) {\n      return this._request('DELETE', `/projects/columns/cards/${cardId}`, null, cb);\n   }\n\n   /**\n   * Move a card\n   * @see https://developer.github.com/v3/projects/cards/#move-a-project-card\n   * @param {string} cardId - the card to be moved\n   * @param {string} position - can be one of top, bottom, or after:<card-id>,\n   * where <card-id> is the id value of a card in the same project.\n   * @param {string} colId - the id value of a column in the same project.\n   * @param {Requestable.callback} cb - will receive true if the operation is successful\n   * @return {Promise} - the promise for the http request\n   */\n   moveProjectCard(cardId, position, colId, cb) {\n      return this._request(\n         'POST',\n         `/projects/columns/cards/${cardId}/moves`,\n         {position: position, column_id: colId}, // eslint-disable-line camelcase\n         cb\n      );\n   }\n}\n\nmodule.exports = Project;\n","/**\n * @file\n * @copyright  2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license    Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n *             Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\n\n/**\n * RateLimit allows users to query their rate-limit status\n */\nclass RateLimit extends Requestable {\n   /**\n    * construct a RateLimit\n    * @param {Requestable.auth} auth - the credentials to authenticate to GitHub\n    * @param {string} [apiBase] - the base Github API URL\n    * @return {Promise} - the promise for the http request\n    */\n   constructor(auth, apiBase) {\n      super(auth, apiBase);\n   }\n\n   /**\n    * Query the current rate limit\n    * @see https://developer.github.com/v3/rate_limit/\n    * @param {Requestable.callback} [cb] - will receive the rate-limit data\n    * @return {Promise} - the promise for the http request\n    */\n   getRateLimit(cb) {\n      return this._request('GET', '/rate_limit', null, cb);\n   }\n}\n\nmodule.exports = RateLimit;\n","/**\n * @file\n * @copyright  2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license    Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n *             Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\nimport Utf8 from 'utf8';\nimport {\n   Base64,\n} from 'js-base64';\nimport debug from 'debug';\nconst log = debug('github:repository');\n\n/**\n * Respository encapsulates the functionality to create, query, and modify files.\n */\nclass Repository extends Requestable {\n   /**\n    * Create a Repository.\n    * @param {string} fullname - the full name of the repository\n    * @param {Requestable.auth} [auth] - information required to authenticate to Github\n    * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n    */\n   constructor(fullname, auth, apiBase) {\n      super(auth, apiBase);\n      this.__fullname = fullname;\n      this.__currentTree = {\n         branch: null,\n         sha: null,\n      };\n   }\n\n   /**\n    * Get a reference\n    * @see https://developer.github.com/v3/git/refs/#get-a-reference\n    * @param {string} ref - the reference to get\n    * @param {Requestable.callback} [cb] - will receive the reference's refSpec or a list of refSpecs that match `ref`\n    * @return {Promise} - the promise for the http request\n    */\n   getRef(ref, cb) {\n      return this._request('GET', `/repos/${this.__fullname}/git/refs/${ref}`, null, cb);\n   }\n\n   /**\n    * Create a reference\n    * @see https://developer.github.com/v3/git/refs/#create-a-reference\n    * @param {Object} options - the object describing the ref\n    * @param {Requestable.callback} [cb] - will receive the ref\n    * @return {Promise} - the promise for the http request\n    */\n   createRef(options, cb) {\n      return this._request('POST', `/repos/${this.__fullname}/git/refs`, options, cb);\n   }\n\n   /**\n    * Delete a reference\n    * @see https://developer.github.com/v3/git/refs/#delete-a-reference\n    * @param {string} ref - the name of the ref to delte\n    * @param {Requestable.callback} [cb] - will receive true if the request is successful\n    * @return {Promise} - the promise for the http request\n    */\n   deleteRef(ref, cb) {\n      return this._request('DELETE', `/repos/${this.__fullname}/git/refs/${ref}`, null, cb);\n   }\n\n   /**\n    * Delete a repository\n    * @see https://developer.github.com/v3/repos/#delete-a-repository\n    * @param {Requestable.callback} [cb] - will receive true if the request is successful\n    * @return {Promise} - the promise for the http request\n    */\n   deleteRepo(cb) {\n      return this._request('DELETE', `/repos/${this.__fullname}`, null, cb);\n   }\n\n   /**\n    * List the tags on a repository\n    * @see https://developer.github.com/v3/repos/#list-tags\n    * @param {Requestable.callback} [cb] - will receive the tag data\n    * @return {Promise} - the promise for the http request\n    */\n   listTags(cb) {\n      return this._request('GET', `/repos/${this.__fullname}/tags`, null, cb);\n   }\n\n   /**\n    * List the open pull requests on the repository\n    * @see https://developer.github.com/v3/pulls/#list-pull-requests\n    * @param {Object} options - options to filter the search\n    * @param {Requestable.callback} [cb] - will receive the list of PRs\n    * @return {Promise} - the promise for the http request\n    */\n   listPullRequests(options, cb) {\n      options = options || {};\n      return this._request('GET', `/repos/${this.__fullname}/pulls`, options, cb);\n   }\n\n   /**\n    * Get information about a specific pull request\n    * @see https://developer.github.com/v3/pulls/#get-a-single-pull-request\n    * @param {number} number - the PR you wish to fetch\n    * @param {Requestable.callback} [cb] - will receive the PR from the API\n    * @return {Promise} - the promise for the http request\n    */\n   getPullRequest(number, cb) {\n      return this._request('GET', `/repos/${this.__fullname}/pulls/${number}`, null, cb);\n   }\n\n   /**\n    * List the files of a specific pull request\n    * @see https://developer.github.com/v3/pulls/#list-pull-requests-files\n    * @param {number|string} number - the PR you wish to fetch\n    * @param {Requestable.callback} [cb] - will receive the list of files from the API\n    * @return {Promise} - the promise for the http request\n    */\n   listPullRequestFiles(number, cb) {\n      return this._request('GET', `/repos/${this.__fullname}/pulls/${number}/files`, null, cb);\n   }\n\n   /**\n    * Compare two branches/commits/repositories\n    * @see https://developer.github.com/v3/repos/commits/#compare-two-commits\n    * @param {string} base - the base commit\n    * @param {string} head - the head commit\n    * @param {Requestable.callback} cb - will receive the comparison\n    * @return {Promise} - the promise for the http request\n    */\n   compareBranches(base, head, cb) {\n      return this._request('GET', `/repos/${this.__fullname}/compare/${base}...${head}`, null, cb);\n   }\n\n   /**\n    * List all the branches for the repository\n    * @see https://developer.github.com/v3/repos/#list-branches\n    * @param {Requestable.callback} cb - will receive the list of branches\n    * @return {Promise} - the promise for the http request\n    */\n   listBranches(cb) {\n      return this._request('GET', `/repos/${this.__fullname}/branches`, null, cb);\n   }\n\n   /**\n    * Get a raw blob from the repository\n    * @see https://developer.github.com/v3/git/blobs/#get-a-blob\n    * @param {string} sha - the sha of the blob to fetch\n    * @param {Requestable.callback} cb - will receive the blob from the API\n    * @return {Promise} - the promise for the http request\n    */\n   getBlob(sha, cb) {\n      return this._request('GET', `/repos/${this.__fullname}/git/blobs/${sha}`, null, cb, 'raw');\n   }\n\n   /**\n    * Get a single branch\n    * @see https://developer.github.com/v3/repos/branches/#get-branch\n    * @param {string} branch - the name of the branch to fetch\n    * @param {Requestable.callback} cb - will receive the branch from the API\n    * @returns {Promise} - the promise for the http request\n    */\n   getBranch(branch, cb) {\n      return this._request('GET', `/repos/${this.__fullname}/branches/${branch}`, null, cb);\n   }\n\n   /**\n    * Get a commit from the repository\n    * @see https://developer.github.com/v3/repos/commits/#get-a-single-commit\n    * @param {string} sha - the sha for the commit to fetch\n    * @param {Requestable.callback} cb - will receive the commit data\n    * @return {Promise} - the promise for the http request\n    */\n   getCommit(sha, cb) {\n      return this._request('GET', `/repos/${this.__fullname}/git/commits/${sha}`, null, cb);\n   }\n\n   /**\n    * List the commits on a repository, optionally filtering by path, author or time range\n    * @see https://developer.github.com/v3/repos/commits/#list-commits-on-a-repository\n    * @param {Object} [options] - the filtering options for commits\n    * @param {string} [options.sha] - the SHA or branch to start from\n    * @param {string} [options.path] - the path to search on\n    * @param {string} [options.author] - the commit author\n    * @param {(Date|string)} [options.since] - only commits after this date will be returned\n    * @param {(Date|string)} [options.until] - only commits before this date will be returned\n    * @param {Requestable.callback} cb - will receive the list of commits found matching the criteria\n    * @return {Promise} - the promise for the http request\n    */\n   listCommits(options, cb) {\n      options = options || {};\n\n      options.since = this._dateToISO(options.since);\n      options.until = this._dateToISO(options.until);\n\n      return this._request('GET', `/repos/${this.__fullname}/commits`, options, cb);\n   }\n\n    /**\n     * Gets a single commit information for a repository\n     * @see https://developer.github.com/v3/repos/commits/#get-a-single-commit\n     * @param {string} ref - the reference for the commit-ish\n     * @param {Requestable.callback} cb - will receive the commit information\n     * @return {Promise} - the promise for the http request\n     */\n   getSingleCommit(ref, cb) {\n      ref = ref || '';\n      return this._request('GET', `/repos/${this.__fullname}/commits/${ref}`, null, cb);\n   }\n\n   /**\n    * Get tha sha for a particular object in the repository. This is a convenience function\n    * @see https://developer.github.com/v3/repos/contents/#get-contents\n    * @param {string} [branch] - the branch to look in, or the repository's default branch if omitted\n    * @param {string} path - the path of the file or directory\n    * @param {Requestable.callback} cb - will receive a description of the requested object, including a `SHA` property\n    * @return {Promise} - the promise for the http request\n    */\n   getSha(branch, path, cb) {\n      branch = branch ? `?ref=${branch}` : '';\n      return this._request('GET', `/repos/${this.__fullname}/contents/${path}${branch}`, null, cb);\n   }\n\n   /**\n    * List the commit statuses for a particular sha, branch, or tag\n    * @see https://developer.github.com/v3/repos/statuses/#list-statuses-for-a-specific-ref\n    * @param {string} sha - the sha, branch, or tag to get statuses for\n    * @param {Requestable.callback} cb - will receive the list of statuses\n    * @return {Promise} - the promise for the http request\n    */\n   listStatuses(sha, cb) {\n      return this._request('GET', `/repos/${this.__fullname}/commits/${sha}/statuses`, null, cb);\n   }\n\n   /**\n    * Get a description of a git tree\n    * @see https://developer.github.com/v3/git/trees/#get-a-tree\n    * @param {string} treeSHA - the SHA of the tree to fetch\n    * @param {Requestable.callback} cb - will receive the callback data\n    * @return {Promise} - the promise for the http request\n    */\n   getTree(treeSHA, cb) {\n      return this._request('GET', `/repos/${this.__fullname}/git/trees/${treeSHA}`, null, cb);\n   }\n\n   /**\n    * Create a blob\n    * @see https://developer.github.com/v3/git/blobs/#create-a-blob\n    * @param {(string|Buffer|Blob)} content - the content to add to the repository\n    * @param {Requestable.callback} cb - will receive the details of the created blob\n    * @return {Promise} - the promise for the http request\n    */\n   createBlob(content, cb) {\n      let postBody = this._getContentObject(content);\n\n      log('sending content', postBody);\n      return this._request('POST', `/repos/${this.__fullname}/git/blobs`, postBody, cb);\n   }\n\n   /**\n    * Get the object that represents the provided content\n    * @param {string|Buffer|Blob} content - the content to send to the server\n    * @return {Object} the representation of `content` for the GitHub API\n    */\n   _getContentObject(content) {\n      if (typeof content === 'string') {\n         log('contet is a string');\n         return {\n            content: Utf8.encode(content),\n            encoding: 'utf-8',\n         };\n\n      } else if (typeof Buffer !== 'undefined' && content instanceof Buffer) {\n         log('We appear to be in Node');\n         return {\n            content: content.toString('base64'),\n            encoding: 'base64',\n         };\n\n      } else if (typeof Blob !== 'undefined' && content instanceof Blob) {\n         log('We appear to be in the browser');\n         return {\n            content: Base64.encode(content),\n            encoding: 'base64',\n         };\n\n      } else { // eslint-disable-line\n         log(`Not sure what this content is: ${typeof content}, ${JSON.stringify(content)}`);\n         throw new Error('Unknown content passed to postBlob. Must be string or Buffer (node) or Blob (web)');\n      }\n   }\n\n   /**\n    * Update a tree in Git\n    * @see https://developer.github.com/v3/git/trees/#create-a-tree\n    * @param {string} baseTreeSHA - the SHA of the tree to update\n    * @param {string} path - the path for the new file\n    * @param {string} blobSHA - the SHA for the blob to put at `path`\n    * @param {Requestable.callback} cb - will receive the new tree that is created\n    * @return {Promise} - the promise for the http request\n    * @deprecated use {@link Repository#createTree} instead\n    */\n   updateTree(baseTreeSHA, path, blobSHA, cb) {\n      let newTree = {\n         base_tree: baseTreeSHA, // eslint-disable-line\n         tree: [{\n            path: path,\n            sha: blobSHA,\n            mode: '100644',\n            type: 'blob',\n         }],\n      };\n\n      return this._request('POST', `/repos/${this.__fullname}/git/trees`, newTree, cb);\n   }\n\n   /**\n    * Create a new tree in git\n    * @see https://developer.github.com/v3/git/trees/#create-a-tree\n    * @param {Object} tree - the tree to create\n    * @param {string} baseSHA - the root sha of the tree\n    * @param {Requestable.callback} cb - will receive the new tree that is created\n    * @return {Promise} - the promise for the http request\n    */\n   createTree(tree, baseSHA, cb) {\n      return this._request('POST', `/repos/${this.__fullname}/git/trees`, {\n         tree,\n         base_tree: baseSHA, // eslint-disable-line camelcase\n      }, cb);\n   }\n\n   /**\n    * Add a commit to the repository\n    * @see https://developer.github.com/v3/git/commits/#create-a-commit\n    * @param {string} parent - the SHA of the parent commit\n    * @param {string} tree - the SHA of the tree for this commit\n    * @param {string} message - the commit message\n    * @param {Requestable.callback} cb - will receive the commit that is created\n    * @return {Promise} - the promise for the http request\n    */\n   commit(parent, tree, message, cb) {\n      let data = {\n         message,\n         tree,\n         parents: [parent],\n      };\n\n      return this._request('POST', `/repos/${this.__fullname}/git/commits`, data, cb)\n         .then((response) => {\n            this.__currentTree.sha = response.data.sha; // Update latest commit\n            return response;\n         });\n   }\n\n   /**\n    * Update a ref\n    * @see https://developer.github.com/v3/git/refs/#update-a-reference\n    * @param {string} ref - the ref to update\n    * @param {string} commitSHA - the SHA to point the reference to\n    * @param {boolean} force - indicates whether to force or ensure a fast-forward update\n    * @param {Requestable.callback} cb - will receive the updated ref back\n    * @return {Promise} - the promise for the http request\n    */\n   updateHead(ref, commitSHA, force, cb) {\n      return this._request('PATCH', `/repos/${this.__fullname}/git/refs/${ref}`, {\n         sha: commitSHA,\n         force: force,\n      }, cb);\n   }\n\n   /**\n    * Update commit status\n    * @see https://developer.github.com/v3/repos/statuses/\n    * @param {string} commitSHA - the SHA of the commit that should be updated\n    * @param {object} options - Commit status parameters\n    * @param {string} options.state - The state of the status. Can be one of: pending, success, error, or failure.\n    * @param {string} [options.target_url] - The target URL to associate with this status.\n    * @param {string} [options.description] - A short description of the status.\n    * @param {string} [options.context] - A string label to differentiate this status among CI systems.\n    * @param {Requestable.callback} cb - will receive the updated commit back\n    * @return {Promise} - the promise for the http request\n    */\n   updateStatus(commitSHA, options, cb) {\n      return this._request('POST', `/repos/${this.__fullname}/statuses/${commitSHA}`, options, cb);\n   }\n\n   /**\n    * Update repository information\n    * @see https://developer.github.com/v3/repos/#edit\n    * @param {object} options - New parameters that will be set to the repository\n    * @param {string} options.name - Name of the repository\n    * @param {string} [options.description] - A short description of the repository\n    * @param {string} [options.homepage] - A URL with more information about the repository\n    * @param {boolean} [options.private] - Either true to make the repository private, or false to make it public.\n    * @param {boolean} [options.has_issues] - Either true to enable issues for this repository, false to disable them.\n    * @param {boolean} [options.has_wiki] - Either true to enable the wiki for this repository, false to disable it.\n    * @param {boolean} [options.has_downloads] - Either true to enable downloads, false to disable them.\n    * @param {string} [options.default_branch] - Updates the default branch for this repository.\n    * @param {Requestable.callback} cb - will receive the updated repository back\n    * @return {Promise} - the promise for the http request\n    */\n   updateRepository(options, cb) {\n      return this._request('PATCH', `/repos/${this.__fullname}`, options, cb);\n   }\n\n  /**\n    * Get information about the repository\n    * @see https://developer.github.com/v3/repos/#get\n    * @param {Requestable.callback} cb - will receive the information about the repository\n    * @return {Promise} - the promise for the http request\n    */\n   getDetails(cb) {\n      return this._request('GET', `/repos/${this.__fullname}`, null, cb);\n   }\n\n   /**\n    * List the contributors to the repository\n    * @see https://developer.github.com/v3/repos/#list-contributors\n    * @param {Requestable.callback} cb - will receive the list of contributors\n    * @return {Promise} - the promise for the http request\n    */\n   getContributors(cb) {\n      return this._request('GET', `/repos/${this.__fullname}/contributors`, null, cb);\n   }\n\n   /**\n    * List the contributor stats to the repository\n    * @see https://developer.github.com/v3/repos/#list-contributors\n    * @param {Requestable.callback} cb - will receive the list of contributors\n    * @return {Promise} - the promise for the http request\n    */\n   getContributorStats(cb) {\n      return this._request('GET', `/repos/${this.__fullname}/stats/contributors`, null, cb);\n   }\n\n   /**\n    * List the users who are collaborators on the repository. The currently authenticated user must have\n    * push access to use this method\n    * @see https://developer.github.com/v3/repos/collaborators/#list-collaborators\n    * @param {Requestable.callback} cb - will receive the list of collaborators\n    * @return {Promise} - the promise for the http request\n    */\n   getCollaborators(cb) {\n      return this._request('GET', `/repos/${this.__fullname}/collaborators`, null, cb);\n   }\n\n   /**\n    * Check if a user is a collaborator on the repository\n    * @see https://developer.github.com/v3/repos/collaborators/#check-if-a-user-is-a-collaborator\n    * @param {string} username - the user to check\n    * @param {Requestable.callback} cb - will receive true if the user is a collaborator and false if they are not\n    * @return {Promise} - the promise for the http request {Boolean} [description]\n    */\n   isCollaborator(username, cb) {\n      return this._request('GET', `/repos/${this.__fullname}/collaborators/${username}`, null, cb);\n   }\n\n   /**\n    * Get the contents of a repository\n    * @see https://developer.github.com/v3/repos/contents/#get-contents\n    * @param {string} ref - the ref to check\n    * @param {string} path - the path containing the content to fetch\n    * @param {boolean} raw - `true` if the results should be returned raw instead of GitHub's normalized format\n    * @param {Requestable.callback} cb - will receive the fetched data\n    * @return {Promise} - the promise for the http request\n    */\n   getContents(ref, path, raw, cb) {\n      path = path ? `${encodeURI(path)}` : '';\n      return this._request('GET', `/repos/${this.__fullname}/contents/${path}`, {\n         ref,\n      }, cb, raw);\n   }\n\n   /**\n    * Get the README of a repository\n    * @see https://developer.github.com/v3/repos/contents/#get-the-readme\n    * @param {string} ref - the ref to check\n    * @param {boolean} raw - `true` if the results should be returned raw instead of GitHub's normalized format\n    * @param {Requestable.callback} cb - will receive the fetched data\n    * @return {Promise} - the promise for the http request\n    */\n   getReadme(ref, raw, cb) {\n      return this._request('GET', `/repos/${this.__fullname}/readme`, {\n         ref,\n      }, cb, raw);\n   }\n\n   /**\n    * Fork a repository\n    * @see https://developer.github.com/v3/repos/forks/#create-a-fork\n    * @param {Requestable.callback} cb - will receive the information about the newly created fork\n    * @return {Promise} - the promise for the http request\n    */\n   fork(cb) {\n      return this._request('POST', `/repos/${this.__fullname}/forks`, null, cb);\n   }\n\n   /**\n    * List a repository's forks\n    * @see https://developer.github.com/v3/repos/forks/#list-forks\n    * @param {Requestable.callback} cb - will receive the list of repositories forked from this one\n    * @return {Promise} - the promise for the http request\n    */\n   listForks(cb) {\n      return this._request('GET', `/repos/${this.__fullname}/forks`, null, cb);\n   }\n\n   /**\n    * Create a new branch from an existing branch.\n    * @param {string} [oldBranch=master] - the name of the existing branch\n    * @param {string} newBranch - the name of the new branch\n    * @param {Requestable.callback} cb - will receive the commit data for the head of the new branch\n    * @return {Promise} - the promise for the http request\n    */\n   createBranch(oldBranch, newBranch, cb) {\n      if (typeof newBranch === 'function') {\n         cb = newBranch;\n         newBranch = oldBranch;\n         oldBranch = 'master';\n      }\n\n      return this.getRef(`heads/${oldBranch}`)\n         .then((response) => {\n            let sha = response.data.object.sha;\n            return this.createRef({\n               sha,\n               ref: `refs/heads/${newBranch}`,\n            }, cb);\n         });\n   }\n\n   /**\n    * Create a new pull request\n    * @see https://developer.github.com/v3/pulls/#create-a-pull-request\n    * @param {Object} options - the pull request description\n    * @param {Requestable.callback} cb - will receive the new pull request\n    * @return {Promise} - the promise for the http request\n    */\n   createPullRequest(options, cb) {\n      return this._request('POST', `/repos/${this.__fullname}/pulls`, options, cb);\n   }\n\n   /**\n    * Update a pull request\n    * @see https://developer.github.com/v3/pulls/#update-a-pull-request\n    * @param {number|string} number - the number of the pull request to update\n    * @param {Object} options - the pull request description\n    * @param {Requestable.callback} [cb] - will receive the pull request information\n    * @return {Promise} - the promise for the http request\n    */\n   updatePullRequest(number, options, cb) {\n      return this._request('PATCH', `/repos/${this.__fullname}/pulls/${number}`, options, cb);\n   }\n\n   /**\n    * List the hooks for the repository\n    * @see https://developer.github.com/v3/repos/hooks/#list-hooks\n    * @param {Requestable.callback} cb - will receive the list of hooks\n    * @return {Promise} - the promise for the http request\n    */\n   listHooks(cb) {\n      return this._request('GET', `/repos/${this.__fullname}/hooks`, null, cb);\n   }\n\n   /**\n    * Get a hook for the repository\n    * @see https://developer.github.com/v3/repos/hooks/#get-single-hook\n    * @param {number} id - the id of the webook\n    * @param {Requestable.callback} cb - will receive the details of the webook\n    * @return {Promise} - the promise for the http request\n    */\n   getHook(id, cb) {\n      return this._request('GET', `/repos/${this.__fullname}/hooks/${id}`, null, cb);\n   }\n\n   /**\n    * Add a new hook to the repository\n    * @see https://developer.github.com/v3/repos/hooks/#create-a-hook\n    * @param {Object} options - the configuration describing the new hook\n    * @param {Requestable.callback} cb - will receive the new webhook\n    * @return {Promise} - the promise for the http request\n    */\n   createHook(options, cb) {\n      return this._request('POST', `/repos/${this.__fullname}/hooks`, options, cb);\n   }\n\n   /**\n    * Edit an existing webhook\n    * @see https://developer.github.com/v3/repos/hooks/#edit-a-hook\n    * @param {number} id - the id of the webhook\n    * @param {Object} options - the new description of the webhook\n    * @param {Requestable.callback} cb - will receive the updated webhook\n    * @return {Promise} - the promise for the http request\n    */\n   updateHook(id, options, cb) {\n      return this._request('PATCH', `/repos/${this.__fullname}/hooks/${id}`, options, cb);\n   }\n\n   /**\n    * Delete a webhook\n    * @see https://developer.github.com/v3/repos/hooks/#delete-a-hook\n    * @param {number} id - the id of the webhook to be deleted\n    * @param {Requestable.callback} cb - will receive true if the call is successful\n    * @return {Promise} - the promise for the http request\n    */\n   deleteHook(id, cb) {\n      return this._request('DELETE', `/repos/${this.__fullname}/hooks/${id}`, null, cb);\n   }\n\n   /**\n    * List the deploy keys for the repository\n    * @see https://developer.github.com/v3/repos/keys/#list-deploy-keys\n    * @param {Requestable.callback} cb - will receive the list of deploy keys\n    * @return {Promise} - the promise for the http request\n    */\n   listKeys(cb) {\n      return this._request('GET', `/repos/${this.__fullname}/keys`, null, cb);\n   }\n\n   /**\n    * Get a deploy key for the repository\n    * @see https://developer.github.com/v3/repos/keys/#get-a-deploy-key\n    * @param {number} id - the id of the deploy key\n    * @param {Requestable.callback} cb - will receive the details of the deploy key\n    * @return {Promise} - the promise for the http request\n    */\n   getKey(id, cb) {\n      return this._request('GET', `/repos/${this.__fullname}/keys/${id}`, null, cb);\n   }\n\n   /**\n    * Add a new deploy key to the repository\n    * @see https://developer.github.com/v3/repos/keys/#add-a-new-deploy-key\n    * @param {Object} options - the configuration describing the new deploy key\n    * @param {Requestable.callback} cb - will receive the new deploy key\n    * @return {Promise} - the promise for the http request\n    */\n   createKey(options, cb) {\n      return this._request('POST', `/repos/${this.__fullname}/keys`, options, cb);\n   }\n\n   /**\n    * Delete a deploy key\n    * @see https://developer.github.com/v3/repos/keys/#remove-a-deploy-key\n    * @param {number} id - the id of the deploy key to be deleted\n    * @param {Requestable.callback} cb - will receive true if the call is successful\n    * @return {Promise} - the promise for the http request\n    */\n   deleteKey(id, cb) {\n      return this._request('DELETE', `/repos/${this.__fullname}/keys/${id}`, null, cb);\n   }\n\n   /**\n    * Delete a file from a branch\n    * @see https://developer.github.com/v3/repos/contents/#delete-a-file\n    * @param {string} branch - the branch to delete from, or the default branch if not specified\n    * @param {string} path - the path of the file to remove\n    * @param {Requestable.callback} cb - will receive the commit in which the delete occurred\n    * @return {Promise} - the promise for the http request\n    */\n   deleteFile(branch, path, cb) {\n      return this.getSha(branch, path)\n         .then((response) => {\n            const deleteCommit = {\n               message: `Delete the file at '${path}'`,\n               sha: response.data.sha,\n               branch,\n            };\n            return this._request('DELETE', `/repos/${this.__fullname}/contents/${path}`, deleteCommit, cb);\n         });\n   }\n\n   /**\n    * Change all references in a repo from oldPath to new_path\n    * @param {string} branch - the branch to carry out the reference change, or the default branch if not specified\n    * @param {string} oldPath - original path\n    * @param {string} newPath - new reference path\n    * @param {Requestable.callback} cb - will receive the commit in which the move occurred\n    * @return {Promise} - the promise for the http request\n    */\n   move(branch, oldPath, newPath, cb) {\n      let oldSha;\n      return this.getRef(`heads/${branch}`)\n         .then(({data: {object}}) => this.getTree(`${object.sha}?recursive=true`))\n         .then(({data: {tree, sha}}) => {\n            oldSha = sha;\n            let newTree = tree.map((ref) => {\n               if (ref.path === oldPath) {\n                  ref.path = newPath;\n               }\n               if (ref.type === 'tree') {\n                  delete ref.sha;\n               }\n               return ref;\n            });\n            return this.createTree(newTree);\n         })\n         .then(({data: tree}) => this.commit(oldSha, tree.sha, `Renamed '${oldPath}' to '${newPath}'`))\n         .then(({data: commit}) => this.updateHead(`heads/${branch}`, commit.sha, true, cb));\n   }\n\n   /**\n    * Write a file to the repository\n    * @see https://developer.github.com/v3/repos/contents/#update-a-file\n    * @param {string} branch - the name of the branch\n    * @param {string} path - the path for the file\n    * @param {string} content - the contents of the file\n    * @param {string} message - the commit message\n    * @param {Object} [options] - commit options\n    * @param {Object} [options.author] - the author of the commit\n    * @param {Object} [options.commiter] - the committer\n    * @param {boolean} [options.encode] - true if the content should be base64 encoded\n    * @param {Requestable.callback} cb - will receive the new commit\n    * @return {Promise} - the promise for the http request\n    */\n   writeFile(branch, path, content, message, options, cb) {\n      if (typeof options === 'function') {\n         cb = options;\n         options = {};\n      }\n      let filePath = path ? encodeURI(path) : '';\n      let shouldEncode = options.encode !== false;\n      let commit = {\n         branch,\n         message,\n         author: options.author,\n         committer: options.committer,\n         content: shouldEncode ? Base64.encode(content) : content,\n      };\n\n      return this.getSha(branch, filePath)\n         .then((response) => {\n            commit.sha = response.data.sha;\n            return this._request('PUT', `/repos/${this.__fullname}/contents/${filePath}`, commit, cb);\n         }, () => {\n            return this._request('PUT', `/repos/${this.__fullname}/contents/${filePath}`, commit, cb);\n         });\n   }\n\n   /**\n    * Check if a repository is starred by you\n    * @see https://developer.github.com/v3/activity/starring/#check-if-you-are-starring-a-repository\n    * @param {Requestable.callback} cb - will receive true if the repository is starred and false if the repository\n    *                                  is not starred\n    * @return {Promise} - the promise for the http request {Boolean} [description]\n    */\n   isStarred(cb) {\n      return this._request204or404(`/user/starred/${this.__fullname}`, null, cb);\n   }\n\n   /**\n    * Star a repository\n    * @see https://developer.github.com/v3/activity/starring/#star-a-repository\n    * @param {Requestable.callback} cb - will receive true if the repository is starred\n    * @return {Promise} - the promise for the http request\n    */\n   star(cb) {\n      return this._request('PUT', `/user/starred/${this.__fullname}`, null, cb);\n   }\n\n   /**\n    * Unstar a repository\n    * @see https://developer.github.com/v3/activity/starring/#unstar-a-repository\n    * @param {Requestable.callback} cb - will receive true if the repository is unstarred\n    * @return {Promise} - the promise for the http request\n    */\n   unstar(cb) {\n      return this._request('DELETE', `/user/starred/${this.__fullname}`, null, cb);\n   }\n\n   /**\n    * Create a new release\n    * @see https://developer.github.com/v3/repos/releases/#create-a-release\n    * @param {Object} options - the description of the release\n    * @param {Requestable.callback} cb - will receive the newly created release\n    * @return {Promise} - the promise for the http request\n    */\n   createRelease(options, cb) {\n      return this._request('POST', `/repos/${this.__fullname}/releases`, options, cb);\n   }\n\n   /**\n    * Edit a release\n    * @see https://developer.github.com/v3/repos/releases/#edit-a-release\n    * @param {string} id - the id of the release\n    * @param {Object} options - the description of the release\n    * @param {Requestable.callback} cb - will receive the modified release\n    * @return {Promise} - the promise for the http request\n    */\n   updateRelease(id, options, cb) {\n      return this._request('PATCH', `/repos/${this.__fullname}/releases/${id}`, options, cb);\n   }\n\n   /**\n    * Get information about all releases\n    * @see https://developer.github.com/v3/repos/releases/#list-releases-for-a-repository\n    * @param {Requestable.callback} cb - will receive the release information\n    * @return {Promise} - the promise for the http request\n    */\n   listReleases(cb) {\n      return this._request('GET', `/repos/${this.__fullname}/releases`, null, cb);\n   }\n\n   /**\n    * Get information about a release\n    * @see https://developer.github.com/v3/repos/releases/#get-a-single-release\n    * @param {string} id - the id of the release\n    * @param {Requestable.callback} cb - will receive the release information\n    * @return {Promise} - the promise for the http request\n    */\n   getRelease(id, cb) {\n      return this._request('GET', `/repos/${this.__fullname}/releases/${id}`, null, cb);\n   }\n\n   /**\n    * Delete a release\n    * @see https://developer.github.com/v3/repos/releases/#delete-a-release\n    * @param {string} id - the release to be deleted\n    * @param {Requestable.callback} cb - will receive true if the operation is successful\n    * @return {Promise} - the promise for the http request\n    */\n   deleteRelease(id, cb) {\n      return this._request('DELETE', `/repos/${this.__fullname}/releases/${id}`, null, cb);\n   }\n\n   /**\n    * Merge a pull request\n    * @see https://developer.github.com/v3/pulls/#merge-a-pull-request-merge-button\n    * @param {number|string} number - the number of the pull request to merge\n    * @param {Object} options - the merge options for the pull request\n    * @param {Requestable.callback} [cb] - will receive the merge information if the operation is successful\n    * @return {Promise} - the promise for the http request\n    */\n   mergePullRequest(number, options, cb) {\n      return this._request('PUT', `/repos/${this.__fullname}/pulls/${number}/merge`, options, cb);\n   }\n\n   /**\n    * Get information about all projects\n    * @see https://developer.github.com/v3/projects/#list-repository-projects\n    * @param {Requestable.callback} [cb] - will receive the list of projects\n    * @return {Promise} - the promise for the http request\n    */\n   listProjects(cb) {\n      return this._requestAllPages(`/repos/${this.__fullname}/projects`, {AcceptHeader: 'inertia-preview'}, cb);\n   }\n\n   /**\n    * Create a new project\n    * @see https://developer.github.com/v3/projects/#create-a-repository-project\n    * @param {Object} options - the description of the project\n    * @param {Requestable.callback} cb - will receive the newly created project\n    * @return {Promise} - the promise for the http request\n    */\n   createProject(options, cb) {\n      options = options || {};\n      options.AcceptHeader = 'inertia-preview';\n      return this._request('POST', `/repos/${this.__fullname}/projects`, options, cb);\n   }\n\n}\n\nmodule.exports = Repository;\n","/**\n * @file\n * @copyright  2016 Yahoo Inc.\n * @license    Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n *             Github.js is freely distributable.\n */\n\nimport axios from 'axios';\nimport debug from 'debug';\nimport {Base64} from 'js-base64';\n\nconst log = debug('github:request');\n\n/**\n * The error structure returned when a network call fails\n */\nclass ResponseError extends Error {\n   /**\n    * Construct a new ResponseError\n    * @param {string} message - an message to return instead of the the default error message\n    * @param {string} path - the requested path\n    * @param {Object} response - the object returned by Axios\n    */\n   constructor(message, path, response) {\n      super(message);\n      this.path = path;\n      this.request = response.config;\n      this.response = (response || {}).response || response;\n      this.status = response.status;\n   }\n}\n\n/**\n * Requestable wraps the logic for making http requests to the API\n */\nclass Requestable {\n   /**\n    * Either a username and password or an oauth token for Github\n    * @typedef {Object} Requestable.auth\n    * @prop {string} [username] - the Github username\n    * @prop {string} [password] - the user's password\n    * @prop {token} [token] - an OAuth token\n    */\n   /**\n    * Initialize the http internals.\n    * @param {Requestable.auth} [auth] - the credentials to authenticate to Github. If auth is\n    *                                  not provided request will be made unauthenticated\n    * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n    * @param {string} [AcceptHeader=v3] - the accept header for the requests\n    */\n   constructor(auth, apiBase, AcceptHeader) {\n      this.__apiBase = apiBase || 'https://api.github.com';\n      this.__auth = {\n         token: auth.token,\n         username: auth.username,\n         password: auth.password,\n      };\n      this.__AcceptHeader = AcceptHeader || 'v3';\n\n      if (auth.token) {\n         this.__authorizationHeader = 'token ' + auth.token;\n      } else if (auth.username && auth.password) {\n         this.__authorizationHeader = 'Basic ' + Base64.encode(auth.username + ':' + auth.password);\n      }\n   }\n\n   /**\n    * Compute the URL to use to make a request.\n    * @private\n    * @param {string} path - either a URL relative to the API base or an absolute URL\n    * @return {string} - the URL to use\n    */\n   __getURL(path) {\n      let url = path;\n\n      if (path.indexOf('//') === -1) {\n         url = this.__apiBase + path;\n      }\n\n      let newCacheBuster = 'timestamp=' + new Date().getTime();\n      return url.replace(/(timestamp=\\d+)/, newCacheBuster);\n   }\n\n   /**\n    * Compute the headers required for an API request.\n    * @private\n    * @param {boolean} raw - if the request should be treated as JSON or as a raw request\n    * @param {string} AcceptHeader - the accept header for the request\n    * @return {Object} - the headers to use in the request\n    */\n   __getRequestHeaders(raw, AcceptHeader) {\n      let headers = {\n         'Content-Type': 'application/json;charset=UTF-8',\n         'Accept': 'application/vnd.github.' + (AcceptHeader || this.__AcceptHeader),\n      };\n\n      if (raw) {\n         headers.Accept += '.raw';\n      }\n      headers.Accept += '+json';\n\n      if (this.__authorizationHeader) {\n         headers.Authorization = this.__authorizationHeader;\n      }\n\n      return headers;\n   }\n\n   /**\n    * Sets the default options for API requests\n    * @protected\n    * @param {Object} [requestOptions={}] - the current options for the request\n    * @return {Object} - the options to pass to the request\n    */\n   _getOptionsWithDefaults(requestOptions = {}) {\n      if (!(requestOptions.visibility || requestOptions.affiliation)) {\n         requestOptions.type = requestOptions.type || 'all';\n      }\n      requestOptions.sort = requestOptions.sort || 'updated';\n      requestOptions.per_page = requestOptions.per_page || '100'; // eslint-disable-line\n\n      return requestOptions;\n   }\n\n   /**\n    * if a `Date` is passed to this function it will be converted to an ISO string\n    * @param {*} date - the object to attempt to cooerce into an ISO date string\n    * @return {string} - the ISO representation of `date` or whatever was passed in if it was not a date\n    */\n   _dateToISO(date) {\n      if (date && (date instanceof Date)) {\n         date = date.toISOString();\n      }\n\n      return date;\n   }\n\n   /**\n    * A function that receives the result of the API request.\n    * @callback Requestable.callback\n    * @param {Requestable.Error} error - the error returned by the API or `null`\n    * @param {(Object|true)} result - the data returned by the API or `true` if the API returns `204 No Content`\n    * @param {Object} request - the raw {@linkcode https://github.com/mzabriskie/axios#response-schema Response}\n    */\n   /**\n    * Make a request.\n    * @param {string} method - the method for the request (GET, PUT, POST, DELETE)\n    * @param {string} path - the path for the request\n    * @param {*} [data] - the data to send to the server. For HTTP methods that don't have a body the data\n    *                   will be sent as query parameters\n    * @param {Requestable.callback} [cb] - the callback for the request\n    * @param {boolean} [raw=false] - if the request should be sent as raw. If this is a falsy value then the\n    *                              request will be made as JSON\n    * @return {Promise} - the Promise for the http request\n    */\n   _request(method, path, data, cb, raw) {\n      const url = this.__getURL(path);\n\n      const AcceptHeader = (data || {}).AcceptHeader;\n      if (AcceptHeader) {\n         delete data.AcceptHeader;\n      }\n      const headers = this.__getRequestHeaders(raw, AcceptHeader);\n\n      let queryParams = {};\n\n      const shouldUseDataAsParams = data && (typeof data === 'object') && methodHasNoBody(method);\n      if (shouldUseDataAsParams) {\n         queryParams = data;\n         data = undefined;\n      }\n\n      const config = {\n         url: url,\n         method: method,\n         headers: headers,\n         params: queryParams,\n         data: data,\n         responseType: raw ? 'text' : 'json',\n      };\n\n      log(`${config.method} to ${config.url}`);\n      const requestPromise = axios(config).catch(callbackErrorOrThrow(cb, path));\n\n      if (cb) {\n         requestPromise.then((response) => {\n            if (response.data && Object.keys(response.data).length > 0) {\n               // When data has results\n               cb(null, response.data, response);\n            } else if (config.method !== 'GET' && Object.keys(response.data).length < 1) {\n               // True when successful submit a request and receive a empty object\n               cb(null, (response.status < 300), response);\n            } else {\n               cb(null, response.data, response);\n            }\n         });\n      }\n\n      return requestPromise;\n   }\n\n   /**\n    * Make a request to an endpoint the returns 204 when true and 404 when false\n    * @param {string} path - the path to request\n    * @param {Object} data - any query parameters for the request\n    * @param {Requestable.callback} cb - the callback that will receive `true` or `false`\n    * @param {method} [method=GET] - HTTP Method to use\n    * @return {Promise} - the promise for the http request\n    */\n   _request204or404(path, data, cb, method = 'GET') {\n      return this._request(method, path, data)\n         .then(function success(response) {\n            if (cb) {\n               cb(null, true, response);\n            }\n            return true;\n         }, function failure(response) {\n            if (response.response.status === 404) {\n               if (cb) {\n                  cb(null, false, response);\n               }\n               return false;\n            }\n\n            if (cb) {\n               cb(response);\n            }\n            throw response;\n         });\n   }\n\n   /**\n    * Make a request and fetch all the available data. Github will paginate responses so for queries\n    * that might span multiple pages this method is preferred to {@link Requestable#request}\n    * @param {string} path - the path to request\n    * @param {Object} options - the query parameters to include\n    * @param {Requestable.callback} [cb] - the function to receive the data. The returned data will always be an array.\n    * @param {Object[]} results - the partial results. This argument is intended for interal use only.\n    * @return {Promise} - a promise which will resolve when all pages have been fetched\n    * @deprecated This will be folded into {@link Requestable#_request} in the 2.0 release.\n    */\n   _requestAllPages(path, options, cb, results) {\n      results = results || [];\n\n      return this._request('GET', path, options)\n         .then((response) => {\n            let thisGroup;\n            if (response.data instanceof Array) {\n               thisGroup = response.data;\n            } else if (response.data.items instanceof Array) {\n               thisGroup = response.data.items;\n            } else {\n               let message = `cannot figure out how to append ${response.data} to the result set`;\n               throw new ResponseError(message, path, response);\n            }\n            results.push(...thisGroup);\n\n            const nextUrl = getNextPage(response.headers.link);\n            if (nextUrl && typeof options.page !== 'number') {\n               log(`getting next page: ${nextUrl}`);\n               return this._requestAllPages(nextUrl, options, cb, results);\n            }\n\n            if (cb) {\n               cb(null, results, response);\n            }\n\n            response.data = results;\n            return response;\n         }).catch(callbackErrorOrThrow(cb, path));\n   }\n}\n\nmodule.exports = Requestable;\n\n// ////////////////////////// //\n//  Private helper functions  //\n// ////////////////////////// //\nconst METHODS_WITH_NO_BODY = ['GET', 'HEAD', 'DELETE'];\nfunction methodHasNoBody(method) {\n   return METHODS_WITH_NO_BODY.indexOf(method) !== -1;\n}\n\nfunction getNextPage(linksHeader = '') {\n   const links = linksHeader.split(/\\s*,\\s*/); // splits and strips the urls\n   return links.reduce(function(nextUrl, link) {\n      if (link.search(/rel=\"next\"/) !== -1) {\n         return (link.match(/<(.*)>/) || [])[1];\n      }\n\n      return nextUrl;\n   }, undefined);\n}\n\nfunction callbackErrorOrThrow(cb, path) {\n   return function handler(object) {\n      let error;\n      if (object.hasOwnProperty('config')) {\n         const {response: {status, statusText}, config: {method, url}} = object;\n         let message = (`${status} error making request ${method} ${url}: \"${statusText}\"`);\n         error = new ResponseError(message, path, object);\n         log(`${message} ${JSON.stringify(object.data)}`);\n      } else {\n         error = object;\n      }\n      if (cb) {\n         log('going to error callback');\n         cb(error);\n      } else {\n         log('throwing error');\n         throw error;\n      }\n   };\n}\n","/**\n * @file\n * @copyright  2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license    Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n *             Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\nimport debug from 'debug';\nconst log = debug('github:search');\n\n/**\n * Wrap the Search API\n */\nclass Search extends Requestable {\n   /**\n    * Create a Search\n    * @param {Object} defaults - defaults for the search\n    * @param {Requestable.auth} [auth] - information required to authenticate to Github\n    * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n    */\n   constructor(defaults, auth, apiBase) {\n      super(auth, apiBase);\n      this.__defaults = this._getOptionsWithDefaults(defaults);\n   }\n\n   /**\n    * Available search options\n    * @see https://developer.github.com/v3/search/#parameters\n    * @typedef {Object} Search.Params\n    * @param {string} q - the query to make\n    * @param {string} sort - the sort field, one of `stars`, `forks`, or `updated`.\n    *                      Default is [best match](https://developer.github.com/v3/search/#ranking-search-results)\n    * @param {string} order - the ordering, either `asc` or `desc`\n    */\n   /**\n    * Perform a search on the GitHub API\n    * @private\n    * @param {string} path - the scope of the search\n    * @param {Search.Params} [withOptions] - additional parameters for the search\n    * @param {Requestable.callback} [cb] - will receive the results of the search\n    * @return {Promise} - the promise for the http request\n    */\n   _search(path, withOptions = {}, cb = undefined) {\n      let requestOptions = {};\n      Object.keys(this.__defaults).forEach((prop) => {\n         requestOptions[prop] = this.__defaults[prop];\n      });\n      Object.keys(withOptions).forEach((prop) => {\n         requestOptions[prop] = withOptions[prop];\n      });\n\n      log(`searching ${path} with options:`, requestOptions);\n      return this._requestAllPages(`/search/${path}`, requestOptions, cb);\n   }\n\n   /**\n    * Search for repositories\n    * @see https://developer.github.com/v3/search/#search-repositories\n    * @param {Search.Params} [options] - additional parameters for the search\n    * @param {Requestable.callback} [cb] - will receive the results of the search\n    * @return {Promise} - the promise for the http request\n    */\n   forRepositories(options, cb) {\n      return this._search('repositories', options, cb);\n   }\n\n   /**\n    * Search for code\n    * @see https://developer.github.com/v3/search/#search-code\n    * @param {Search.Params} [options] - additional parameters for the search\n    * @param {Requestable.callback} [cb] - will receive the results of the search\n    * @return {Promise} - the promise for the http request\n    */\n   forCode(options, cb) {\n      return this._search('code', options, cb);\n   }\n\n   /**\n    * Search for issues\n    * @see https://developer.github.com/v3/search/#search-issues\n    * @param {Search.Params} [options] - additional parameters for the search\n    * @param {Requestable.callback} [cb] - will receive the results of the search\n    * @return {Promise} - the promise for the http request\n    */\n   forIssues(options, cb) {\n      return this._search('issues', options, cb);\n   }\n\n   /**\n    * Search for users\n    * @see https://developer.github.com/v3/search/#search-users\n    * @param {Search.Params} [options] - additional parameters for the search\n    * @param {Requestable.callback} [cb] - will receive the results of the search\n    * @return {Promise} - the promise for the http request\n    */\n   forUsers(options, cb) {\n      return this._search('users', options, cb);\n   }\n}\n\nmodule.exports = Search;\n","/**\n * @file\n * @copyright  2016 Matt Smith (Development Seed)\n * @license    Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n *             Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\nimport debug from 'debug';\nconst log = debug('github:team');\n\n/**\n * A Team allows scoping of API requests to a particular Github Organization Team.\n */\nclass Team extends Requestable {\n   /**\n    * Create a Team.\n    * @param {string} [teamId] - the id for the team\n    * @param {Requestable.auth} [auth] - information required to authenticate to Github\n    * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n    */\n   constructor(teamId, auth, apiBase) {\n      super(auth, apiBase);\n      this.__teamId = teamId;\n   }\n\n   /**\n    * Get Team information\n    * @see https://developer.github.com/v3/orgs/teams/#get-team\n    * @param {Requestable.callback} [cb] - will receive the team\n    * @return {Promise} - the promise for the http request\n    */\n   getTeam(cb) {\n      log(`Fetching Team ${this.__teamId}`);\n      return this._request('Get', `/teams/${this.__teamId}`, undefined, cb);\n   }\n\n   /**\n    * List the Team's repositories\n    * @see https://developer.github.com/v3/orgs/teams/#list-team-repos\n    * @param {Requestable.callback} [cb] - will receive the list of repositories\n    * @return {Promise} - the promise for the http request\n    */\n   listRepos(cb) {\n      log(`Fetching repositories for Team ${this.__teamId}`);\n      return this._requestAllPages(`/teams/${this.__teamId}/repos`, undefined, cb);\n   }\n\n   /**\n    * Edit Team information\n    * @see https://developer.github.com/v3/orgs/teams/#edit-team\n    * @param {object} options - Parameters for team edit\n    * @param {string} options.name - The name of the team\n    * @param {string} [options.description] - Team description\n    * @param {string} [options.repo_names] - Repos to add the team to\n    * @param {string} [options.privacy=secret] - The level of privacy the team should have. Can be either one\n    * of: `secret`, or `closed`\n    * @param {Requestable.callback} [cb] - will receive the updated team\n    * @return {Promise} - the promise for the http request\n    */\n   editTeam(options, cb) {\n      log(`Editing Team ${this.__teamId}`);\n      return this._request('PATCH', `/teams/${this.__teamId}`, options, cb);\n   }\n\n   /**\n    * List the users who are members of the Team\n    * @see https://developer.github.com/v3/orgs/teams/#list-team-members\n    * @param {object} options - Parameters for listing team users\n    * @param {string} [options.role=all] - can be one of: `all`, `maintainer`, or `member`\n    * @param {Requestable.callback} [cb] - will receive the list of users\n    * @return {Promise} - the promise for the http request\n    */\n   listMembers(options, cb) {\n      log(`Getting members of Team ${this.__teamId}`);\n      return this._requestAllPages(`/teams/${this.__teamId}/members`, options, cb);\n   }\n\n   /**\n    * Get Team membership status for a user\n    * @see https://developer.github.com/v3/orgs/teams/#get-team-membership\n    * @param {string} username - can be one of: `all`, `maintainer`, or `member`\n    * @param {Requestable.callback} [cb] - will receive the membership status of a user\n    * @return {Promise} - the promise for the http request\n    */\n   getMembership(username, cb) {\n      log(`Getting membership of user ${username} in Team ${this.__teamId}`);\n      return this._request('GET', `/teams/${this.__teamId}/memberships/${username}`, undefined, cb);\n   }\n\n   /**\n    * Add a member to the Team\n    * @see https://developer.github.com/v3/orgs/teams/#add-team-membership\n    * @param {string} username - can be one of: `all`, `maintainer`, or `member`\n    * @param {object} options - Parameters for adding a team member\n    * @param {string} [options.role=member] - The role that this user should have in the team. Can be one\n    * of: `member`, or `maintainer`\n    * @param {Requestable.callback} [cb] - will receive the membership status of added user\n    * @return {Promise} - the promise for the http request\n    */\n   addMembership(username, options, cb) {\n      log(`Adding user ${username} to Team ${this.__teamId}`);\n      return this._request('PUT', `/teams/${this.__teamId}/memberships/${username}`, options, cb);\n   }\n\n   /**\n    * Get repo management status for team\n    * @see https://developer.github.com/v3/orgs/teams/#remove-team-membership\n    * @param {string} owner - Organization name\n    * @param {string} repo - Repo name\n    * @param {Requestable.callback} [cb] - will receive the membership status of added user\n    * @return {Promise} - the promise for the http request\n    */\n   isManagedRepo(owner, repo, cb) {\n      log(`Getting repo management by Team ${this.__teamId} for repo ${owner}/${repo}`);\n      return this._request204or404(`/teams/${this.__teamId}/repos/${owner}/${repo}`, undefined, cb);\n   }\n\n   /**\n    * Add or Update repo management status for team\n    * @see https://developer.github.com/v3/orgs/teams/#add-or-update-team-repository\n    * @param {string} owner - Organization name\n    * @param {string} repo - Repo name\n    * @param {object} options - Parameters for adding or updating repo management for the team\n    * @param {string} [options.permission] - The permission to grant the team on this repository. Can be one\n    * of: `pull`, `push`, or `admin`\n    * @param {Requestable.callback} [cb] - will receive the membership status of added user\n    * @return {Promise} - the promise for the http request\n    */\n   manageRepo(owner, repo, options, cb) {\n      log(`Adding or Updating repo management by Team ${this.__teamId} for repo ${owner}/${repo}`);\n      return this._request204or404(`/teams/${this.__teamId}/repos/${owner}/${repo}`, options, cb, 'PUT');\n   }\n\n   /**\n    * Remove repo management status for team\n    * @see https://developer.github.com/v3/orgs/teams/#remove-team-repository\n    * @param {string} owner - Organization name\n    * @param {string} repo - Repo name\n    * @param {Requestable.callback} [cb] - will receive the membership status of added user\n    * @return {Promise} - the promise for the http request\n    */\n   unmanageRepo(owner, repo, cb) {\n      log(`Remove repo management by Team ${this.__teamId} for repo ${owner}/${repo}`);\n      return this._request204or404(`/teams/${this.__teamId}/repos/${owner}/${repo}`, undefined, cb, 'DELETE');\n   }\n\n   /**\n    * Delete Team\n    * @see https://developer.github.com/v3/orgs/teams/#delete-team\n    * @param {Requestable.callback} [cb] - will receive the list of repositories\n    * @return {Promise} - the promise for the http request\n    */\n   deleteTeam(cb) {\n      log(`Deleting Team ${this.__teamId}`);\n      return this._request204or404(`/teams/${this.__teamId}`, undefined, cb, 'DELETE');\n   }\n}\n\nmodule.exports = Team;\n","/**\n * @file\n * @copyright  2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license    Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n *             Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\nimport debug from 'debug';\nconst log = debug('github:user');\n\n/**\n * A User allows scoping of API requests to a particular Github user.\n */\nclass User extends Requestable {\n   /**\n    * Create a User.\n    * @param {string} [username] - the user to use for user-scoped queries\n    * @param {Requestable.auth} [auth] - information required to authenticate to Github\n    * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n    */\n   constructor(username, auth, apiBase) {\n      super(auth, apiBase);\n      this.__user = username;\n   }\n\n   /**\n    * Get the url for the request. (dependent on if we're requesting for the authenticated user or not)\n    * @private\n    * @param {string} endpoint - the endpoint being requested\n    * @return {string} - the resolved endpoint\n    */\n   __getScopedUrl(endpoint) {\n      if (this.__user) {\n         return endpoint ?\n            `/users/${this.__user}/${endpoint}` :\n            `/users/${this.__user}`\n            ;\n\n      } else { // eslint-disable-line\n         switch (endpoint) {\n            case '':\n               return '/user';\n\n            case 'notifications':\n            case 'gists':\n               return `/${endpoint}`;\n\n            default:\n               return `/user/${endpoint}`;\n         }\n      }\n   }\n\n   /**\n    * List the user's repositories\n    * @see https://developer.github.com/v3/repos/#list-user-repositories\n    * @param {Object} [options={}] - any options to refine the search\n    * @param {Requestable.callback} [cb] - will receive the list of repositories\n    * @return {Promise} - the promise for the http request\n    */\n   listRepos(options, cb) {\n      if (typeof options === 'function') {\n         cb = options;\n         options = {};\n      }\n\n      options = this._getOptionsWithDefaults(options);\n\n      log(`Fetching repositories with options: ${JSON.stringify(options)}`);\n      return this._requestAllPages(this.__getScopedUrl('repos'), options, cb);\n   }\n\n   /**\n    * List the orgs that the user belongs to\n    * @see https://developer.github.com/v3/orgs/#list-user-organizations\n    * @param {Requestable.callback} [cb] - will receive the list of organizations\n    * @return {Promise} - the promise for the http request\n    */\n   listOrgs(cb) {\n      return this._request('GET', this.__getScopedUrl('orgs'), null, cb);\n   }\n\n   /**\n    * List the user's gists\n    * @see https://developer.github.com/v3/gists/#list-a-users-gists\n    * @param {Requestable.callback} [cb] - will receive the list of gists\n    * @return {Promise} - the promise for the http request\n    */\n   listGists(cb) {\n      return this._request('GET', this.__getScopedUrl('gists'), null, cb);\n   }\n\n   /**\n    * List the user's starred gists\n    * @see https://developer.github.com/v3/gists/#list-starred-gists\n    * @param {Requestable.callback} [cb] - will receive the list of gists\n    * @return {Promise} - the promise for the http request\n    */\n   listStarredGists(cb) {\n      return this._request('GET', this.__getScopedUrl('gists/starred'), null, cb);\n   }\n\n   /**\n    * List the user's gists\n    * @see https://developer.github.com/v3/gists/#list-a-users-gists\n    * @param {Requestable.callback} [cb] - will receive the list of gists\n    * @return {Promise} - the promise for the http request\n    */\n   listStarredGists(cb) {\n      return this._request('GET', this.__getScopedUrl('gists'), null, cb);\n   }\n\n   /**\n    * List the user's notifications\n    * @see https://developer.github.com/v3/activity/notifications/#list-your-notifications\n    * @param {Object} [options={}] - any options to refine the search\n    * @param {Requestable.callback} [cb] - will receive the list of repositories\n    * @return {Promise} - the promise for the http request\n    */\n   listNotifications(options, cb) {\n      options = options || {};\n      if (typeof options === 'function') {\n         cb = options;\n         options = {};\n      }\n\n      options.since = this._dateToISO(options.since);\n      options.before = this._dateToISO(options.before);\n\n      return this._request('GET', this.__getScopedUrl('notifications'), options, cb);\n   }\n\n   /**\n    * Show the user's profile\n    * @see https://developer.github.com/v3/users/#get-a-single-user\n    * @param {Requestable.callback} [cb] - will receive the user's information\n    * @return {Promise} - the promise for the http request\n    */\n   getProfile(cb) {\n      return this._request('GET', this.__getScopedUrl(''), null, cb);\n   }\n\n   /**\n    * Gets the list of starred repositories for the user\n    * @see https://developer.github.com/v3/activity/starring/#list-repositories-being-starred\n    * @param {Requestable.callback} [cb] - will receive the list of starred repositories\n    * @return {Promise} - the promise for the http request\n    */\n   listStarredRepos(cb) {\n      let requestOptions = this._getOptionsWithDefaults();\n      return this._requestAllPages(this.__getScopedUrl('starred'), requestOptions, cb);\n   }\n\n   /**\n    * List email addresses for a user\n    * @see https://developer.github.com/v3/users/emails/#list-email-addresses-for-a-user\n    * @param {Requestable.callback} [cb] - will receive the list of emails\n    * @return {Promise} - the promise for the http request\n    */\n   getEmails(cb) {\n      return this._request('GET', '/user/emails', null, cb);\n   }\n\n   /**\n    * Have the authenticated user follow this user\n    * @see https://developer.github.com/v3/users/followers/#follow-a-user\n    * @param {string} username - the user to follow\n    * @param {Requestable.callback} [cb] - will receive true if the request succeeds\n    * @return {Promise} - the promise for the http request\n    */\n   follow(username, cb) {\n      return this._request('PUT', `/user/following/${this.__user}`, null, cb);\n   }\n\n   /**\n    * Have the currently authenticated user unfollow this user\n    * @see https://developer.github.com/v3/users/followers/#follow-a-user\n    * @param {string} username - the user to unfollow\n    * @param {Requestable.callback} [cb] - receives true if the request succeeds\n    * @return {Promise} - the promise for the http request\n    */\n   unfollow(username, cb) {\n      return this._request('DELETE', `/user/following/${this.__user}`, null, cb);\n   }\n\n   /**\n    * Create a new repository for the currently authenticated user\n    * @see https://developer.github.com/v3/repos/#create\n    * @param {object} options - the repository definition\n    * @param {Requestable.callback} [cb] - will receive the API response\n    * @return {Promise} - the promise for the http request\n    */\n   createRepo(options, cb) {\n      return this._request('POST', '/user/repos', options, cb);\n   }\n}\n\nmodule.exports = User;\n"]}"} \ No newline at end of file +{"version":3,"sources":["node_modules/browser-pack/_prelude.js","lib/Gist.js","lib/GitHub.js","lib/Issue.js","lib/Markdown.js","lib/Organization.js","lib/Project.js","lib/RateLimit.js","lib/Repository.js","lib/Requestable.js","lib/Search.js","lib/Team.js","lib/User.js"],"names":[],"mappings":"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","file":"GitHub.js","sourcesContent":["(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require==\"function\"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error(\"Cannot find module '\"+o+\"'\");throw f.code=\"MODULE_NOT_FOUND\",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require==\"function\"&&require;for(var o=0;o {\n this.__id = response.data.id;\n return response;\n });\n }\n\n /**\n * Delete a gist.\n * @see https://developer.github.com/v3/gists/#delete-a-gist\n * @param {Requestable.callback} [cb] - will receive true if the request succeeds\n * @return {Promise} - the Promise for the http request\n */\n delete(cb) {\n return this._request('DELETE', `/gists/${this.__id}`, null, cb);\n }\n\n /**\n * Fork a gist.\n * @see https://developer.github.com/v3/gists/#fork-a-gist\n * @param {Requestable.callback} [cb] - the function that will receive the gist\n * @return {Promise} - the Promise for the http request\n */\n fork(cb) {\n return this._request('POST', `/gists/${this.__id}/forks`, null, cb);\n }\n\n /**\n * Update a gist.\n * @see https://developer.github.com/v3/gists/#edit-a-gist\n * @param {Object} gist - the new data for the gist\n * @param {Requestable.callback} [cb] - the function that receives the API result\n * @return {Promise} - the Promise for the http request\n */\n update(gist, cb) {\n return this._request('PATCH', `/gists/${this.__id}`, gist, cb);\n }\n\n /**\n * Star a gist.\n * @see https://developer.github.com/v3/gists/#star-a-gist\n * @param {Requestable.callback} [cb] - will receive true if the request is successful\n * @return {Promise} - the Promise for the http request\n */\n star(cb) {\n return this._request('PUT', `/gists/${this.__id}/star`, null, cb);\n }\n\n /**\n * Unstar a gist.\n * @see https://developer.github.com/v3/gists/#unstar-a-gist\n * @param {Requestable.callback} [cb] - will receive true if the request is successful\n * @return {Promise} - the Promise for the http request\n */\n unstar(cb) {\n return this._request('DELETE', `/gists/${this.__id}/star`, null, cb);\n }\n\n /**\n * Check if a gist is starred by the user.\n * @see https://developer.github.com/v3/gists/#check-if-a-gist-is-starred\n * @param {Requestable.callback} [cb] - will receive true if the gist is starred and false if the gist is not starred\n * @return {Promise} - the Promise for the http request\n */\n isStarred(cb) {\n return this._request204or404(`/gists/${this.__id}/star`, null, cb);\n }\n\n /**\n * List the gist's commits\n * @see https://developer.github.com/v3/gists/#list-gist-commits\n * @param {Requestable.callback} [cb] - will receive the array of commits\n * @return {Promise} - the Promise for the http request\n */\n listCommits(cb) {\n return this._requestAllPages(`/gists/${this.__id}/commits`, null, cb);\n }\n\n /**\n * Fetch one of the gist's revision.\n * @see https://developer.github.com/v3/gists/#get-a-specific-revision-of-a-gist\n * @param {string} revision - the id of the revision\n * @param {Requestable.callback} [cb] - will receive the revision\n * @return {Promise} - the Promise for the http request\n */\n getRevision(revision, cb) {\n return this._request('GET', `/gists/${this.__id}/${revision}`, null, cb);\n }\n\n /**\n * List the gist's comments\n * @see https://developer.github.com/v3/gists/comments/#list-comments-on-a-gist\n * @param {Requestable.callback} [cb] - will receive the array of comments\n * @return {Promise} - the promise for the http request\n */\n listComments(cb) {\n return this._requestAllPages(`/gists/${this.__id}/comments`, null, cb);\n }\n\n /**\n * Fetch one of the gist's comments\n * @see https://developer.github.com/v3/gists/comments/#get-a-single-comment\n * @param {number} comment - the id of the comment\n * @param {Requestable.callback} [cb] - will receive the comment\n * @return {Promise} - the Promise for the http request\n */\n getComment(comment, cb) {\n return this._request('GET', `/gists/${this.__id}/comments/${comment}`, null, cb);\n }\n\n /**\n * Comment on a gist\n * @see https://developer.github.com/v3/gists/comments/#create-a-comment\n * @param {string} comment - the comment to add\n * @param {Requestable.callback} [cb] - the function that receives the API result\n * @return {Promise} - the Promise for the http request\n */\n createComment(comment, cb) {\n return this._request('POST', `/gists/${this.__id}/comments`, {body: comment}, cb);\n }\n\n /**\n * Edit a comment on the gist\n * @see https://developer.github.com/v3/gists/comments/#edit-a-comment\n * @param {number} comment - the id of the comment\n * @param {string} body - the new comment\n * @param {Requestable.callback} [cb] - will receive the modified comment\n * @return {Promise} - the promise for the http request\n */\n editComment(comment, body, cb) {\n return this._request('PATCH', `/gists/${this.__id}/comments/${comment}`, {body: body}, cb);\n }\n\n /**\n * Delete a comment on the gist.\n * @see https://developer.github.com/v3/gists/comments/#delete-a-comment\n * @param {number} comment - the id of the comment\n * @param {Requestable.callback} [cb] - will receive true if the request succeeds\n * @return {Promise} - the Promise for the http request\n */\n deleteComment(comment, cb) {\n return this._request('DELETE', `/gists/${this.__id}/comments/${comment}`, null, cb);\n }\n}\n\nmodule.exports = Gist;\n","/**\n * @file\n * @copyright 2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n * Github.js is freely distributable.\n */\n/* eslint valid-jsdoc: [\"error\", {\"requireReturnDescription\": false}] */\n\nimport Gist from './Gist';\nimport User from './User';\nimport Issue from './Issue';\nimport Search from './Search';\nimport RateLimit from './RateLimit';\nimport Repository from './Repository';\nimport Organization from './Organization';\nimport Team from './Team';\nimport Markdown from './Markdown';\nimport Project from './Project';\n\n/**\n * GitHub encapsulates the functionality to create various API wrapper objects.\n */\nclass GitHub {\n /**\n * Create a new GitHub.\n * @param {Requestable.auth} [auth] - the credentials to authenticate to Github. If auth is\n * not provided requests will be made unauthenticated\n * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n */\n constructor(auth, apiBase = 'https://api.github.com') {\n this.__apiBase = apiBase;\n this.__auth = auth || {};\n }\n\n /**\n * Create a new Gist wrapper\n * @param {number} [id] - the id for the gist, leave undefined when creating a new gist\n * @return {Gist}\n */\n getGist(id) {\n return new Gist(id, this.__auth, this.__apiBase);\n }\n\n /**\n * Create a new User wrapper\n * @param {string} [user] - the name of the user to get information about\n * leave undefined for the authenticated user\n * @return {User}\n */\n getUser(user) {\n return new User(user, this.__auth, this.__apiBase);\n }\n\n /**\n * Create a new Organization wrapper\n * @param {string} organization - the name of the organization\n * @return {Organization}\n */\n getOrganization(organization) {\n return new Organization(organization, this.__auth, this.__apiBase);\n }\n\n /**\n * create a new Team wrapper\n * @param {string} teamId - the name of the team\n * @return {team}\n */\n getTeam(teamId) {\n return new Team(teamId, this.__auth, this.__apiBase);\n }\n\n /**\n * Create a new Repository wrapper\n * @param {string} user - the user who owns the respository\n * @param {string} repo - the name of the repository\n * @return {Repository}\n */\n getRepo(user, repo) {\n return new Repository(this._getFullName(user, repo), this.__auth, this.__apiBase);\n }\n\n /**\n * Create a new Issue wrapper\n * @param {string} user - the user who owns the respository\n * @param {string} repo - the name of the repository\n * @return {Issue}\n */\n getIssues(user, repo) {\n return new Issue(this._getFullName(user, repo), this.__auth, this.__apiBase);\n }\n\n /**\n * Create a new Search wrapper\n * @param {string} query - the query to search for\n * @return {Search}\n */\n search(query) {\n return new Search(query, this.__auth, this.__apiBase);\n }\n\n /**\n * Create a new RateLimit wrapper\n * @return {RateLimit}\n */\n getRateLimit() {\n return new RateLimit(this.__auth, this.__apiBase);\n }\n\n /**\n * Create a new Markdown wrapper\n * @return {Markdown}\n */\n getMarkdown() {\n return new Markdown(this.__auth, this.__apiBase);\n }\n\n /**\n * Create a new Project wrapper\n * @param {string} id - the id of the project\n * @return {Markdown}\n */\n getProject(id) {\n return new Project(id, this.__auth, this.__apiBase);\n }\n\n /**\n * Computes the full repository name\n * @param {string} user - the username (or the full name)\n * @param {string} repo - the repository name, must not be passed if `user` is the full name\n * @return {string} the repository's full name\n */\n _getFullName(user, repo) {\n let fullname = user;\n\n if (repo) {\n fullname = `${user}/${repo}`;\n }\n\n return fullname;\n }\n}\n\nmodule.exports = GitHub;\n","/**\n * @file\n * @copyright 2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n * Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\n\n/**\n * Issue wraps the functionality to get issues for repositories\n */\nclass Issue extends Requestable {\n /**\n * Create a new Issue\n * @param {string} repository - the full name of the repository (`:user/:repo`) to get issues for\n * @param {Requestable.auth} [auth] - information required to authenticate to Github\n * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n */\n constructor(repository, auth, apiBase) {\n super(auth, apiBase);\n this.__repository = repository;\n }\n\n /**\n * Create a new issue\n * @see https://developer.github.com/v3/issues/#create-an-issue\n * @param {Object} issueData - the issue to create\n * @param {Requestable.callback} [cb] - will receive the created issue\n * @return {Promise} - the promise for the http request\n */\n createIssue(issueData, cb) {\n return this._request('POST', `/repos/${this.__repository}/issues`, issueData, cb);\n }\n\n /**\n * List the issues for the repository\n * @see https://developer.github.com/v3/issues/#list-issues-for-a-repository\n * @param {Object} options - filtering options\n * @param {Requestable.callback} [cb] - will receive the array of issues\n * @return {Promise} - the promise for the http request\n */\n listIssues(options, cb) {\n return this._requestAllPages(`/repos/${this.__repository}/issues`, options, cb);\n }\n\n /**\n * List the events for an issue\n * @see https://developer.github.com/v3/issues/events/#list-events-for-an-issue\n * @param {number} issue - the issue to get events for\n * @param {Requestable.callback} [cb] - will receive the list of events\n * @return {Promise} - the promise for the http request\n */\n listIssueEvents(issue, cb) {\n return this._request('GET', `/repos/${this.__repository}/issues/${issue}/events`, null, cb);\n }\n\n /**\n * List comments on an issue\n * @see https://developer.github.com/v3/issues/comments/#list-comments-on-an-issue\n * @param {number} issue - the id of the issue to get comments from\n * @param {Requestable.callback} [cb] - will receive the comments\n * @return {Promise} - the promise for the http request\n */\n listIssueComments(issue, cb) {\n return this._request('GET', `/repos/${this.__repository}/issues/${issue}/comments`, null, cb);\n }\n\n /**\n * Get a single comment on an issue\n * @see https://developer.github.com/v3/issues/comments/#get-a-single-comment\n * @param {number} id - the comment id to get\n * @param {Requestable.callback} [cb] - will receive the comment\n * @return {Promise} - the promise for the http request\n */\n getIssueComment(id, cb) {\n return this._request('GET', `/repos/${this.__repository}/issues/comments/${id}`, null, cb);\n }\n\n /**\n * Comment on an issue\n * @see https://developer.github.com/v3/issues/comments/#create-a-comment\n * @param {number} issue - the id of the issue to comment on\n * @param {string} comment - the comment to add\n * @param {Requestable.callback} [cb] - will receive the created comment\n * @return {Promise} - the promise for the http request\n */\n createIssueComment(issue, comment, cb) {\n return this._request('POST', `/repos/${this.__repository}/issues/${issue}/comments`, {body: comment}, cb);\n }\n\n /**\n * Edit a comment on an issue\n * @see https://developer.github.com/v3/issues/comments/#edit-a-comment\n * @param {number} id - the comment id to edit\n * @param {string} comment - the comment to edit\n * @param {Requestable.callback} [cb] - will receive the edited comment\n * @return {Promise} - the promise for the http request\n */\n editIssueComment(id, comment, cb) {\n return this._request('PATCH', `/repos/${this.__repository}/issues/comments/${id}`, {body: comment}, cb);\n }\n\n /**\n * Delete a comment on an issue\n * @see https://developer.github.com/v3/issues/comments/#delete-a-comment\n * @param {number} id - the comment id to delete\n * @param {Requestable.callback} [cb] - will receive true if the request is successful\n * @return {Promise} - the promise for the http request\n */\n deleteIssueComment(id, cb) {\n return this._request('DELETE', `/repos/${this.__repository}/issues/comments/${id}`, null, cb);\n }\n\n /**\n * Edit an issue\n * @see https://developer.github.com/v3/issues/#edit-an-issue\n * @param {number} issue - the issue number to edit\n * @param {Object} issueData - the new issue data\n * @param {Requestable.callback} [cb] - will receive the modified issue\n * @return {Promise} - the promise for the http request\n */\n editIssue(issue, issueData, cb) {\n return this._request('PATCH', `/repos/${this.__repository}/issues/${issue}`, issueData, cb);\n }\n\n /**\n * Get a particular issue\n * @see https://developer.github.com/v3/issues/#get-a-single-issue\n * @param {number} issue - the issue number to fetch\n * @param {Requestable.callback} [cb] - will receive the issue\n * @return {Promise} - the promise for the http request\n */\n getIssue(issue, cb) {\n return this._request('GET', `/repos/${this.__repository}/issues/${issue}`, null, cb);\n }\n\n /**\n * List the milestones for the repository\n * @see https://developer.github.com/v3/issues/milestones/#list-milestones-for-a-repository\n * @param {Object} options - filtering options\n * @param {Requestable.callback} [cb] - will receive the array of milestones\n * @return {Promise} - the promise for the http request\n */\n listMilestones(options, cb) {\n return this._request('GET', `/repos/${this.__repository}/milestones`, options, cb);\n }\n\n /**\n * Get a milestone\n * @see https://developer.github.com/v3/issues/milestones/#get-a-single-milestone\n * @param {string} milestone - the id of the milestone to fetch\n * @param {Requestable.callback} [cb] - will receive the milestone\n * @return {Promise} - the promise for the http request\n */\n getMilestone(milestone, cb) {\n return this._request('GET', `/repos/${this.__repository}/milestones/${milestone}`, null, cb);\n }\n\n /**\n * Create a new milestone\n * @see https://developer.github.com/v3/issues/milestones/#create-a-milestone\n * @param {Object} milestoneData - the milestone definition\n * @param {Requestable.callback} [cb] - will receive the milestone\n * @return {Promise} - the promise for the http request\n */\n createMilestone(milestoneData, cb) {\n return this._request('POST', `/repos/${this.__repository}/milestones`, milestoneData, cb);\n }\n\n /**\n * Edit a milestone\n * @see https://developer.github.com/v3/issues/milestones/#update-a-milestone\n * @param {string} milestone - the id of the milestone to edit\n * @param {Object} milestoneData - the updates to make to the milestone\n * @param {Requestable.callback} [cb] - will receive the updated milestone\n * @return {Promise} - the promise for the http request\n */\n editMilestone(milestone, milestoneData, cb) {\n return this._request('PATCH', `/repos/${this.__repository}/milestones/${milestone}`, milestoneData, cb);\n }\n\n /**\n * Delete a milestone (this is distinct from closing a milestone)\n * @see https://developer.github.com/v3/issues/milestones/#delete-a-milestone\n * @param {string} milestone - the id of the milestone to delete\n * @param {Requestable.callback} [cb] - will receive the status\n * @return {Promise} - the promise for the http request\n */\n deleteMilestone(milestone, cb) {\n return this._request('DELETE', `/repos/${this.__repository}/milestones/${milestone}`, null, cb);\n }\n\n /**\n * Create a new label\n * @see https://developer.github.com/v3/issues/labels/#create-a-label\n * @param {Object} labelData - the label definition\n * @param {Requestable.callback} [cb] - will receive the object representing the label\n * @return {Promise} - the promise for the http request\n */\n createLabel(labelData, cb) {\n return this._request('POST', `/repos/${this.__repository}/labels`, labelData, cb);\n }\n\n /**\n * List the labels for the repository\n * @see https://developer.github.com/v3/issues/labels/#list-all-labels-for-this-repository\n * @param {Object} options - filtering options\n * @param {Requestable.callback} [cb] - will receive the array of labels\n * @return {Promise} - the promise for the http request\n */\n listLabels(options, cb) {\n return this._request('GET', `/repos/${this.__repository}/labels`, options, cb);\n }\n\n /**\n * Get a label\n * @see https://developer.github.com/v3/issues/labels/#get-a-single-label\n * @param {string} label - the name of the label to fetch\n * @param {Requestable.callback} [cb] - will receive the label\n * @return {Promise} - the promise for the http request\n */\n getLabel(label, cb) {\n return this._request('GET', `/repos/${this.__repository}/labels/${label}`, null, cb);\n }\n\n /**\n * Edit a label\n * @see https://developer.github.com/v3/issues/labels/#update-a-label\n * @param {string} label - the name of the label to edit\n * @param {Object} labelData - the updates to make to the label\n * @param {Requestable.callback} [cb] - will receive the updated label\n * @return {Promise} - the promise for the http request\n */\n editLabel(label, labelData, cb) {\n return this._request('PATCH', `/repos/${this.__repository}/labels/${label}`, labelData, cb);\n }\n\n /**\n * Delete a label\n * @see https://developer.github.com/v3/issues/labels/#delete-a-label\n * @param {string} label - the name of the label to delete\n * @param {Requestable.callback} [cb] - will receive the status\n * @return {Promise} - the promise for the http request\n */\n deleteLabel(label, cb) {\n return this._request('DELETE', `/repos/${this.__repository}/labels/${label}`, null, cb);\n }\n}\n\nmodule.exports = Issue;\n","/**\n * @file\n * @copyright 2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n * Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\n\n/**\n * Renders html from Markdown text\n */\nclass Markdown extends Requestable {\n /**\n * construct a Markdown\n * @param {Requestable.auth} auth - the credentials to authenticate to GitHub\n * @param {string} [apiBase] - the base Github API URL\n * @return {Promise} - the promise for the http request\n */\n constructor(auth, apiBase) {\n super(auth, apiBase);\n }\n\n /**\n * Render html from Markdown text.\n * @see https://developer.github.com/v3/markdown/#render-an-arbitrary-markdown-document\n * @param {Object} options - conversion options\n * @param {string} [options.text] - the markdown text to convert\n * @param {string} [options.mode=markdown] - can be either `markdown` or `gfm`\n * @param {string} [options.context] - repository name if mode is gfm\n * @param {Requestable.callback} [cb] - will receive the converted html\n * @return {Promise} - the promise for the http request\n */\n render(options, cb) {\n return this._request('POST', '/markdown', options, cb);\n }\n}\n\nmodule.exports = Markdown;\n","/**\n * @file\n * @copyright 2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n * Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\n\n/**\n * Organization encapsulates the functionality to create repositories in organizations\n */\nclass Organization extends Requestable {\n /**\n * Create a new Organization\n * @param {string} organization - the name of the organization\n * @param {Requestable.auth} [auth] - information required to authenticate to Github\n * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n */\n constructor(organization, auth, apiBase) {\n super(auth, apiBase);\n this.__name = organization;\n }\n\n /**\n * Create a repository in an organization\n * @see https://developer.github.com/v3/repos/#create\n * @param {Object} options - the repository definition\n * @param {Requestable.callback} [cb] - will receive the created repository\n * @return {Promise} - the promise for the http request\n */\n createRepo(options, cb) {\n return this._request('POST', `/orgs/${this.__name}/repos`, options, cb);\n }\n\n /**\n * List the repositories in an organization\n * @see https://developer.github.com/v3/repos/#list-organization-repositories\n * @param {Requestable.callback} [cb] - will receive the list of repositories\n * @return {Promise} - the promise for the http request\n */\n getRepos(cb) {\n let requestOptions = this._getOptionsWithDefaults({direction: 'desc'});\n\n return this._requestAllPages(`/orgs/${this.__name}/repos`, requestOptions, cb);\n }\n\n /**\n * Query if the user is a member or not\n * @param {string} username - the user in question\n * @param {Requestable.callback} [cb] - will receive true if the user is a member\n * @return {Promise} - the promise for the http request\n */\n isMember(username, cb) {\n return this._request204or404(`/orgs/${this.__name}/members/${username}`, null, cb);\n }\n\n /**\n * List the users who are members of the company\n * @see https://developer.github.com/v3/orgs/members/#members-list\n * @param {object} options - filtering options\n * @param {string} [options.filter=all] - can be either `2fa_disabled` or `all`\n * @param {string} [options.role=all] - can be one of: `all`, `admin`, or `member`\n * @param {Requestable.callback} [cb] - will receive the list of users\n * @return {Promise} - the promise for the http request\n */\n listMembers(options, cb) {\n return this._request('GET', `/orgs/${this.__name}/members`, options, cb);\n }\n\n /**\n * List the Teams in the Organization\n * @see https://developer.github.com/v3/orgs/teams/#list-teams\n * @param {Requestable.callback} [cb] - will receive the list of teams\n * @return {Promise} - the promise for the http request\n */\n getTeams(cb) {\n return this._requestAllPages(`/orgs/${this.__name}/teams`, undefined, cb);\n }\n\n /**\n * Create a team\n * @see https://developer.github.com/v3/orgs/teams/#create-team\n * @param {object} options - Team creation parameters\n * @param {string} options.name - The name of the team\n * @param {string} [options.description] - Team description\n * @param {string} [options.repo_names] - Repos to add the team to\n * @param {string} [options.privacy=secret] - The level of privacy the team should have. Can be either one\n * of: `secret`, or `closed`\n * @param {Requestable.callback} [cb] - will receive the created team\n * @return {Promise} - the promise for the http request\n */\n createTeam(options, cb) {\n return this._request('POST', `/orgs/${this.__name}/teams`, options, cb);\n }\n\n /**\n * Get information about all projects\n * @see https://developer.github.com/v3/projects/#list-organization-projects\n * @param {Requestable.callback} [cb] - will receive the list of projects\n * @return {Promise} - the promise for the http request\n */\n listProjects(cb) {\n return this._requestAllPages(`/orgs/${this.__name}/projects`, {AcceptHeader: 'inertia-preview'}, cb);\n }\n\n /**\n * Create a new project\n * @see https://developer.github.com/v3/repos/projects/#create-a-project\n * @param {Object} options - the description of the project\n * @param {Requestable.callback} cb - will receive the newly created project\n * @return {Promise} - the promise for the http request\n */\n createProject(options, cb) {\n options = options || {};\n options.AcceptHeader = 'inertia-preview';\n return this._request('POST', `/orgs/${this.__name}/projects`, options, cb);\n }\n}\n\nmodule.exports = Organization;\n","/**\n * @file\n * @copyright 2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n * Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\n\n/**\n * Project encapsulates the functionality to create, query, and modify cards and columns.\n */\nclass Project extends Requestable {\n /**\n * Create a Project.\n * @param {string} id - the id of the project\n * @param {Requestable.auth} [auth] - information required to authenticate to Github\n * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n */\n constructor(id, auth, apiBase) {\n super(auth, apiBase, 'inertia-preview');\n this.__id = id;\n }\n\n /**\n * Get information about a project\n * @see https://developer.github.com/v3/projects/#get-a-project\n * @param {Requestable.callback} cb - will receive the project information\n * @return {Promise} - the promise for the http request\n */\n getProject(cb) {\n return this._request('GET', `/projects/${this.__id}`, null, cb);\n }\n\n /**\n * Edit a project\n * @see https://developer.github.com/v3/projects/#update-a-project\n * @param {Object} options - the description of the project\n * @param {Requestable.callback} cb - will receive the modified project\n * @return {Promise} - the promise for the http request\n */\n updateProject(options, cb) {\n return this._request('PATCH', `/projects/${this.__id}`, options, cb);\n }\n\n /**\n * Delete a project\n * @see https://developer.github.com/v3/projects/#delete-a-project\n * @param {Requestable.callback} cb - will receive true if the operation is successful\n * @return {Promise} - the promise for the http request\n */\n deleteProject(cb) {\n return this._request('DELETE', `/projects/${this.__id}`, null, cb);\n }\n\n /**\n * Get information about all columns of a project\n * @see https://developer.github.com/v3/projects/columns/#list-project-columns\n * @param {Requestable.callback} [cb] - will receive the list of columns\n * @return {Promise} - the promise for the http request\n */\n listProjectColumns(cb) {\n return this._requestAllPages(`/projects/${this.__id}/columns`, null, cb);\n }\n\n /**\n * Get information about a column\n * @see https://developer.github.com/v3/projects/columns/#get-a-project-column\n * @param {string} colId - the id of the column\n * @param {Requestable.callback} cb - will receive the column information\n * @return {Promise} - the promise for the http request\n */\n getProjectColumn(colId, cb) {\n return this._request('GET', `/projects/columns/${colId}`, null, cb);\n }\n\n /**\n * Create a new column\n * @see https://developer.github.com/v3/projects/columns/#create-a-project-column\n * @param {Object} options - the description of the column\n * @param {Requestable.callback} cb - will receive the newly created column\n * @return {Promise} - the promise for the http request\n */\n createProjectColumn(options, cb) {\n return this._request('POST', `/projects/${this.__id}/columns`, options, cb);\n }\n\n /**\n * Edit a column\n * @see https://developer.github.com/v3/projects/columns/#update-a-project-column\n * @param {string} colId - the column id\n * @param {Object} options - the description of the column\n * @param {Requestable.callback} cb - will receive the modified column\n * @return {Promise} - the promise for the http request\n */\n updateProjectColumn(colId, options, cb) {\n return this._request('PATCH', `/projects/columns/${colId}`, options, cb);\n }\n\n /**\n * Delete a column\n * @see https://developer.github.com/v3/projects/columns/#delete-a-project-column\n * @param {string} colId - the column to be deleted\n * @param {Requestable.callback} cb - will receive true if the operation is successful\n * @return {Promise} - the promise for the http request\n */\n deleteProjectColumn(colId, cb) {\n return this._request('DELETE', `/projects/columns/${colId}`, null, cb);\n }\n\n /**\n * Move a column\n * @see https://developer.github.com/v3/projects/columns/#move-a-project-column\n * @param {string} colId - the column to be moved\n * @param {string} position - can be one of first, last, or after:,\n * where is the id value of a column in the same project.\n * @param {Requestable.callback} cb - will receive true if the operation is successful\n * @return {Promise} - the promise for the http request\n */\n moveProjectColumn(colId, position, cb) {\n return this._request(\n 'POST',\n `/projects/columns/${colId}/moves`,\n {position: position},\n cb\n );\n }\n\n /**\n * Get information about all cards of a project\n * @see https://developer.github.com/v3/projects/cards/#list-project-cards\n * @param {Requestable.callback} [cb] - will receive the list of cards\n * @return {Promise} - the promise for the http request\n */\n listProjectCards(cb) {\n return this.listProjectColumns()\n .then(({data}) => {\n return Promise.all(data.map((column) => {\n return this._requestAllPages(`/projects/columns/${column.id}/cards`, null);\n }));\n }).then((cardsInColumns) => {\n const cards = cardsInColumns.reduce((prev, {data}) => {\n prev.push(...data);\n return prev;\n }, []);\n if (cb) {\n cb(null, cards);\n }\n return cards;\n }).catch((err) => {\n if (cb) {\n cb(err);\n return;\n }\n throw err;\n });\n }\n\n /**\n * Get information about all cards of a column\n * @see https://developer.github.com/v3/projects/cards/#list-project-cards\n * @param {string} colId - the id of the column\n * @param {Requestable.callback} [cb] - will receive the list of cards\n * @return {Promise} - the promise for the http request\n */\n listColumnCards(colId, cb) {\n return this._requestAllPages(`/projects/columns/${colId}/cards`, null, cb);\n }\n\n /**\n * Get information about a card\n * @see https://developer.github.com/v3/projects/cards/#get-a-project-card\n * @param {string} cardId - the id of the card\n * @param {Requestable.callback} cb - will receive the card information\n * @return {Promise} - the promise for the http request\n */\n getProjectCard(cardId, cb) {\n return this._request('GET', `/projects/columns/cards/${cardId}`, null, cb);\n }\n\n /**\n * Create a new card\n * @see https://developer.github.com/v3/projects/cards/#create-a-project-card\n * @param {string} colId - the column id\n * @param {Object} options - the description of the card\n * @param {Requestable.callback} cb - will receive the newly created card\n * @return {Promise} - the promise for the http request\n */\n createProjectCard(colId, options, cb) {\n return this._request('POST', `/projects/columns/${colId}/cards`, options, cb);\n }\n\n /**\n * Edit a card\n * @see https://developer.github.com/v3/projects/cards/#update-a-project-card\n * @param {string} cardId - the card id\n * @param {Object} options - the description of the card\n * @param {Requestable.callback} cb - will receive the modified card\n * @return {Promise} - the promise for the http request\n */\n updateProjectCard(cardId, options, cb) {\n return this._request('PATCH', `/projects/columns/cards/${cardId}`, options, cb);\n }\n\n /**\n * Delete a card\n * @see https://developer.github.com/v3/projects/cards/#delete-a-project-card\n * @param {string} cardId - the card to be deleted\n * @param {Requestable.callback} cb - will receive true if the operation is successful\n * @return {Promise} - the promise for the http request\n */\n deleteProjectCard(cardId, cb) {\n return this._request('DELETE', `/projects/columns/cards/${cardId}`, null, cb);\n }\n\n /**\n * Move a card\n * @see https://developer.github.com/v3/projects/cards/#move-a-project-card\n * @param {string} cardId - the card to be moved\n * @param {string} position - can be one of top, bottom, or after:,\n * where is the id value of a card in the same project.\n * @param {string} colId - the id value of a column in the same project.\n * @param {Requestable.callback} cb - will receive true if the operation is successful\n * @return {Promise} - the promise for the http request\n */\n moveProjectCard(cardId, position, colId, cb) {\n return this._request(\n 'POST',\n `/projects/columns/cards/${cardId}/moves`,\n {position: position, column_id: colId}, // eslint-disable-line camelcase\n cb\n );\n }\n}\n\nmodule.exports = Project;\n","/**\n * @file\n * @copyright 2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n * Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\n\n/**\n * RateLimit allows users to query their rate-limit status\n */\nclass RateLimit extends Requestable {\n /**\n * construct a RateLimit\n * @param {Requestable.auth} auth - the credentials to authenticate to GitHub\n * @param {string} [apiBase] - the base Github API URL\n * @return {Promise} - the promise for the http request\n */\n constructor(auth, apiBase) {\n super(auth, apiBase);\n }\n\n /**\n * Query the current rate limit\n * @see https://developer.github.com/v3/rate_limit/\n * @param {Requestable.callback} [cb] - will receive the rate-limit data\n * @return {Promise} - the promise for the http request\n */\n getRateLimit(cb) {\n return this._request('GET', '/rate_limit', null, cb);\n }\n}\n\nmodule.exports = RateLimit;\n","/**\n * @file\n * @copyright 2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n * Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\nimport Utf8 from 'utf8';\nimport {\n Base64,\n} from 'js-base64';\nimport debug from 'debug';\nconst log = debug('github:repository');\n\n/**\n * Respository encapsulates the functionality to create, query, and modify files.\n */\nclass Repository extends Requestable {\n /**\n * Create a Repository.\n * @param {string} fullname - the full name of the repository\n * @param {Requestable.auth} [auth] - information required to authenticate to Github\n * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n */\n constructor(fullname, auth, apiBase) {\n super(auth, apiBase);\n this.__fullname = fullname;\n this.__currentTree = {\n branch: null,\n sha: null,\n };\n }\n\n /**\n * Get a reference\n * @see https://developer.github.com/v3/git/refs/#get-a-reference\n * @param {string} ref - the reference to get\n * @param {Requestable.callback} [cb] - will receive the reference's refSpec or a list of refSpecs that match `ref`\n * @return {Promise} - the promise for the http request\n */\n getRef(ref, cb) {\n return this._request('GET', `/repos/${this.__fullname}/git/refs/${ref}`, null, cb);\n }\n\n /**\n * Create a reference\n * @see https://developer.github.com/v3/git/refs/#create-a-reference\n * @param {Object} options - the object describing the ref\n * @param {Requestable.callback} [cb] - will receive the ref\n * @return {Promise} - the promise for the http request\n */\n createRef(options, cb) {\n return this._request('POST', `/repos/${this.__fullname}/git/refs`, options, cb);\n }\n\n /**\n * Delete a reference\n * @see https://developer.github.com/v3/git/refs/#delete-a-reference\n * @param {string} ref - the name of the ref to delte\n * @param {Requestable.callback} [cb] - will receive true if the request is successful\n * @return {Promise} - the promise for the http request\n */\n deleteRef(ref, cb) {\n return this._request('DELETE', `/repos/${this.__fullname}/git/refs/${ref}`, null, cb);\n }\n\n /**\n * Delete a repository\n * @see https://developer.github.com/v3/repos/#delete-a-repository\n * @param {Requestable.callback} [cb] - will receive true if the request is successful\n * @return {Promise} - the promise for the http request\n */\n deleteRepo(cb) {\n return this._request('DELETE', `/repos/${this.__fullname}`, null, cb);\n }\n\n /**\n * List the tags on a repository\n * @see https://developer.github.com/v3/repos/#list-tags\n * @param {Requestable.callback} [cb] - will receive the tag data\n * @return {Promise} - the promise for the http request\n */\n listTags(cb) {\n return this._request('GET', `/repos/${this.__fullname}/tags`, null, cb);\n }\n\n /**\n * List the open pull requests on the repository\n * @see https://developer.github.com/v3/pulls/#list-pull-requests\n * @param {Object} options - options to filter the search\n * @param {Requestable.callback} [cb] - will receive the list of PRs\n * @return {Promise} - the promise for the http request\n */\n listPullRequests(options, cb) {\n options = options || {};\n return this._request('GET', `/repos/${this.__fullname}/pulls`, options, cb);\n }\n\n /**\n * Get information about a specific pull request\n * @see https://developer.github.com/v3/pulls/#get-a-single-pull-request\n * @param {number} number - the PR you wish to fetch\n * @param {Requestable.callback} [cb] - will receive the PR from the API\n * @return {Promise} - the promise for the http request\n */\n getPullRequest(number, cb) {\n return this._request('GET', `/repos/${this.__fullname}/pulls/${number}`, null, cb);\n }\n\n /**\n * List the files of a specific pull request\n * @see https://developer.github.com/v3/pulls/#list-pull-requests-files\n * @param {number|string} number - the PR you wish to fetch\n * @param {Requestable.callback} [cb] - will receive the list of files from the API\n * @return {Promise} - the promise for the http request\n */\n listPullRequestFiles(number, cb) {\n return this._request('GET', `/repos/${this.__fullname}/pulls/${number}/files`, null, cb);\n }\n\n /**\n * Compare two branches/commits/repositories\n * @see https://developer.github.com/v3/repos/commits/#compare-two-commits\n * @param {string} base - the base commit\n * @param {string} head - the head commit\n * @param {Requestable.callback} cb - will receive the comparison\n * @return {Promise} - the promise for the http request\n */\n compareBranches(base, head, cb) {\n return this._request('GET', `/repos/${this.__fullname}/compare/${base}...${head}`, null, cb);\n }\n\n /**\n * List all the branches for the repository\n * @see https://developer.github.com/v3/repos/#list-branches\n * @param {Requestable.callback} cb - will receive the list of branches\n * @return {Promise} - the promise for the http request\n */\n listBranches(cb) {\n return this._request('GET', `/repos/${this.__fullname}/branches`, null, cb);\n }\n\n /**\n * Get a raw blob from the repository\n * @see https://developer.github.com/v3/git/blobs/#get-a-blob\n * @param {string} sha - the sha of the blob to fetch\n * @param {Requestable.callback} cb - will receive the blob from the API\n * @return {Promise} - the promise for the http request\n */\n getBlob(sha, cb) {\n return this._request('GET', `/repos/${this.__fullname}/git/blobs/${sha}`, null, cb, 'raw');\n }\n\n /**\n * Get a single branch\n * @see https://developer.github.com/v3/repos/branches/#get-branch\n * @param {string} branch - the name of the branch to fetch\n * @param {Requestable.callback} cb - will receive the branch from the API\n * @returns {Promise} - the promise for the http request\n */\n getBranch(branch, cb) {\n return this._request('GET', `/repos/${this.__fullname}/branches/${branch}`, null, cb);\n }\n\n /**\n * Get a commit from the repository\n * @see https://developer.github.com/v3/repos/commits/#get-a-single-commit\n * @param {string} sha - the sha for the commit to fetch\n * @param {Requestable.callback} cb - will receive the commit data\n * @return {Promise} - the promise for the http request\n */\n getCommit(sha, cb) {\n return this._request('GET', `/repos/${this.__fullname}/git/commits/${sha}`, null, cb);\n }\n\n /**\n * List the commits on a repository, optionally filtering by path, author or time range\n * @see https://developer.github.com/v3/repos/commits/#list-commits-on-a-repository\n * @param {Object} [options] - the filtering options for commits\n * @param {string} [options.sha] - the SHA or branch to start from\n * @param {string} [options.path] - the path to search on\n * @param {string} [options.author] - the commit author\n * @param {(Date|string)} [options.since] - only commits after this date will be returned\n * @param {(Date|string)} [options.until] - only commits before this date will be returned\n * @param {Requestable.callback} cb - will receive the list of commits found matching the criteria\n * @return {Promise} - the promise for the http request\n */\n listCommits(options, cb) {\n options = options || {};\n\n options.since = this._dateToISO(options.since);\n options.until = this._dateToISO(options.until);\n\n return this._request('GET', `/repos/${this.__fullname}/commits`, options, cb);\n }\n\n /**\n * Gets a single commit information for a repository\n * @see https://developer.github.com/v3/repos/commits/#get-a-single-commit\n * @param {string} ref - the reference for the commit-ish\n * @param {Requestable.callback} cb - will receive the commit information\n * @return {Promise} - the promise for the http request\n */\n getSingleCommit(ref, cb) {\n ref = ref || '';\n return this._request('GET', `/repos/${this.__fullname}/commits/${ref}`, null, cb);\n }\n\n /**\n * Get tha sha for a particular object in the repository. This is a convenience function\n * @see https://developer.github.com/v3/repos/contents/#get-contents\n * @param {string} [branch] - the branch to look in, or the repository's default branch if omitted\n * @param {string} path - the path of the file or directory\n * @param {Requestable.callback} cb - will receive a description of the requested object, including a `SHA` property\n * @return {Promise} - the promise for the http request\n */\n getSha(branch, path, cb) {\n branch = branch ? `?ref=${branch}` : '';\n return this._request('GET', `/repos/${this.__fullname}/contents/${path}${branch}`, null, cb);\n }\n\n /**\n * List the commit statuses for a particular sha, branch, or tag\n * @see https://developer.github.com/v3/repos/statuses/#list-statuses-for-a-specific-ref\n * @param {string} sha - the sha, branch, or tag to get statuses for\n * @param {Requestable.callback} cb - will receive the list of statuses\n * @return {Promise} - the promise for the http request\n */\n listStatuses(sha, cb) {\n return this._request('GET', `/repos/${this.__fullname}/commits/${sha}/statuses`, null, cb);\n }\n\n /**\n * Get a description of a git tree\n * @see https://developer.github.com/v3/git/trees/#get-a-tree\n * @param {string} treeSHA - the SHA of the tree to fetch\n * @param {Requestable.callback} cb - will receive the callback data\n * @return {Promise} - the promise for the http request\n */\n getTree(treeSHA, cb) {\n return this._request('GET', `/repos/${this.__fullname}/git/trees/${treeSHA}`, null, cb);\n }\n\n /**\n * Create a blob\n * @see https://developer.github.com/v3/git/blobs/#create-a-blob\n * @param {(string|Buffer|Blob)} content - the content to add to the repository\n * @param {Requestable.callback} cb - will receive the details of the created blob\n * @return {Promise} - the promise for the http request\n */\n createBlob(content, cb) {\n let postBody = this._getContentObject(content);\n\n log('sending content', postBody);\n return this._request('POST', `/repos/${this.__fullname}/git/blobs`, postBody, cb);\n }\n\n /**\n * Get the object that represents the provided content\n * @param {string|Buffer|Blob} content - the content to send to the server\n * @return {Object} the representation of `content` for the GitHub API\n */\n _getContentObject(content) {\n if (typeof content === 'string') {\n log('contet is a string');\n return {\n content: Utf8.encode(content),\n encoding: 'utf-8',\n };\n\n } else if (typeof Buffer !== 'undefined' && content instanceof Buffer) {\n log('We appear to be in Node');\n return {\n content: content.toString('base64'),\n encoding: 'base64',\n };\n\n } else if (typeof Blob !== 'undefined' && content instanceof Blob) {\n log('We appear to be in the browser');\n return {\n content: Base64.encode(content),\n encoding: 'base64',\n };\n\n } else { // eslint-disable-line\n log(`Not sure what this content is: ${typeof content}, ${JSON.stringify(content)}`);\n throw new Error('Unknown content passed to postBlob. Must be string or Buffer (node) or Blob (web)');\n }\n }\n\n /**\n * Update a tree in Git\n * @see https://developer.github.com/v3/git/trees/#create-a-tree\n * @param {string} baseTreeSHA - the SHA of the tree to update\n * @param {string} path - the path for the new file\n * @param {string} blobSHA - the SHA for the blob to put at `path`\n * @param {Requestable.callback} cb - will receive the new tree that is created\n * @return {Promise} - the promise for the http request\n * @deprecated use {@link Repository#createTree} instead\n */\n updateTree(baseTreeSHA, path, blobSHA, cb) {\n let newTree = {\n base_tree: baseTreeSHA, // eslint-disable-line\n tree: [{\n path: path,\n sha: blobSHA,\n mode: '100644',\n type: 'blob',\n }],\n };\n\n return this._request('POST', `/repos/${this.__fullname}/git/trees`, newTree, cb);\n }\n\n /**\n * Create a new tree in git\n * @see https://developer.github.com/v3/git/trees/#create-a-tree\n * @param {Object} tree - the tree to create\n * @param {string} baseSHA - the root sha of the tree\n * @param {Requestable.callback} cb - will receive the new tree that is created\n * @return {Promise} - the promise for the http request\n */\n createTree(tree, baseSHA, cb) {\n return this._request('POST', `/repos/${this.__fullname}/git/trees`, {\n tree,\n base_tree: baseSHA, // eslint-disable-line camelcase\n }, cb);\n }\n\n /**\n * Add a commit to the repository\n * @see https://developer.github.com/v3/git/commits/#create-a-commit\n * @param {string} parent - the SHA of the parent commit\n * @param {string} tree - the SHA of the tree for this commit\n * @param {string} message - the commit message\n * @param {Requestable.callback} cb - will receive the commit that is created\n * @return {Promise} - the promise for the http request\n */\n commit(parent, tree, message, cb) {\n let data = {\n message,\n tree,\n parents: [parent],\n };\n\n return this._request('POST', `/repos/${this.__fullname}/git/commits`, data, cb)\n .then((response) => {\n this.__currentTree.sha = response.data.sha; // Update latest commit\n return response;\n });\n }\n\n /**\n * Update a ref\n * @see https://developer.github.com/v3/git/refs/#update-a-reference\n * @param {string} ref - the ref to update\n * @param {string} commitSHA - the SHA to point the reference to\n * @param {boolean} force - indicates whether to force or ensure a fast-forward update\n * @param {Requestable.callback} cb - will receive the updated ref back\n * @return {Promise} - the promise for the http request\n */\n updateHead(ref, commitSHA, force, cb) {\n return this._request('PATCH', `/repos/${this.__fullname}/git/refs/${ref}`, {\n sha: commitSHA,\n force: force,\n }, cb);\n }\n\n /**\n * Update commit status\n * @see https://developer.github.com/v3/repos/statuses/\n * @param {string} commitSHA - the SHA of the commit that should be updated\n * @param {object} options - Commit status parameters\n * @param {string} options.state - The state of the status. Can be one of: pending, success, error, or failure.\n * @param {string} [options.target_url] - The target URL to associate with this status.\n * @param {string} [options.description] - A short description of the status.\n * @param {string} [options.context] - A string label to differentiate this status among CI systems.\n * @param {Requestable.callback} cb - will receive the updated commit back\n * @return {Promise} - the promise for the http request\n */\n updateStatus(commitSHA, options, cb) {\n return this._request('POST', `/repos/${this.__fullname}/statuses/${commitSHA}`, options, cb);\n }\n\n /**\n * Update repository information\n * @see https://developer.github.com/v3/repos/#edit\n * @param {object} options - New parameters that will be set to the repository\n * @param {string} options.name - Name of the repository\n * @param {string} [options.description] - A short description of the repository\n * @param {string} [options.homepage] - A URL with more information about the repository\n * @param {boolean} [options.private] - Either true to make the repository private, or false to make it public.\n * @param {boolean} [options.has_issues] - Either true to enable issues for this repository, false to disable them.\n * @param {boolean} [options.has_wiki] - Either true to enable the wiki for this repository, false to disable it.\n * @param {boolean} [options.has_downloads] - Either true to enable downloads, false to disable them.\n * @param {string} [options.default_branch] - Updates the default branch for this repository.\n * @param {Requestable.callback} cb - will receive the updated repository back\n * @return {Promise} - the promise for the http request\n */\n updateRepository(options, cb) {\n return this._request('PATCH', `/repos/${this.__fullname}`, options, cb);\n }\n\n /**\n * Get information about the repository\n * @see https://developer.github.com/v3/repos/#get\n * @param {Requestable.callback} cb - will receive the information about the repository\n * @return {Promise} - the promise for the http request\n */\n getDetails(cb) {\n return this._request('GET', `/repos/${this.__fullname}`, null, cb);\n }\n\n /**\n * List the contributors to the repository\n * @see https://developer.github.com/v3/repos/#list-contributors\n * @param {Requestable.callback} cb - will receive the list of contributors\n * @return {Promise} - the promise for the http request\n */\n getContributors(cb) {\n return this._request('GET', `/repos/${this.__fullname}/contributors`, null, cb);\n }\n\n /**\n * List the contributor stats to the repository\n * @see https://developer.github.com/v3/repos/#list-contributors\n * @param {Requestable.callback} cb - will receive the list of contributors\n * @return {Promise} - the promise for the http request\n */\n getContributorStats(cb) {\n return this._request('GET', `/repos/${this.__fullname}/stats/contributors`, null, cb);\n }\n\n /**\n * List the users who are collaborators on the repository. The currently authenticated user must have\n * push access to use this method\n * @see https://developer.github.com/v3/repos/collaborators/#list-collaborators\n * @param {Requestable.callback} cb - will receive the list of collaborators\n * @return {Promise} - the promise for the http request\n */\n getCollaborators(cb) {\n return this._request('GET', `/repos/${this.__fullname}/collaborators`, null, cb);\n }\n\n /**\n * Check if a user is a collaborator on the repository\n * @see https://developer.github.com/v3/repos/collaborators/#check-if-a-user-is-a-collaborator\n * @param {string} username - the user to check\n * @param {Requestable.callback} cb - will receive true if the user is a collaborator and false if they are not\n * @return {Promise} - the promise for the http request {Boolean} [description]\n */\n isCollaborator(username, cb) {\n return this._request('GET', `/repos/${this.__fullname}/collaborators/${username}`, null, cb);\n }\n\n /**\n * Get the contents of a repository\n * @see https://developer.github.com/v3/repos/contents/#get-contents\n * @param {string} ref - the ref to check\n * @param {string} path - the path containing the content to fetch\n * @param {boolean} raw - `true` if the results should be returned raw instead of GitHub's normalized format\n * @param {Requestable.callback} cb - will receive the fetched data\n * @return {Promise} - the promise for the http request\n */\n getContents(ref, path, raw, cb) {\n path = path ? `${encodeURI(path)}` : '';\n return this._request('GET', `/repos/${this.__fullname}/contents/${path}`, {\n ref,\n }, cb, raw);\n }\n\n /**\n * Get the README of a repository\n * @see https://developer.github.com/v3/repos/contents/#get-the-readme\n * @param {string} ref - the ref to check\n * @param {boolean} raw - `true` if the results should be returned raw instead of GitHub's normalized format\n * @param {Requestable.callback} cb - will receive the fetched data\n * @return {Promise} - the promise for the http request\n */\n getReadme(ref, raw, cb) {\n return this._request('GET', `/repos/${this.__fullname}/readme`, {\n ref,\n }, cb, raw);\n }\n\n /**\n * Fork a repository\n * @see https://developer.github.com/v3/repos/forks/#create-a-fork\n * @param {Requestable.callback} cb - will receive the information about the newly created fork\n * @return {Promise} - the promise for the http request\n */\n fork(cb) {\n return this._request('POST', `/repos/${this.__fullname}/forks`, null, cb);\n }\n\n /**\n * List a repository's forks\n * @see https://developer.github.com/v3/repos/forks/#list-forks\n * @param {Requestable.callback} cb - will receive the list of repositories forked from this one\n * @return {Promise} - the promise for the http request\n */\n listForks(cb) {\n return this._request('GET', `/repos/${this.__fullname}/forks`, null, cb);\n }\n\n /**\n * Create a new branch from an existing branch.\n * @param {string} [oldBranch=master] - the name of the existing branch\n * @param {string} newBranch - the name of the new branch\n * @param {Requestable.callback} cb - will receive the commit data for the head of the new branch\n * @return {Promise} - the promise for the http request\n */\n createBranch(oldBranch, newBranch, cb) {\n if (typeof newBranch === 'function') {\n cb = newBranch;\n newBranch = oldBranch;\n oldBranch = 'master';\n }\n\n return this.getRef(`heads/${oldBranch}`)\n .then((response) => {\n let sha = response.data.object.sha;\n return this.createRef({\n sha,\n ref: `refs/heads/${newBranch}`,\n }, cb);\n });\n }\n\n /**\n * Create a new pull request\n * @see https://developer.github.com/v3/pulls/#create-a-pull-request\n * @param {Object} options - the pull request description\n * @param {Requestable.callback} cb - will receive the new pull request\n * @return {Promise} - the promise for the http request\n */\n createPullRequest(options, cb) {\n return this._request('POST', `/repos/${this.__fullname}/pulls`, options, cb);\n }\n\n /**\n * Update a pull request\n * @see https://developer.github.com/v3/pulls/#update-a-pull-request\n * @param {number|string} number - the number of the pull request to update\n * @param {Object} options - the pull request description\n * @param {Requestable.callback} [cb] - will receive the pull request information\n * @return {Promise} - the promise for the http request\n */\n updatePullRequest(number, options, cb) {\n return this._request('PATCH', `/repos/${this.__fullname}/pulls/${number}`, options, cb);\n }\n\n /**\n * List the hooks for the repository\n * @see https://developer.github.com/v3/repos/hooks/#list-hooks\n * @param {Requestable.callback} cb - will receive the list of hooks\n * @return {Promise} - the promise for the http request\n */\n listHooks(cb) {\n return this._request('GET', `/repos/${this.__fullname}/hooks`, null, cb);\n }\n\n /**\n * Get a hook for the repository\n * @see https://developer.github.com/v3/repos/hooks/#get-single-hook\n * @param {number} id - the id of the webook\n * @param {Requestable.callback} cb - will receive the details of the webook\n * @return {Promise} - the promise for the http request\n */\n getHook(id, cb) {\n return this._request('GET', `/repos/${this.__fullname}/hooks/${id}`, null, cb);\n }\n\n /**\n * Add a new hook to the repository\n * @see https://developer.github.com/v3/repos/hooks/#create-a-hook\n * @param {Object} options - the configuration describing the new hook\n * @param {Requestable.callback} cb - will receive the new webhook\n * @return {Promise} - the promise for the http request\n */\n createHook(options, cb) {\n return this._request('POST', `/repos/${this.__fullname}/hooks`, options, cb);\n }\n\n /**\n * Edit an existing webhook\n * @see https://developer.github.com/v3/repos/hooks/#edit-a-hook\n * @param {number} id - the id of the webhook\n * @param {Object} options - the new description of the webhook\n * @param {Requestable.callback} cb - will receive the updated webhook\n * @return {Promise} - the promise for the http request\n */\n updateHook(id, options, cb) {\n return this._request('PATCH', `/repos/${this.__fullname}/hooks/${id}`, options, cb);\n }\n\n /**\n * Delete a webhook\n * @see https://developer.github.com/v3/repos/hooks/#delete-a-hook\n * @param {number} id - the id of the webhook to be deleted\n * @param {Requestable.callback} cb - will receive true if the call is successful\n * @return {Promise} - the promise for the http request\n */\n deleteHook(id, cb) {\n return this._request('DELETE', `/repos/${this.__fullname}/hooks/${id}`, null, cb);\n }\n\n /**\n * List the deploy keys for the repository\n * @see https://developer.github.com/v3/repos/keys/#list-deploy-keys\n * @param {Requestable.callback} cb - will receive the list of deploy keys\n * @return {Promise} - the promise for the http request\n */\n listKeys(cb) {\n return this._request('GET', `/repos/${this.__fullname}/keys`, null, cb);\n }\n\n /**\n * Get a deploy key for the repository\n * @see https://developer.github.com/v3/repos/keys/#get-a-deploy-key\n * @param {number} id - the id of the deploy key\n * @param {Requestable.callback} cb - will receive the details of the deploy key\n * @return {Promise} - the promise for the http request\n */\n getKey(id, cb) {\n return this._request('GET', `/repos/${this.__fullname}/keys/${id}`, null, cb);\n }\n\n /**\n * Add a new deploy key to the repository\n * @see https://developer.github.com/v3/repos/keys/#add-a-new-deploy-key\n * @param {Object} options - the configuration describing the new deploy key\n * @param {Requestable.callback} cb - will receive the new deploy key\n * @return {Promise} - the promise for the http request\n */\n createKey(options, cb) {\n return this._request('POST', `/repos/${this.__fullname}/keys`, options, cb);\n }\n\n /**\n * Delete a deploy key\n * @see https://developer.github.com/v3/repos/keys/#remove-a-deploy-key\n * @param {number} id - the id of the deploy key to be deleted\n * @param {Requestable.callback} cb - will receive true if the call is successful\n * @return {Promise} - the promise for the http request\n */\n deleteKey(id, cb) {\n return this._request('DELETE', `/repos/${this.__fullname}/keys/${id}`, null, cb);\n }\n\n /**\n * Delete a file from a branch\n * @see https://developer.github.com/v3/repos/contents/#delete-a-file\n * @param {string} branch - the branch to delete from, or the default branch if not specified\n * @param {string} path - the path of the file to remove\n * @param {Requestable.callback} cb - will receive the commit in which the delete occurred\n * @return {Promise} - the promise for the http request\n */\n deleteFile(branch, path, cb) {\n return this.getSha(branch, path)\n .then((response) => {\n const deleteCommit = {\n message: `Delete the file at '${path}'`,\n sha: response.data.sha,\n branch,\n };\n return this._request('DELETE', `/repos/${this.__fullname}/contents/${path}`, deleteCommit, cb);\n });\n }\n\n /**\n * Change all references in a repo from oldPath to new_path\n * @param {string} branch - the branch to carry out the reference change, or the default branch if not specified\n * @param {string} oldPath - original path\n * @param {string} newPath - new reference path\n * @param {Requestable.callback} cb - will receive the commit in which the move occurred\n * @return {Promise} - the promise for the http request\n */\n move(branch, oldPath, newPath, cb) {\n let oldSha;\n return this.getRef(`heads/${branch}`)\n .then(({data: {object}}) => this.getTree(`${object.sha}?recursive=true`))\n .then(({data: {tree, sha}}) => {\n oldSha = sha;\n let newTree = tree.map((ref) => {\n if (ref.path === oldPath) {\n ref.path = newPath;\n }\n if (ref.type === 'tree') {\n delete ref.sha;\n }\n return ref;\n });\n return this.createTree(newTree);\n })\n .then(({data: tree}) => this.commit(oldSha, tree.sha, `Renamed '${oldPath}' to '${newPath}'`))\n .then(({data: commit}) => this.updateHead(`heads/${branch}`, commit.sha, true, cb));\n }\n\n /**\n * Write a file to the repository\n * @see https://developer.github.com/v3/repos/contents/#update-a-file\n * @param {string} branch - the name of the branch\n * @param {string} path - the path for the file\n * @param {string} content - the contents of the file\n * @param {string} message - the commit message\n * @param {Object} [options] - commit options\n * @param {Object} [options.author] - the author of the commit\n * @param {Object} [options.commiter] - the committer\n * @param {boolean} [options.encode] - true if the content should be base64 encoded\n * @param {Requestable.callback} cb - will receive the new commit\n * @return {Promise} - the promise for the http request\n */\n writeFile(branch, path, content, message, options, cb) {\n if (typeof options === 'function') {\n cb = options;\n options = {};\n }\n let filePath = path ? encodeURI(path) : '';\n let shouldEncode = options.encode !== false;\n let commit = {\n branch,\n message,\n author: options.author,\n committer: options.committer,\n content: shouldEncode ? Base64.encode(content) : content,\n };\n\n return this.getSha(branch, filePath)\n .then((response) => {\n commit.sha = response.data.sha;\n return this._request('PUT', `/repos/${this.__fullname}/contents/${filePath}`, commit, cb);\n }, () => {\n return this._request('PUT', `/repos/${this.__fullname}/contents/${filePath}`, commit, cb);\n });\n }\n\n /**\n * Check if a repository is starred by you\n * @see https://developer.github.com/v3/activity/starring/#check-if-you-are-starring-a-repository\n * @param {Requestable.callback} cb - will receive true if the repository is starred and false if the repository\n * is not starred\n * @return {Promise} - the promise for the http request {Boolean} [description]\n */\n isStarred(cb) {\n return this._request204or404(`/user/starred/${this.__fullname}`, null, cb);\n }\n\n /**\n * Star a repository\n * @see https://developer.github.com/v3/activity/starring/#star-a-repository\n * @param {Requestable.callback} cb - will receive true if the repository is starred\n * @return {Promise} - the promise for the http request\n */\n star(cb) {\n return this._request('PUT', `/user/starred/${this.__fullname}`, null, cb);\n }\n\n /**\n * Unstar a repository\n * @see https://developer.github.com/v3/activity/starring/#unstar-a-repository\n * @param {Requestable.callback} cb - will receive true if the repository is unstarred\n * @return {Promise} - the promise for the http request\n */\n unstar(cb) {\n return this._request('DELETE', `/user/starred/${this.__fullname}`, null, cb);\n }\n\n /**\n * Create a new release\n * @see https://developer.github.com/v3/repos/releases/#create-a-release\n * @param {Object} options - the description of the release\n * @param {Requestable.callback} cb - will receive the newly created release\n * @return {Promise} - the promise for the http request\n */\n createRelease(options, cb) {\n return this._request('POST', `/repos/${this.__fullname}/releases`, options, cb);\n }\n\n /**\n * Edit a release\n * @see https://developer.github.com/v3/repos/releases/#edit-a-release\n * @param {string} id - the id of the release\n * @param {Object} options - the description of the release\n * @param {Requestable.callback} cb - will receive the modified release\n * @return {Promise} - the promise for the http request\n */\n updateRelease(id, options, cb) {\n return this._request('PATCH', `/repos/${this.__fullname}/releases/${id}`, options, cb);\n }\n\n /**\n * Get information about all releases\n * @see https://developer.github.com/v3/repos/releases/#list-releases-for-a-repository\n * @param {Requestable.callback} cb - will receive the release information\n * @return {Promise} - the promise for the http request\n */\n listReleases(cb) {\n return this._request('GET', `/repos/${this.__fullname}/releases`, null, cb);\n }\n\n /**\n * Get information about a release\n * @see https://developer.github.com/v3/repos/releases/#get-a-single-release\n * @param {string} id - the id of the release\n * @param {Requestable.callback} cb - will receive the release information\n * @return {Promise} - the promise for the http request\n */\n getRelease(id, cb) {\n return this._request('GET', `/repos/${this.__fullname}/releases/${id}`, null, cb);\n }\n\n /**\n * Delete a release\n * @see https://developer.github.com/v3/repos/releases/#delete-a-release\n * @param {string} id - the release to be deleted\n * @param {Requestable.callback} cb - will receive true if the operation is successful\n * @return {Promise} - the promise for the http request\n */\n deleteRelease(id, cb) {\n return this._request('DELETE', `/repos/${this.__fullname}/releases/${id}`, null, cb);\n }\n\n /**\n * Merge a pull request\n * @see https://developer.github.com/v3/pulls/#merge-a-pull-request-merge-button\n * @param {number|string} number - the number of the pull request to merge\n * @param {Object} options - the merge options for the pull request\n * @param {Requestable.callback} [cb] - will receive the merge information if the operation is successful\n * @return {Promise} - the promise for the http request\n */\n mergePullRequest(number, options, cb) {\n return this._request('PUT', `/repos/${this.__fullname}/pulls/${number}/merge`, options, cb);\n }\n\n /**\n * Get information about all projects\n * @see https://developer.github.com/v3/projects/#list-repository-projects\n * @param {Requestable.callback} [cb] - will receive the list of projects\n * @return {Promise} - the promise for the http request\n */\n listProjects(cb) {\n return this._requestAllPages(`/repos/${this.__fullname}/projects`, {AcceptHeader: 'inertia-preview'}, cb);\n }\n\n /**\n * Create a new project\n * @see https://developer.github.com/v3/projects/#create-a-repository-project\n * @param {Object} options - the description of the project\n * @param {Requestable.callback} cb - will receive the newly created project\n * @return {Promise} - the promise for the http request\n */\n createProject(options, cb) {\n options = options || {};\n options.AcceptHeader = 'inertia-preview';\n return this._request('POST', `/repos/${this.__fullname}/projects`, options, cb);\n }\n\n}\n\nmodule.exports = Repository;\n","/**\n * @file\n * @copyright 2016 Yahoo Inc.\n * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n * Github.js is freely distributable.\n */\n\nimport axios from 'axios';\nimport debug from 'debug';\nimport {Base64} from 'js-base64';\n\nconst log = debug('github:request');\n\n/**\n * The error structure returned when a network call fails\n */\nclass ResponseError extends Error {\n /**\n * Construct a new ResponseError\n * @param {string} message - an message to return instead of the the default error message\n * @param {string} path - the requested path\n * @param {Object} response - the object returned by Axios\n */\n constructor(message, path, response) {\n super(message);\n this.path = path;\n this.request = response.config;\n this.response = (response || {}).response || response;\n this.status = response.status;\n }\n}\n\n/**\n * Requestable wraps the logic for making http requests to the API\n */\nclass Requestable {\n /**\n * Either a username and password or an oauth token for Github\n * @typedef {Object} Requestable.auth\n * @prop {string} [username] - the Github username\n * @prop {string} [password] - the user's password\n * @prop {token} [token] - an OAuth token\n */\n /**\n * Initialize the http internals.\n * @param {Requestable.auth} [auth] - the credentials to authenticate to Github. If auth is\n * not provided request will be made unauthenticated\n * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n * @param {string} [AcceptHeader=v3] - the accept header for the requests\n */\n constructor(auth, apiBase, AcceptHeader) {\n this.__apiBase = apiBase || 'https://api.github.com';\n this.__auth = {\n token: auth.token,\n username: auth.username,\n password: auth.password,\n };\n this.__AcceptHeader = AcceptHeader || 'v3';\n\n if (auth.token) {\n this.__authorizationHeader = 'token ' + auth.token;\n } else if (auth.username && auth.password) {\n this.__authorizationHeader = 'Basic ' + Base64.encode(auth.username + ':' + auth.password);\n }\n }\n\n /**\n * Compute the URL to use to make a request.\n * @private\n * @param {string} path - either a URL relative to the API base or an absolute URL\n * @return {string} - the URL to use\n */\n __getURL(path) {\n let url = path;\n\n if (path.indexOf('//') === -1) {\n url = this.__apiBase + path;\n }\n\n let newCacheBuster = 'timestamp=' + new Date().getTime();\n return url.replace(/(timestamp=\\d+)/, newCacheBuster);\n }\n\n /**\n * Compute the headers required for an API request.\n * @private\n * @param {boolean} raw - if the request should be treated as JSON or as a raw request\n * @param {string} AcceptHeader - the accept header for the request\n * @return {Object} - the headers to use in the request\n */\n __getRequestHeaders(raw, AcceptHeader) {\n let headers = {\n 'Content-Type': 'application/json;charset=UTF-8',\n 'Accept': 'application/vnd.github.' + (AcceptHeader || this.__AcceptHeader),\n };\n\n if (raw) {\n headers.Accept += '.raw';\n }\n headers.Accept += '+json';\n\n if (this.__authorizationHeader) {\n headers.Authorization = this.__authorizationHeader;\n }\n\n return headers;\n }\n\n /**\n * Sets the default options for API requests\n * @protected\n * @param {Object} [requestOptions={}] - the current options for the request\n * @return {Object} - the options to pass to the request\n */\n _getOptionsWithDefaults(requestOptions = {}) {\n if (!(requestOptions.visibility || requestOptions.affiliation)) {\n requestOptions.type = requestOptions.type || 'all';\n }\n requestOptions.sort = requestOptions.sort || 'updated';\n requestOptions.per_page = requestOptions.per_page || '100'; // eslint-disable-line\n\n return requestOptions;\n }\n\n /**\n * if a `Date` is passed to this function it will be converted to an ISO string\n * @param {*} date - the object to attempt to cooerce into an ISO date string\n * @return {string} - the ISO representation of `date` or whatever was passed in if it was not a date\n */\n _dateToISO(date) {\n if (date && (date instanceof Date)) {\n date = date.toISOString();\n }\n\n return date;\n }\n\n /**\n * A function that receives the result of the API request.\n * @callback Requestable.callback\n * @param {Requestable.Error} error - the error returned by the API or `null`\n * @param {(Object|true)} result - the data returned by the API or `true` if the API returns `204 No Content`\n * @param {Object} request - the raw {@linkcode https://github.com/mzabriskie/axios#response-schema Response}\n */\n /**\n * Make a request.\n * @param {string} method - the method for the request (GET, PUT, POST, DELETE)\n * @param {string} path - the path for the request\n * @param {*} [data] - the data to send to the server. For HTTP methods that don't have a body the data\n * will be sent as query parameters\n * @param {Requestable.callback} [cb] - the callback for the request\n * @param {boolean} [raw=false] - if the request should be sent as raw. If this is a falsy value then the\n * request will be made as JSON\n * @return {Promise} - the Promise for the http request\n */\n _request(method, path, data, cb, raw) {\n const url = this.__getURL(path);\n\n const AcceptHeader = (data || {}).AcceptHeader;\n if (AcceptHeader) {\n delete data.AcceptHeader;\n }\n const headers = this.__getRequestHeaders(raw, AcceptHeader);\n\n let queryParams = {};\n\n const shouldUseDataAsParams = data && (typeof data === 'object') && methodHasNoBody(method);\n if (shouldUseDataAsParams) {\n queryParams = data;\n data = undefined;\n }\n\n const config = {\n url: url,\n method: method,\n headers: headers,\n params: queryParams,\n data: data,\n responseType: raw ? 'text' : 'json',\n };\n\n log(`${config.method} to ${config.url}`);\n const requestPromise = axios(config).catch(callbackErrorOrThrow(cb, path));\n\n if (cb) {\n requestPromise.then((response) => {\n if (response.data && Object.keys(response.data).length > 0) {\n // When data has results\n cb(null, response.data, response);\n } else if (config.method !== 'GET' && Object.keys(response.data).length < 1) {\n // True when successful submit a request and receive a empty object\n cb(null, (response.status < 300), response);\n } else {\n cb(null, response.data, response);\n }\n });\n }\n\n return requestPromise;\n }\n\n /**\n * Make a request to an endpoint the returns 204 when true and 404 when false\n * @param {string} path - the path to request\n * @param {Object} data - any query parameters for the request\n * @param {Requestable.callback} cb - the callback that will receive `true` or `false`\n * @param {method} [method=GET] - HTTP Method to use\n * @return {Promise} - the promise for the http request\n */\n _request204or404(path, data, cb, method = 'GET') {\n return this._request(method, path, data)\n .then(function success(response) {\n if (cb) {\n cb(null, true, response);\n }\n return true;\n }, function failure(response) {\n if (response.response.status === 404) {\n if (cb) {\n cb(null, false, response);\n }\n return false;\n }\n\n if (cb) {\n cb(response);\n }\n throw response;\n });\n }\n\n /**\n * Make a request and fetch all the available data. Github will paginate responses so for queries\n * that might span multiple pages this method is preferred to {@link Requestable#request}\n * @param {string} path - the path to request\n * @param {Object} options - the query parameters to include\n * @param {Requestable.callback} [cb] - the function to receive the data. The returned data will always be an array.\n * @param {Object[]} results - the partial results. This argument is intended for interal use only.\n * @return {Promise} - a promise which will resolve when all pages have been fetched\n * @deprecated This will be folded into {@link Requestable#_request} in the 2.0 release.\n */\n _requestAllPages(path, options, cb, results) {\n results = results || [];\n\n return this._request('GET', path, options)\n .then((response) => {\n let thisGroup;\n if (response.data instanceof Array) {\n thisGroup = response.data;\n } else if (response.data.items instanceof Array) {\n thisGroup = response.data.items;\n } else {\n let message = `cannot figure out how to append ${response.data} to the result set`;\n throw new ResponseError(message, path, response);\n }\n results.push(...thisGroup);\n\n const nextUrl = getNextPage(response.headers.link);\n if (nextUrl && typeof options.page !== 'number') {\n log(`getting next page: ${nextUrl}`);\n return this._requestAllPages(nextUrl, options, cb, results);\n }\n\n if (cb) {\n cb(null, results, response);\n }\n\n response.data = results;\n return response;\n }).catch(callbackErrorOrThrow(cb, path));\n }\n}\n\nmodule.exports = Requestable;\n\n// ////////////////////////// //\n// Private helper functions //\n// ////////////////////////// //\nconst METHODS_WITH_NO_BODY = ['GET', 'HEAD', 'DELETE'];\nfunction methodHasNoBody(method) {\n return METHODS_WITH_NO_BODY.indexOf(method) !== -1;\n}\n\nfunction getNextPage(linksHeader = '') {\n const links = linksHeader.split(/\\s*,\\s*/); // splits and strips the urls\n return links.reduce(function(nextUrl, link) {\n if (link.search(/rel=\"next\"/) !== -1) {\n return (link.match(/<(.*)>/) || [])[1];\n }\n\n return nextUrl;\n }, undefined);\n}\n\nfunction callbackErrorOrThrow(cb, path) {\n return function handler(object) {\n let error;\n if (object.hasOwnProperty('config')) {\n const {response: {status, statusText}, config: {method, url}} = object;\n let message = (`${status} error making request ${method} ${url}: \"${statusText}\"`);\n error = new ResponseError(message, path, object);\n log(`${message} ${JSON.stringify(object.data)}`);\n } else {\n error = object;\n }\n if (cb) {\n log('going to error callback');\n cb(error);\n } else {\n log('throwing error');\n throw error;\n }\n };\n}\n","/**\n * @file\n * @copyright 2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n * Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\nimport debug from 'debug';\nconst log = debug('github:search');\n\n/**\n * Wrap the Search API\n */\nclass Search extends Requestable {\n /**\n * Create a Search\n * @param {Object} defaults - defaults for the search\n * @param {Requestable.auth} [auth] - information required to authenticate to Github\n * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n */\n constructor(defaults, auth, apiBase) {\n super(auth, apiBase);\n this.__defaults = this._getOptionsWithDefaults(defaults);\n }\n\n /**\n * Available search options\n * @see https://developer.github.com/v3/search/#parameters\n * @typedef {Object} Search.Params\n * @param {string} q - the query to make\n * @param {string} sort - the sort field, one of `stars`, `forks`, or `updated`.\n * Default is [best match](https://developer.github.com/v3/search/#ranking-search-results)\n * @param {string} order - the ordering, either `asc` or `desc`\n */\n /**\n * Perform a search on the GitHub API\n * @private\n * @param {string} path - the scope of the search\n * @param {Search.Params} [withOptions] - additional parameters for the search\n * @param {Requestable.callback} [cb] - will receive the results of the search\n * @return {Promise} - the promise for the http request\n */\n _search(path, withOptions = {}, cb = undefined) {\n let requestOptions = {};\n Object.keys(this.__defaults).forEach((prop) => {\n requestOptions[prop] = this.__defaults[prop];\n });\n Object.keys(withOptions).forEach((prop) => {\n requestOptions[prop] = withOptions[prop];\n });\n\n log(`searching ${path} with options:`, requestOptions);\n return this._requestAllPages(`/search/${path}`, requestOptions, cb);\n }\n\n /**\n * Search for repositories\n * @see https://developer.github.com/v3/search/#search-repositories\n * @param {Search.Params} [options] - additional parameters for the search\n * @param {Requestable.callback} [cb] - will receive the results of the search\n * @return {Promise} - the promise for the http request\n */\n forRepositories(options, cb) {\n return this._search('repositories', options, cb);\n }\n\n /**\n * Search for code\n * @see https://developer.github.com/v3/search/#search-code\n * @param {Search.Params} [options] - additional parameters for the search\n * @param {Requestable.callback} [cb] - will receive the results of the search\n * @return {Promise} - the promise for the http request\n */\n forCode(options, cb) {\n return this._search('code', options, cb);\n }\n\n /**\n * Search for issues\n * @see https://developer.github.com/v3/search/#search-issues\n * @param {Search.Params} [options] - additional parameters for the search\n * @param {Requestable.callback} [cb] - will receive the results of the search\n * @return {Promise} - the promise for the http request\n */\n forIssues(options, cb) {\n return this._search('issues', options, cb);\n }\n\n /**\n * Search for users\n * @see https://developer.github.com/v3/search/#search-users\n * @param {Search.Params} [options] - additional parameters for the search\n * @param {Requestable.callback} [cb] - will receive the results of the search\n * @return {Promise} - the promise for the http request\n */\n forUsers(options, cb) {\n return this._search('users', options, cb);\n }\n}\n\nmodule.exports = Search;\n","/**\n * @file\n * @copyright 2016 Matt Smith (Development Seed)\n * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n * Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\nimport debug from 'debug';\nconst log = debug('github:team');\n\n/**\n * A Team allows scoping of API requests to a particular Github Organization Team.\n */\nclass Team extends Requestable {\n /**\n * Create a Team.\n * @param {string} [teamId] - the id for the team\n * @param {Requestable.auth} [auth] - information required to authenticate to Github\n * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n */\n constructor(teamId, auth, apiBase) {\n super(auth, apiBase);\n this.__teamId = teamId;\n }\n\n /**\n * Get Team information\n * @see https://developer.github.com/v3/orgs/teams/#get-team\n * @param {Requestable.callback} [cb] - will receive the team\n * @return {Promise} - the promise for the http request\n */\n getTeam(cb) {\n log(`Fetching Team ${this.__teamId}`);\n return this._request('Get', `/teams/${this.__teamId}`, undefined, cb);\n }\n\n /**\n * List the Team's repositories\n * @see https://developer.github.com/v3/orgs/teams/#list-team-repos\n * @param {Requestable.callback} [cb] - will receive the list of repositories\n * @return {Promise} - the promise for the http request\n */\n listRepos(cb) {\n log(`Fetching repositories for Team ${this.__teamId}`);\n return this._requestAllPages(`/teams/${this.__teamId}/repos`, undefined, cb);\n }\n\n /**\n * Edit Team information\n * @see https://developer.github.com/v3/orgs/teams/#edit-team\n * @param {object} options - Parameters for team edit\n * @param {string} options.name - The name of the team\n * @param {string} [options.description] - Team description\n * @param {string} [options.repo_names] - Repos to add the team to\n * @param {string} [options.privacy=secret] - The level of privacy the team should have. Can be either one\n * of: `secret`, or `closed`\n * @param {Requestable.callback} [cb] - will receive the updated team\n * @return {Promise} - the promise for the http request\n */\n editTeam(options, cb) {\n log(`Editing Team ${this.__teamId}`);\n return this._request('PATCH', `/teams/${this.__teamId}`, options, cb);\n }\n\n /**\n * List the users who are members of the Team\n * @see https://developer.github.com/v3/orgs/teams/#list-team-members\n * @param {object} options - Parameters for listing team users\n * @param {string} [options.role=all] - can be one of: `all`, `maintainer`, or `member`\n * @param {Requestable.callback} [cb] - will receive the list of users\n * @return {Promise} - the promise for the http request\n */\n listMembers(options, cb) {\n log(`Getting members of Team ${this.__teamId}`);\n return this._requestAllPages(`/teams/${this.__teamId}/members`, options, cb);\n }\n\n /**\n * Get Team membership status for a user\n * @see https://developer.github.com/v3/orgs/teams/#get-team-membership\n * @param {string} username - can be one of: `all`, `maintainer`, or `member`\n * @param {Requestable.callback} [cb] - will receive the membership status of a user\n * @return {Promise} - the promise for the http request\n */\n getMembership(username, cb) {\n log(`Getting membership of user ${username} in Team ${this.__teamId}`);\n return this._request('GET', `/teams/${this.__teamId}/memberships/${username}`, undefined, cb);\n }\n\n /**\n * Add a member to the Team\n * @see https://developer.github.com/v3/orgs/teams/#add-team-membership\n * @param {string} username - can be one of: `all`, `maintainer`, or `member`\n * @param {object} options - Parameters for adding a team member\n * @param {string} [options.role=member] - The role that this user should have in the team. Can be one\n * of: `member`, or `maintainer`\n * @param {Requestable.callback} [cb] - will receive the membership status of added user\n * @return {Promise} - the promise for the http request\n */\n addMembership(username, options, cb) {\n log(`Adding user ${username} to Team ${this.__teamId}`);\n return this._request('PUT', `/teams/${this.__teamId}/memberships/${username}`, options, cb);\n }\n\n /**\n * Get repo management status for team\n * @see https://developer.github.com/v3/orgs/teams/#remove-team-membership\n * @param {string} owner - Organization name\n * @param {string} repo - Repo name\n * @param {Requestable.callback} [cb] - will receive the membership status of added user\n * @return {Promise} - the promise for the http request\n */\n isManagedRepo(owner, repo, cb) {\n log(`Getting repo management by Team ${this.__teamId} for repo ${owner}/${repo}`);\n return this._request204or404(`/teams/${this.__teamId}/repos/${owner}/${repo}`, undefined, cb);\n }\n\n /**\n * Add or Update repo management status for team\n * @see https://developer.github.com/v3/orgs/teams/#add-or-update-team-repository\n * @param {string} owner - Organization name\n * @param {string} repo - Repo name\n * @param {object} options - Parameters for adding or updating repo management for the team\n * @param {string} [options.permission] - The permission to grant the team on this repository. Can be one\n * of: `pull`, `push`, or `admin`\n * @param {Requestable.callback} [cb] - will receive the membership status of added user\n * @return {Promise} - the promise for the http request\n */\n manageRepo(owner, repo, options, cb) {\n log(`Adding or Updating repo management by Team ${this.__teamId} for repo ${owner}/${repo}`);\n return this._request204or404(`/teams/${this.__teamId}/repos/${owner}/${repo}`, options, cb, 'PUT');\n }\n\n /**\n * Remove repo management status for team\n * @see https://developer.github.com/v3/orgs/teams/#remove-team-repository\n * @param {string} owner - Organization name\n * @param {string} repo - Repo name\n * @param {Requestable.callback} [cb] - will receive the membership status of added user\n * @return {Promise} - the promise for the http request\n */\n unmanageRepo(owner, repo, cb) {\n log(`Remove repo management by Team ${this.__teamId} for repo ${owner}/${repo}`);\n return this._request204or404(`/teams/${this.__teamId}/repos/${owner}/${repo}`, undefined, cb, 'DELETE');\n }\n\n /**\n * Delete Team\n * @see https://developer.github.com/v3/orgs/teams/#delete-team\n * @param {Requestable.callback} [cb] - will receive the list of repositories\n * @return {Promise} - the promise for the http request\n */\n deleteTeam(cb) {\n log(`Deleting Team ${this.__teamId}`);\n return this._request204or404(`/teams/${this.__teamId}`, undefined, cb, 'DELETE');\n }\n}\n\nmodule.exports = Team;\n","/**\n * @file\n * @copyright 2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n * Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\nimport debug from 'debug';\nconst log = debug('github:user');\n\n/**\n * A User allows scoping of API requests to a particular Github user.\n */\nclass User extends Requestable {\n /**\n * Create a User.\n * @param {string} [username] - the user to use for user-scoped queries\n * @param {Requestable.auth} [auth] - information required to authenticate to Github\n * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n */\n constructor(username, auth, apiBase) {\n super(auth, apiBase);\n this.__user = username;\n }\n\n /**\n * Get the url for the request. (dependent on if we're requesting for the authenticated user or not)\n * @private\n * @param {string} endpoint - the endpoint being requested\n * @return {string} - the resolved endpoint\n */\n __getScopedUrl(endpoint) {\n if (this.__user) {\n return endpoint ?\n `/users/${this.__user}/${endpoint}` :\n `/users/${this.__user}`\n ;\n\n } else { // eslint-disable-line\n switch (endpoint) {\n case '':\n return '/user';\n\n case 'notifications':\n case 'gists':\n return `/${endpoint}`;\n\n default:\n return `/user/${endpoint}`;\n }\n }\n }\n\n /**\n * List the user's repositories\n * @see https://developer.github.com/v3/repos/#list-user-repositories\n * @param {Object} [options={}] - any options to refine the search\n * @param {Requestable.callback} [cb] - will receive the list of repositories\n * @return {Promise} - the promise for the http request\n */\n listRepos(options, cb) {\n if (typeof options === 'function') {\n cb = options;\n options = {};\n }\n\n options = this._getOptionsWithDefaults(options);\n\n log(`Fetching repositories with options: ${JSON.stringify(options)}`);\n return this._requestAllPages(this.__getScopedUrl('repos'), options, cb);\n }\n\n /**\n * List the orgs that the user belongs to\n * @see https://developer.github.com/v3/orgs/#list-user-organizations\n * @param {Requestable.callback} [cb] - will receive the list of organizations\n * @return {Promise} - the promise for the http request\n */\n listOrgs(cb) {\n return this._request('GET', this.__getScopedUrl('orgs'), null, cb);\n }\n\n /**\n * List the user's gists\n * @see https://developer.github.com/v3/gists/#list-a-users-gists\n * @param {Requestable.callback} [cb] - will receive the list of gists\n * @return {Promise} - the promise for the http request\n */\n listGists(cb) {\n return this._request('GET', this.__getScopedUrl('gists'), null, cb);\n }\n\n /**\n * List the user's starred gists\n * @see https://developer.github.com/v3/gists/#list-starred-gists\n * @param {Requestable.callback} [cb] - will receive the list of gists\n * @return {Promise} - the promise for the http request\n */\n listStarredGists(cb) {\n return this._request('GET', this.__getScopedUrl('gists/starred'), null, cb);\n }\n\n /**\n * List the user's notifications\n * @see https://developer.github.com/v3/activity/notifications/#list-your-notifications\n * @param {Object} [options={}] - any options to refine the search\n * @param {Requestable.callback} [cb] - will receive the list of repositories\n * @return {Promise} - the promise for the http request\n */\n listNotifications(options, cb) {\n options = options || {};\n if (typeof options === 'function') {\n cb = options;\n options = {};\n }\n\n options.since = this._dateToISO(options.since);\n options.before = this._dateToISO(options.before);\n\n return this._request('GET', this.__getScopedUrl('notifications'), options, cb);\n }\n\n /**\n * Show the user's profile\n * @see https://developer.github.com/v3/users/#get-a-single-user\n * @param {Requestable.callback} [cb] - will receive the user's information\n * @return {Promise} - the promise for the http request\n */\n getProfile(cb) {\n return this._request('GET', this.__getScopedUrl(''), null, cb);\n }\n\n /**\n * Gets the list of starred repositories for the user\n * @see https://developer.github.com/v3/activity/starring/#list-repositories-being-starred\n * @param {Requestable.callback} [cb] - will receive the list of starred repositories\n * @return {Promise} - the promise for the http request\n */\n listStarredRepos(cb) {\n let requestOptions = this._getOptionsWithDefaults();\n return this._requestAllPages(this.__getScopedUrl('starred'), requestOptions, cb);\n }\n\n /**\n * List email addresses for a user\n * @see https://developer.github.com/v3/users/emails/#list-email-addresses-for-a-user\n * @param {Requestable.callback} [cb] - will receive the list of emails\n * @return {Promise} - the promise for the http request\n */\n getEmails(cb) {\n return this._request('GET', '/user/emails', null, cb);\n }\n\n /**\n * Have the authenticated user follow this user\n * @see https://developer.github.com/v3/users/followers/#follow-a-user\n * @param {string} username - the user to follow\n * @param {Requestable.callback} [cb] - will receive true if the request succeeds\n * @return {Promise} - the promise for the http request\n */\n follow(username, cb) {\n return this._request('PUT', `/user/following/${this.__user}`, null, cb);\n }\n\n /**\n * Have the currently authenticated user unfollow this user\n * @see https://developer.github.com/v3/users/followers/#follow-a-user\n * @param {string} username - the user to unfollow\n * @param {Requestable.callback} [cb] - receives true if the request succeeds\n * @return {Promise} - the promise for the http request\n */\n unfollow(username, cb) {\n return this._request('DELETE', `/user/following/${this.__user}`, null, cb);\n }\n\n /**\n * Create a new repository for the currently authenticated user\n * @see https://developer.github.com/v3/repos/#create\n * @param {object} options - the repository definition\n * @param {Requestable.callback} [cb] - will receive the API response\n * @return {Promise} - the promise for the http request\n */\n createRepo(options, cb) {\n return this._request('POST', '/user/repos', options, cb);\n }\n}\n\nmodule.exports = User;\n"],"preExistingComment":"//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["node_modules/browser-pack/_prelude.js","lib/Gist.js","lib/GitHub.js","lib/Issue.js","lib/Markdown.js","lib/Organization.js","lib/Project.js","lib/RateLimit.js","lib/Repository.js","lib/Requestable.js","lib/Search.js","lib/Team.js","lib/User.js"],"names":[],"mappings":"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","file":"generated.js","sourceRoot":"","sourcesContent":["(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require==\"function\"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error(\"Cannot find module '\"+o+\"'\");throw f.code=\"MODULE_NOT_FOUND\",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require==\"function\"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})","/**\n * @file\n * @copyright  2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license    Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n *             Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\n\n/**\n * A Gist can retrieve and modify gists.\n */\nclass Gist extends Requestable {\n   /**\n    * Create a Gist.\n    * @param {string} id - the id of the gist (not required when creating a gist)\n    * @param {Requestable.auth} [auth] - information required to authenticate to Github\n    * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n    */\n   constructor(id, auth, apiBase) {\n      super(auth, apiBase);\n      this.__id = id;\n   }\n\n   /**\n    * Fetch a gist.\n    * @see https://developer.github.com/v3/gists/#get-a-single-gist\n    * @param {Requestable.callback} [cb] - will receive the gist\n    * @return {Promise} - the Promise for the http request\n    */\n   read(cb) {\n      return this._request('GET', `/gists/${this.__id}`, null, cb);\n   }\n\n   /**\n    * Create a new gist.\n    * @see https://developer.github.com/v3/gists/#create-a-gist\n    * @param {Object} gist - the data for the new gist\n    * @param {Requestable.callback} [cb] - will receive the new gist upon creation\n    * @return {Promise} - the Promise for the http request\n    */\n   create(gist, cb) {\n      return this._request('POST', '/gists', gist, cb)\n         .then((response) => {\n            this.__id = response.data.id;\n            return response;\n         });\n   }\n\n   /**\n    * Delete a gist.\n    * @see https://developer.github.com/v3/gists/#delete-a-gist\n    * @param {Requestable.callback} [cb] - will receive true if the request succeeds\n    * @return {Promise} - the Promise for the http request\n    */\n   delete(cb) {\n      return this._request('DELETE', `/gists/${this.__id}`, null, cb);\n   }\n\n   /**\n    * Fork a gist.\n    * @see https://developer.github.com/v3/gists/#fork-a-gist\n    * @param {Requestable.callback} [cb] - the function that will receive the gist\n    * @return {Promise} - the Promise for the http request\n    */\n   fork(cb) {\n      return this._request('POST', `/gists/${this.__id}/forks`, null, cb);\n   }\n\n   /**\n    * Update a gist.\n    * @see https://developer.github.com/v3/gists/#edit-a-gist\n    * @param {Object} gist - the new data for the gist\n    * @param {Requestable.callback} [cb] - the function that receives the API result\n    * @return {Promise} - the Promise for the http request\n    */\n   update(gist, cb) {\n      return this._request('PATCH', `/gists/${this.__id}`, gist, cb);\n   }\n\n   /**\n    * Star a gist.\n    * @see https://developer.github.com/v3/gists/#star-a-gist\n    * @param {Requestable.callback} [cb] - will receive true if the request is successful\n    * @return {Promise} - the Promise for the http request\n    */\n   star(cb) {\n      return this._request('PUT', `/gists/${this.__id}/star`, null, cb);\n   }\n\n   /**\n    * Unstar a gist.\n    * @see https://developer.github.com/v3/gists/#unstar-a-gist\n    * @param {Requestable.callback} [cb] - will receive true if the request is successful\n    * @return {Promise} - the Promise for the http request\n    */\n   unstar(cb) {\n      return this._request('DELETE', `/gists/${this.__id}/star`, null, cb);\n   }\n\n   /**\n    * Check if a gist is starred by the user.\n    * @see https://developer.github.com/v3/gists/#check-if-a-gist-is-starred\n    * @param {Requestable.callback} [cb] - will receive true if the gist is starred and false if the gist is not starred\n    * @return {Promise} - the Promise for the http request\n    */\n   isStarred(cb) {\n      return this._request204or404(`/gists/${this.__id}/star`, null, cb);\n   }\n\n   /**\n    * List the gist's commits\n    * @see https://developer.github.com/v3/gists/#list-gist-commits\n    * @param {Requestable.callback} [cb] - will receive the array of commits\n    * @return {Promise} - the Promise for the http request\n    */\n   listCommits(cb) {\n      return this._requestAllPages(`/gists/${this.__id}/commits`, null, cb);\n   }\n\n   /**\n    * Fetch one of the gist's revision.\n    * @see https://developer.github.com/v3/gists/#get-a-specific-revision-of-a-gist\n    * @param {string} revision - the id of the revision\n    * @param {Requestable.callback} [cb] - will receive the revision\n    * @return {Promise} - the Promise for the http request\n    */\n   getRevision(revision, cb) {\n      return this._request('GET', `/gists/${this.__id}/${revision}`, null, cb);\n   }\n\n   /**\n    * List the gist's comments\n    * @see https://developer.github.com/v3/gists/comments/#list-comments-on-a-gist\n    * @param {Requestable.callback} [cb] - will receive the array of comments\n    * @return {Promise} - the promise for the http request\n    */\n   listComments(cb) {\n      return this._requestAllPages(`/gists/${this.__id}/comments`, null, cb);\n   }\n\n   /**\n    * Fetch one of the gist's comments\n    * @see https://developer.github.com/v3/gists/comments/#get-a-single-comment\n    * @param {number} comment - the id of the comment\n    * @param {Requestable.callback} [cb] - will receive the comment\n    * @return {Promise} - the Promise for the http request\n    */\n   getComment(comment, cb) {\n      return this._request('GET', `/gists/${this.__id}/comments/${comment}`, null, cb);\n   }\n\n   /**\n    * Comment on a gist\n    * @see https://developer.github.com/v3/gists/comments/#create-a-comment\n    * @param {string} comment - the comment to add\n    * @param {Requestable.callback} [cb] - the function that receives the API result\n    * @return {Promise} - the Promise for the http request\n    */\n   createComment(comment, cb) {\n      return this._request('POST', `/gists/${this.__id}/comments`, {body: comment}, cb);\n   }\n\n   /**\n    * Edit a comment on the gist\n    * @see https://developer.github.com/v3/gists/comments/#edit-a-comment\n    * @param {number} comment - the id of the comment\n    * @param {string} body - the new comment\n    * @param {Requestable.callback} [cb] - will receive the modified comment\n    * @return {Promise} - the promise for the http request\n    */\n   editComment(comment, body, cb) {\n      return this._request('PATCH', `/gists/${this.__id}/comments/${comment}`, {body: body}, cb);\n   }\n\n   /**\n    * Delete a comment on the gist.\n    * @see https://developer.github.com/v3/gists/comments/#delete-a-comment\n    * @param {number} comment - the id of the comment\n    * @param {Requestable.callback} [cb] - will receive true if the request succeeds\n    * @return {Promise} - the Promise for the http request\n    */\n   deleteComment(comment, cb) {\n      return this._request('DELETE', `/gists/${this.__id}/comments/${comment}`, null, cb);\n   }\n}\n\nmodule.exports = Gist;\n","/**\n * @file\n * @copyright  2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license    Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n *             Github.js is freely distributable.\n */\n/* eslint valid-jsdoc: [\"error\", {\"requireReturnDescription\": false}] */\n\nimport Gist from './Gist';\nimport User from './User';\nimport Issue from './Issue';\nimport Search from './Search';\nimport RateLimit from './RateLimit';\nimport Repository from './Repository';\nimport Organization from './Organization';\nimport Team from './Team';\nimport Markdown from './Markdown';\nimport Project from './Project';\n\n/**\n * GitHub encapsulates the functionality to create various API wrapper objects.\n */\nclass GitHub {\n   /**\n    * Create a new GitHub.\n    * @param {Requestable.auth} [auth] - the credentials to authenticate to Github. If auth is\n    *                                  not provided requests will be made unauthenticated\n    * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n    */\n   constructor(auth, apiBase = 'https://api.github.com') {\n      this.__apiBase = apiBase;\n      this.__auth = auth || {};\n   }\n\n   /**\n    * Create a new Gist wrapper\n    * @param {number} [id] - the id for the gist, leave undefined when creating a new gist\n    * @return {Gist}\n    */\n   getGist(id) {\n      return new Gist(id, this.__auth, this.__apiBase);\n   }\n\n   /**\n    * Create a new User wrapper\n    * @param {string} [user] - the name of the user to get information about\n    *                        leave undefined for the authenticated user\n    * @return {User}\n    */\n   getUser(user) {\n      return new User(user, this.__auth, this.__apiBase);\n   }\n\n   /**\n    * Create a new Organization wrapper\n    * @param {string} organization - the name of the organization\n    * @return {Organization}\n    */\n   getOrganization(organization) {\n      return new Organization(organization, this.__auth, this.__apiBase);\n   }\n\n   /**\n    * create a new Team wrapper\n    * @param {string} teamId - the name of the team\n    * @return {team}\n    */\n   getTeam(teamId) {\n      return new Team(teamId, this.__auth, this.__apiBase);\n   }\n\n   /**\n    * Create a new Repository wrapper\n    * @param {string} user - the user who owns the respository\n    * @param {string} repo - the name of the repository\n    * @return {Repository}\n    */\n   getRepo(user, repo) {\n      return new Repository(this._getFullName(user, repo), this.__auth, this.__apiBase);\n   }\n\n   /**\n    * Create a new Issue wrapper\n    * @param {string} user - the user who owns the respository\n    * @param {string} repo - the name of the repository\n    * @return {Issue}\n    */\n   getIssues(user, repo) {\n      return new Issue(this._getFullName(user, repo), this.__auth, this.__apiBase);\n   }\n\n   /**\n    * Create a new Search wrapper\n    * @param {string} query - the query to search for\n    * @return {Search}\n    */\n   search(query) {\n      return new Search(query, this.__auth, this.__apiBase);\n   }\n\n   /**\n    * Create a new RateLimit wrapper\n    * @return {RateLimit}\n    */\n   getRateLimit() {\n      return new RateLimit(this.__auth, this.__apiBase);\n   }\n\n   /**\n    * Create a new Markdown wrapper\n    * @return {Markdown}\n    */\n   getMarkdown() {\n      return new Markdown(this.__auth, this.__apiBase);\n   }\n\n   /**\n    * Create a new Project wrapper\n    * @param {string} id - the id of the project\n    * @return {Markdown}\n    */\n   getProject(id) {\n      return new Project(id, this.__auth, this.__apiBase);\n   }\n\n   /**\n    * Computes the full repository name\n    * @param {string} user - the username (or the full name)\n    * @param {string} repo - the repository name, must not be passed if `user` is the full name\n    * @return {string} the repository's full name\n    */\n   _getFullName(user, repo) {\n      let fullname = user;\n\n      if (repo) {\n         fullname = `${user}/${repo}`;\n      }\n\n      return fullname;\n   }\n}\n\nmodule.exports = GitHub;\n","/**\n * @file\n * @copyright  2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license    Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n *             Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\n\n/**\n * Issue wraps the functionality to get issues for repositories\n */\nclass Issue extends Requestable {\n   /**\n    * Create a new Issue\n    * @param {string} repository - the full name of the repository (`:user/:repo`) to get issues for\n    * @param {Requestable.auth} [auth] - information required to authenticate to Github\n    * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n    */\n   constructor(repository, auth, apiBase) {\n      super(auth, apiBase);\n      this.__repository = repository;\n   }\n\n   /**\n    * Create a new issue\n    * @see https://developer.github.com/v3/issues/#create-an-issue\n    * @param {Object} issueData - the issue to create\n    * @param {Requestable.callback} [cb] - will receive the created issue\n    * @return {Promise} - the promise for the http request\n    */\n   createIssue(issueData, cb) {\n      return this._request('POST', `/repos/${this.__repository}/issues`, issueData, cb);\n   }\n\n   /**\n    * List the issues for the repository\n    * @see https://developer.github.com/v3/issues/#list-issues-for-a-repository\n    * @param {Object} options - filtering options\n    * @param {Requestable.callback} [cb] - will receive the array of issues\n    * @return {Promise} - the promise for the http request\n    */\n   listIssues(options, cb) {\n      return this._requestAllPages(`/repos/${this.__repository}/issues`, options, cb);\n   }\n\n   /**\n    * List the events for an issue\n    * @see https://developer.github.com/v3/issues/events/#list-events-for-an-issue\n    * @param {number} issue - the issue to get events for\n    * @param {Requestable.callback} [cb] - will receive the list of events\n    * @return {Promise} - the promise for the http request\n    */\n   listIssueEvents(issue, cb) {\n      return this._request('GET', `/repos/${this.__repository}/issues/${issue}/events`, null, cb);\n   }\n\n   /**\n    * List comments on an issue\n    * @see https://developer.github.com/v3/issues/comments/#list-comments-on-an-issue\n    * @param {number} issue - the id of the issue to get comments from\n    * @param {Requestable.callback} [cb] - will receive the comments\n    * @return {Promise} - the promise for the http request\n    */\n   listIssueComments(issue, cb) {\n      return this._request('GET', `/repos/${this.__repository}/issues/${issue}/comments`, null, cb);\n   }\n\n   /**\n    * Get a single comment on an issue\n    * @see https://developer.github.com/v3/issues/comments/#get-a-single-comment\n    * @param {number} id - the comment id to get\n    * @param {Requestable.callback} [cb] - will receive the comment\n    * @return {Promise} - the promise for the http request\n    */\n   getIssueComment(id, cb) {\n      return this._request('GET', `/repos/${this.__repository}/issues/comments/${id}`, null, cb);\n   }\n\n   /**\n    * Comment on an issue\n    * @see https://developer.github.com/v3/issues/comments/#create-a-comment\n    * @param {number} issue - the id of the issue to comment on\n    * @param {string} comment - the comment to add\n    * @param {Requestable.callback} [cb] - will receive the created comment\n    * @return {Promise} - the promise for the http request\n    */\n   createIssueComment(issue, comment, cb) {\n      return this._request('POST', `/repos/${this.__repository}/issues/${issue}/comments`, {body: comment}, cb);\n   }\n\n   /**\n    * Edit a comment on an issue\n    * @see https://developer.github.com/v3/issues/comments/#edit-a-comment\n    * @param {number} id - the comment id to edit\n    * @param {string} comment - the comment to edit\n    * @param {Requestable.callback} [cb] - will receive the edited comment\n    * @return {Promise} - the promise for the http request\n    */\n   editIssueComment(id, comment, cb) {\n      return this._request('PATCH', `/repos/${this.__repository}/issues/comments/${id}`, {body: comment}, cb);\n   }\n\n   /**\n    * Delete a comment on an issue\n    * @see https://developer.github.com/v3/issues/comments/#delete-a-comment\n    * @param {number} id - the comment id to delete\n    * @param {Requestable.callback} [cb] - will receive true if the request is successful\n    * @return {Promise} - the promise for the http request\n    */\n   deleteIssueComment(id, cb) {\n      return this._request('DELETE', `/repos/${this.__repository}/issues/comments/${id}`, null, cb);\n   }\n\n   /**\n    * Edit an issue\n    * @see https://developer.github.com/v3/issues/#edit-an-issue\n    * @param {number} issue - the issue number to edit\n    * @param {Object} issueData - the new issue data\n    * @param {Requestable.callback} [cb] - will receive the modified issue\n    * @return {Promise} - the promise for the http request\n    */\n   editIssue(issue, issueData, cb) {\n      return this._request('PATCH', `/repos/${this.__repository}/issues/${issue}`, issueData, cb);\n   }\n\n   /**\n    * Get a particular issue\n    * @see https://developer.github.com/v3/issues/#get-a-single-issue\n    * @param {number} issue - the issue number to fetch\n    * @param {Requestable.callback} [cb] - will receive the issue\n    * @return {Promise} - the promise for the http request\n    */\n   getIssue(issue, cb) {\n      return this._request('GET', `/repos/${this.__repository}/issues/${issue}`, null, cb);\n   }\n\n   /**\n    * List the milestones for the repository\n    * @see https://developer.github.com/v3/issues/milestones/#list-milestones-for-a-repository\n    * @param {Object} options - filtering options\n    * @param {Requestable.callback} [cb] - will receive the array of milestones\n    * @return {Promise} - the promise for the http request\n    */\n   listMilestones(options, cb) {\n      return this._request('GET', `/repos/${this.__repository}/milestones`, options, cb);\n   }\n\n   /**\n    * Get a milestone\n    * @see https://developer.github.com/v3/issues/milestones/#get-a-single-milestone\n    * @param {string} milestone - the id of the milestone to fetch\n    * @param {Requestable.callback} [cb] - will receive the milestone\n    * @return {Promise} - the promise for the http request\n    */\n   getMilestone(milestone, cb) {\n      return this._request('GET', `/repos/${this.__repository}/milestones/${milestone}`, null, cb);\n   }\n\n   /**\n    * Create a new milestone\n    * @see https://developer.github.com/v3/issues/milestones/#create-a-milestone\n    * @param {Object} milestoneData - the milestone definition\n    * @param {Requestable.callback} [cb] - will receive the milestone\n    * @return {Promise} - the promise for the http request\n    */\n   createMilestone(milestoneData, cb) {\n      return this._request('POST', `/repos/${this.__repository}/milestones`, milestoneData, cb);\n   }\n\n   /**\n    * Edit a milestone\n    * @see https://developer.github.com/v3/issues/milestones/#update-a-milestone\n    * @param {string} milestone - the id of the milestone to edit\n    * @param {Object} milestoneData - the updates to make to the milestone\n    * @param {Requestable.callback} [cb] - will receive the updated milestone\n    * @return {Promise} - the promise for the http request\n    */\n   editMilestone(milestone, milestoneData, cb) {\n      return this._request('PATCH', `/repos/${this.__repository}/milestones/${milestone}`, milestoneData, cb);\n   }\n\n   /**\n    * Delete a milestone (this is distinct from closing a milestone)\n    * @see https://developer.github.com/v3/issues/milestones/#delete-a-milestone\n    * @param {string} milestone - the id of the milestone to delete\n    * @param {Requestable.callback} [cb] - will receive the status\n    * @return {Promise} - the promise for the http request\n    */\n   deleteMilestone(milestone, cb) {\n      return this._request('DELETE', `/repos/${this.__repository}/milestones/${milestone}`, null, cb);\n   }\n\n   /**\n    * Create a new label\n    * @see https://developer.github.com/v3/issues/labels/#create-a-label\n    * @param {Object} labelData - the label definition\n    * @param {Requestable.callback} [cb] - will receive the object representing the label\n    * @return {Promise} - the promise for the http request\n    */\n   createLabel(labelData, cb) {\n      return this._request('POST', `/repos/${this.__repository}/labels`, labelData, cb);\n   }\n\n  /**\n   * List the labels for the repository\n   * @see https://developer.github.com/v3/issues/labels/#list-all-labels-for-this-repository\n   * @param {Object} options - filtering options\n   * @param {Requestable.callback} [cb] - will receive the array of labels\n   * @return {Promise} - the promise for the http request\n   */\n   listLabels(options, cb) {\n      return this._request('GET', `/repos/${this.__repository}/labels`, options, cb);\n   }\n\n  /**\n   * Get a label\n   * @see https://developer.github.com/v3/issues/labels/#get-a-single-label\n   * @param {string} label - the name of the label to fetch\n   * @param {Requestable.callback} [cb] - will receive the label\n   * @return {Promise} - the promise for the http request\n   */\n   getLabel(label, cb) {\n      return this._request('GET', `/repos/${this.__repository}/labels/${label}`, null, cb);\n   }\n\n  /**\n   * Edit a label\n   * @see https://developer.github.com/v3/issues/labels/#update-a-label\n   * @param {string} label - the name of the label to edit\n   * @param {Object} labelData - the updates to make to the label\n   * @param {Requestable.callback} [cb] - will receive the updated label\n   * @return {Promise} - the promise for the http request\n   */\n   editLabel(label, labelData, cb) {\n      return this._request('PATCH', `/repos/${this.__repository}/labels/${label}`, labelData, cb);\n   }\n\n  /**\n   * Delete a label\n   * @see https://developer.github.com/v3/issues/labels/#delete-a-label\n   * @param {string} label - the name of the label to delete\n   * @param {Requestable.callback} [cb] - will receive the status\n   * @return {Promise} - the promise for the http request\n   */\n   deleteLabel(label, cb) {\n      return this._request('DELETE', `/repos/${this.__repository}/labels/${label}`, null, cb);\n   }\n}\n\nmodule.exports = Issue;\n","/**\n * @file\n * @copyright  2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license    Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n *             Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\n\n/**\n * Renders html from Markdown text\n */\nclass Markdown extends Requestable {\n   /**\n    * construct a Markdown\n    * @param {Requestable.auth} auth - the credentials to authenticate to GitHub\n    * @param {string} [apiBase] - the base Github API URL\n    * @return {Promise} - the promise for the http request\n    */\n   constructor(auth, apiBase) {\n      super(auth, apiBase);\n   }\n\n   /**\n    * Render html from Markdown text.\n    * @see https://developer.github.com/v3/markdown/#render-an-arbitrary-markdown-document\n    * @param {Object} options - conversion options\n    * @param {string} [options.text] - the markdown text to convert\n    * @param {string} [options.mode=markdown] - can be either `markdown` or `gfm`\n    * @param {string} [options.context] - repository name if mode is gfm\n    * @param {Requestable.callback} [cb] - will receive the converted html\n    * @return {Promise} - the promise for the http request\n    */\n   render(options, cb) {\n      return this._request('POST', '/markdown', options, cb);\n   }\n}\n\nmodule.exports = Markdown;\n","/**\n * @file\n * @copyright  2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license    Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n *             Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\n\n/**\n * Organization encapsulates the functionality to create repositories in organizations\n */\nclass Organization extends Requestable {\n   /**\n    * Create a new Organization\n    * @param {string} organization - the name of the organization\n    * @param {Requestable.auth} [auth] - information required to authenticate to Github\n    * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n    */\n   constructor(organization, auth, apiBase) {\n      super(auth, apiBase);\n      this.__name = organization;\n   }\n\n   /**\n    * Create a repository in an organization\n    * @see https://developer.github.com/v3/repos/#create\n    * @param {Object} options - the repository definition\n    * @param {Requestable.callback} [cb] - will receive the created repository\n    * @return {Promise} - the promise for the http request\n    */\n   createRepo(options, cb) {\n      return this._request('POST', `/orgs/${this.__name}/repos`, options, cb);\n   }\n\n   /**\n    * List the repositories in an organization\n    * @see https://developer.github.com/v3/repos/#list-organization-repositories\n    * @param {Requestable.callback} [cb] - will receive the list of repositories\n    * @return {Promise} - the promise for the http request\n    */\n   getRepos(cb) {\n      let requestOptions = this._getOptionsWithDefaults({direction: 'desc'});\n\n      return this._requestAllPages(`/orgs/${this.__name}/repos`, requestOptions, cb);\n   }\n\n   /**\n    * Query if the user is a member or not\n    * @param {string} username - the user in question\n    * @param {Requestable.callback} [cb] - will receive true if the user is a member\n    * @return {Promise} - the promise for the http request\n    */\n   isMember(username, cb) {\n      return this._request204or404(`/orgs/${this.__name}/members/${username}`, null, cb);\n   }\n\n   /**\n    * List the users who are members of the company\n    * @see https://developer.github.com/v3/orgs/members/#members-list\n    * @param {object} options - filtering options\n    * @param {string} [options.filter=all] - can be either `2fa_disabled` or `all`\n    * @param {string} [options.role=all] - can be one of: `all`, `admin`, or `member`\n    * @param {Requestable.callback} [cb] - will receive the list of users\n    * @return {Promise} - the promise for the http request\n    */\n   listMembers(options, cb) {\n      return this._request('GET', `/orgs/${this.__name}/members`, options, cb);\n   }\n\n   /**\n    * List the Teams in the Organization\n    * @see https://developer.github.com/v3/orgs/teams/#list-teams\n    * @param {Requestable.callback} [cb] - will receive the list of teams\n    * @return {Promise} - the promise for the http request\n    */\n   getTeams(cb) {\n      return this._requestAllPages(`/orgs/${this.__name}/teams`, undefined, cb);\n   }\n\n   /**\n    * Create a team\n    * @see https://developer.github.com/v3/orgs/teams/#create-team\n    * @param {object} options - Team creation parameters\n    * @param {string} options.name - The name of the team\n    * @param {string} [options.description] - Team description\n    * @param {string} [options.repo_names] - Repos to add the team to\n    * @param {string} [options.privacy=secret] - The level of privacy the team should have. Can be either one\n    * of: `secret`, or `closed`\n    * @param {Requestable.callback} [cb] - will receive the created team\n    * @return {Promise} - the promise for the http request\n    */\n   createTeam(options, cb) {\n      return this._request('POST', `/orgs/${this.__name}/teams`, options, cb);\n   }\n\n   /**\n    * Get information about all projects\n    * @see https://developer.github.com/v3/projects/#list-organization-projects\n    * @param {Requestable.callback} [cb] - will receive the list of projects\n    * @return {Promise} - the promise for the http request\n    */\n   listProjects(cb) {\n      return this._requestAllPages(`/orgs/${this.__name}/projects`, {AcceptHeader: 'inertia-preview'}, cb);\n   }\n\n   /**\n    * Create a new project\n    * @see https://developer.github.com/v3/repos/projects/#create-a-project\n    * @param {Object} options - the description of the project\n    * @param {Requestable.callback} cb - will receive the newly created project\n    * @return {Promise} - the promise for the http request\n    */\n   createProject(options, cb) {\n      options = options || {};\n      options.AcceptHeader = 'inertia-preview';\n      return this._request('POST', `/orgs/${this.__name}/projects`, options, cb);\n   }\n}\n\nmodule.exports = Organization;\n","/**\n * @file\n * @copyright  2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license    Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n *             Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\n\n/**\n * Project encapsulates the functionality to create, query, and modify cards and columns.\n */\nclass Project extends Requestable {\n   /**\n    * Create a Project.\n    * @param {string} id - the id of the project\n    * @param {Requestable.auth} [auth] - information required to authenticate to Github\n    * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n    */\n   constructor(id, auth, apiBase) {\n      super(auth, apiBase, 'inertia-preview');\n      this.__id = id;\n   }\n\n   /**\n    * Get information about a project\n    * @see https://developer.github.com/v3/projects/#get-a-project\n    * @param {Requestable.callback} cb - will receive the project information\n    * @return {Promise} - the promise for the http request\n    */\n   getProject(cb) {\n      return this._request('GET', `/projects/${this.__id}`, null, cb);\n   }\n\n   /**\n    * Edit a project\n    * @see https://developer.github.com/v3/projects/#update-a-project\n    * @param {Object} options - the description of the project\n    * @param {Requestable.callback} cb - will receive the modified project\n    * @return {Promise} - the promise for the http request\n    */\n   updateProject(options, cb) {\n      return this._request('PATCH', `/projects/${this.__id}`, options, cb);\n   }\n\n   /**\n    * Delete a project\n    * @see https://developer.github.com/v3/projects/#delete-a-project\n    * @param {Requestable.callback} cb - will receive true if the operation is successful\n    * @return {Promise} - the promise for the http request\n    */\n   deleteProject(cb) {\n      return this._request('DELETE', `/projects/${this.__id}`, null, cb);\n   }\n\n   /**\n    * Get information about all columns of a project\n    * @see https://developer.github.com/v3/projects/columns/#list-project-columns\n    * @param {Requestable.callback} [cb] - will receive the list of columns\n    * @return {Promise} - the promise for the http request\n    */\n   listProjectColumns(cb) {\n      return this._requestAllPages(`/projects/${this.__id}/columns`, null, cb);\n   }\n\n   /**\n    * Get information about a column\n    * @see https://developer.github.com/v3/projects/columns/#get-a-project-column\n    * @param {string} colId - the id of the column\n    * @param {Requestable.callback} cb - will receive the column information\n    * @return {Promise} - the promise for the http request\n    */\n   getProjectColumn(colId, cb) {\n      return this._request('GET', `/projects/columns/${colId}`, null, cb);\n   }\n\n   /**\n    * Create a new column\n    * @see https://developer.github.com/v3/projects/columns/#create-a-project-column\n    * @param {Object} options - the description of the column\n    * @param {Requestable.callback} cb - will receive the newly created column\n    * @return {Promise} - the promise for the http request\n    */\n   createProjectColumn(options, cb) {\n      return this._request('POST', `/projects/${this.__id}/columns`, options, cb);\n   }\n\n   /**\n    * Edit a column\n    * @see https://developer.github.com/v3/projects/columns/#update-a-project-column\n    * @param {string} colId - the column id\n    * @param {Object} options - the description of the column\n    * @param {Requestable.callback} cb - will receive the modified column\n    * @return {Promise} - the promise for the http request\n    */\n   updateProjectColumn(colId, options, cb) {\n      return this._request('PATCH', `/projects/columns/${colId}`, options, cb);\n   }\n\n   /**\n    * Delete a column\n    * @see https://developer.github.com/v3/projects/columns/#delete-a-project-column\n    * @param {string} colId - the column to be deleted\n    * @param {Requestable.callback} cb - will receive true if the operation is successful\n    * @return {Promise} - the promise for the http request\n    */\n   deleteProjectColumn(colId, cb) {\n      return this._request('DELETE', `/projects/columns/${colId}`, null, cb);\n   }\n\n   /**\n    * Move a column\n    * @see https://developer.github.com/v3/projects/columns/#move-a-project-column\n    * @param {string} colId - the column to be moved\n    * @param {string} position - can be one of first, last, or after:<column-id>,\n    * where <column-id> is the id value of a column in the same project.\n    * @param {Requestable.callback} cb - will receive true if the operation is successful\n    * @return {Promise} - the promise for the http request\n    */\n   moveProjectColumn(colId, position, cb) {\n      return this._request(\n         'POST',\n         `/projects/columns/${colId}/moves`,\n         {position: position},\n         cb\n      );\n   }\n\n  /**\n   * Get information about all cards of a project\n   * @see https://developer.github.com/v3/projects/cards/#list-project-cards\n   * @param {Requestable.callback} [cb] - will receive the list of cards\n   * @return {Promise} - the promise for the http request\n   */\n   listProjectCards(cb) {\n      return this.listProjectColumns()\n        .then(({data}) => {\n           return Promise.all(data.map((column) => {\n              return this._requestAllPages(`/projects/columns/${column.id}/cards`, null);\n           }));\n        }).then((cardsInColumns) => {\n           const cards = cardsInColumns.reduce((prev, {data}) => {\n              prev.push(...data);\n              return prev;\n           }, []);\n           if (cb) {\n              cb(null, cards);\n           }\n           return cards;\n        }).catch((err) => {\n           if (cb) {\n              cb(err);\n              return;\n           }\n           throw err;\n        });\n   }\n\n   /**\n   * Get information about all cards of a column\n   * @see https://developer.github.com/v3/projects/cards/#list-project-cards\n   * @param {string} colId - the id of the column\n   * @param {Requestable.callback} [cb] - will receive the list of cards\n   * @return {Promise} - the promise for the http request\n   */\n   listColumnCards(colId, cb) {\n      return this._requestAllPages(`/projects/columns/${colId}/cards`, null, cb);\n   }\n\n   /**\n   * Get information about a card\n   * @see https://developer.github.com/v3/projects/cards/#get-a-project-card\n   * @param {string} cardId - the id of the card\n   * @param {Requestable.callback} cb - will receive the card information\n   * @return {Promise} - the promise for the http request\n   */\n   getProjectCard(cardId, cb) {\n      return this._request('GET', `/projects/columns/cards/${cardId}`, null, cb);\n   }\n\n   /**\n   * Create a new card\n   * @see https://developer.github.com/v3/projects/cards/#create-a-project-card\n   * @param {string} colId - the column id\n   * @param {Object} options - the description of the card\n   * @param {Requestable.callback} cb - will receive the newly created card\n   * @return {Promise} - the promise for the http request\n   */\n   createProjectCard(colId, options, cb) {\n      return this._request('POST', `/projects/columns/${colId}/cards`, options, cb);\n   }\n\n   /**\n   * Edit a card\n   * @see https://developer.github.com/v3/projects/cards/#update-a-project-card\n   * @param {string} cardId - the card id\n   * @param {Object} options - the description of the card\n   * @param {Requestable.callback} cb - will receive the modified card\n   * @return {Promise} - the promise for the http request\n   */\n   updateProjectCard(cardId, options, cb) {\n      return this._request('PATCH', `/projects/columns/cards/${cardId}`, options, cb);\n   }\n\n   /**\n   * Delete a card\n   * @see https://developer.github.com/v3/projects/cards/#delete-a-project-card\n   * @param {string} cardId - the card to be deleted\n   * @param {Requestable.callback} cb - will receive true if the operation is successful\n   * @return {Promise} - the promise for the http request\n   */\n   deleteProjectCard(cardId, cb) {\n      return this._request('DELETE', `/projects/columns/cards/${cardId}`, null, cb);\n   }\n\n   /**\n   * Move a card\n   * @see https://developer.github.com/v3/projects/cards/#move-a-project-card\n   * @param {string} cardId - the card to be moved\n   * @param {string} position - can be one of top, bottom, or after:<card-id>,\n   * where <card-id> is the id value of a card in the same project.\n   * @param {string} colId - the id value of a column in the same project.\n   * @param {Requestable.callback} cb - will receive true if the operation is successful\n   * @return {Promise} - the promise for the http request\n   */\n   moveProjectCard(cardId, position, colId, cb) {\n      return this._request(\n         'POST',\n         `/projects/columns/cards/${cardId}/moves`,\n         {position: position, column_id: colId}, // eslint-disable-line camelcase\n         cb\n      );\n   }\n}\n\nmodule.exports = Project;\n","/**\n * @file\n * @copyright  2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license    Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n *             Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\n\n/**\n * RateLimit allows users to query their rate-limit status\n */\nclass RateLimit extends Requestable {\n   /**\n    * construct a RateLimit\n    * @param {Requestable.auth} auth - the credentials to authenticate to GitHub\n    * @param {string} [apiBase] - the base Github API URL\n    * @return {Promise} - the promise for the http request\n    */\n   constructor(auth, apiBase) {\n      super(auth, apiBase);\n   }\n\n   /**\n    * Query the current rate limit\n    * @see https://developer.github.com/v3/rate_limit/\n    * @param {Requestable.callback} [cb] - will receive the rate-limit data\n    * @return {Promise} - the promise for the http request\n    */\n   getRateLimit(cb) {\n      return this._request('GET', '/rate_limit', null, cb);\n   }\n}\n\nmodule.exports = RateLimit;\n","/**\n * @file\n * @copyright  2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license    Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n *             Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\nimport Utf8 from 'utf8';\nimport {\n   Base64,\n} from 'js-base64';\nimport debug from 'debug';\nconst log = debug('github:repository');\n\n/**\n * Respository encapsulates the functionality to create, query, and modify files.\n */\nclass Repository extends Requestable {\n   /**\n    * Create a Repository.\n    * @param {string} fullname - the full name of the repository\n    * @param {Requestable.auth} [auth] - information required to authenticate to Github\n    * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n    */\n   constructor(fullname, auth, apiBase) {\n      super(auth, apiBase);\n      this.__fullname = fullname;\n      this.__currentTree = {\n         branch: null,\n         sha: null,\n      };\n   }\n\n   /**\n    * Get a reference\n    * @see https://developer.github.com/v3/git/refs/#get-a-reference\n    * @param {string} ref - the reference to get\n    * @param {Requestable.callback} [cb] - will receive the reference's refSpec or a list of refSpecs that match `ref`\n    * @return {Promise} - the promise for the http request\n    */\n   getRef(ref, cb) {\n      return this._request('GET', `/repos/${this.__fullname}/git/refs/${ref}`, null, cb);\n   }\n\n   /**\n    * Create a reference\n    * @see https://developer.github.com/v3/git/refs/#create-a-reference\n    * @param {Object} options - the object describing the ref\n    * @param {Requestable.callback} [cb] - will receive the ref\n    * @return {Promise} - the promise for the http request\n    */\n   createRef(options, cb) {\n      return this._request('POST', `/repos/${this.__fullname}/git/refs`, options, cb);\n   }\n\n   /**\n    * Delete a reference\n    * @see https://developer.github.com/v3/git/refs/#delete-a-reference\n    * @param {string} ref - the name of the ref to delte\n    * @param {Requestable.callback} [cb] - will receive true if the request is successful\n    * @return {Promise} - the promise for the http request\n    */\n   deleteRef(ref, cb) {\n      return this._request('DELETE', `/repos/${this.__fullname}/git/refs/${ref}`, null, cb);\n   }\n\n   /**\n    * Delete a repository\n    * @see https://developer.github.com/v3/repos/#delete-a-repository\n    * @param {Requestable.callback} [cb] - will receive true if the request is successful\n    * @return {Promise} - the promise for the http request\n    */\n   deleteRepo(cb) {\n      return this._request('DELETE', `/repos/${this.__fullname}`, null, cb);\n   }\n\n   /**\n    * List the tags on a repository\n    * @see https://developer.github.com/v3/repos/#list-tags\n    * @param {Requestable.callback} [cb] - will receive the tag data\n    * @return {Promise} - the promise for the http request\n    */\n   listTags(cb) {\n      return this._request('GET', `/repos/${this.__fullname}/tags`, null, cb);\n   }\n\n   /**\n    * List the open pull requests on the repository\n    * @see https://developer.github.com/v3/pulls/#list-pull-requests\n    * @param {Object} options - options to filter the search\n    * @param {Requestable.callback} [cb] - will receive the list of PRs\n    * @return {Promise} - the promise for the http request\n    */\n   listPullRequests(options, cb) {\n      options = options || {};\n      return this._request('GET', `/repos/${this.__fullname}/pulls`, options, cb);\n   }\n\n   /**\n    * Get information about a specific pull request\n    * @see https://developer.github.com/v3/pulls/#get-a-single-pull-request\n    * @param {number} number - the PR you wish to fetch\n    * @param {Requestable.callback} [cb] - will receive the PR from the API\n    * @return {Promise} - the promise for the http request\n    */\n   getPullRequest(number, cb) {\n      return this._request('GET', `/repos/${this.__fullname}/pulls/${number}`, null, cb);\n   }\n\n   /**\n    * List the files of a specific pull request\n    * @see https://developer.github.com/v3/pulls/#list-pull-requests-files\n    * @param {number|string} number - the PR you wish to fetch\n    * @param {Requestable.callback} [cb] - will receive the list of files from the API\n    * @return {Promise} - the promise for the http request\n    */\n   listPullRequestFiles(number, cb) {\n      return this._request('GET', `/repos/${this.__fullname}/pulls/${number}/files`, null, cb);\n   }\n\n   /**\n    * Compare two branches/commits/repositories\n    * @see https://developer.github.com/v3/repos/commits/#compare-two-commits\n    * @param {string} base - the base commit\n    * @param {string} head - the head commit\n    * @param {Requestable.callback} cb - will receive the comparison\n    * @return {Promise} - the promise for the http request\n    */\n   compareBranches(base, head, cb) {\n      return this._request('GET', `/repos/${this.__fullname}/compare/${base}...${head}`, null, cb);\n   }\n\n   /**\n    * List all the branches for the repository\n    * @see https://developer.github.com/v3/repos/#list-branches\n    * @param {Requestable.callback} cb - will receive the list of branches\n    * @return {Promise} - the promise for the http request\n    */\n   listBranches(cb) {\n      return this._request('GET', `/repos/${this.__fullname}/branches`, null, cb);\n   }\n\n   /**\n    * Get a raw blob from the repository\n    * @see https://developer.github.com/v3/git/blobs/#get-a-blob\n    * @param {string} sha - the sha of the blob to fetch\n    * @param {Requestable.callback} cb - will receive the blob from the API\n    * @return {Promise} - the promise for the http request\n    */\n   getBlob(sha, cb) {\n      return this._request('GET', `/repos/${this.__fullname}/git/blobs/${sha}`, null, cb, 'raw');\n   }\n\n   /**\n    * Get a single branch\n    * @see https://developer.github.com/v3/repos/branches/#get-branch\n    * @param {string} branch - the name of the branch to fetch\n    * @param {Requestable.callback} cb - will receive the branch from the API\n    * @returns {Promise} - the promise for the http request\n    */\n   getBranch(branch, cb) {\n      return this._request('GET', `/repos/${this.__fullname}/branches/${branch}`, null, cb);\n   }\n\n   /**\n    * Get a commit from the repository\n    * @see https://developer.github.com/v3/repos/commits/#get-a-single-commit\n    * @param {string} sha - the sha for the commit to fetch\n    * @param {Requestable.callback} cb - will receive the commit data\n    * @return {Promise} - the promise for the http request\n    */\n   getCommit(sha, cb) {\n      return this._request('GET', `/repos/${this.__fullname}/git/commits/${sha}`, null, cb);\n   }\n\n   /**\n    * List the commits on a repository, optionally filtering by path, author or time range\n    * @see https://developer.github.com/v3/repos/commits/#list-commits-on-a-repository\n    * @param {Object} [options] - the filtering options for commits\n    * @param {string} [options.sha] - the SHA or branch to start from\n    * @param {string} [options.path] - the path to search on\n    * @param {string} [options.author] - the commit author\n    * @param {(Date|string)} [options.since] - only commits after this date will be returned\n    * @param {(Date|string)} [options.until] - only commits before this date will be returned\n    * @param {Requestable.callback} cb - will receive the list of commits found matching the criteria\n    * @return {Promise} - the promise for the http request\n    */\n   listCommits(options, cb) {\n      options = options || {};\n\n      options.since = this._dateToISO(options.since);\n      options.until = this._dateToISO(options.until);\n\n      return this._request('GET', `/repos/${this.__fullname}/commits`, options, cb);\n   }\n\n    /**\n     * Gets a single commit information for a repository\n     * @see https://developer.github.com/v3/repos/commits/#get-a-single-commit\n     * @param {string} ref - the reference for the commit-ish\n     * @param {Requestable.callback} cb - will receive the commit information\n     * @return {Promise} - the promise for the http request\n     */\n   getSingleCommit(ref, cb) {\n      ref = ref || '';\n      return this._request('GET', `/repos/${this.__fullname}/commits/${ref}`, null, cb);\n   }\n\n   /**\n    * Get tha sha for a particular object in the repository. This is a convenience function\n    * @see https://developer.github.com/v3/repos/contents/#get-contents\n    * @param {string} [branch] - the branch to look in, or the repository's default branch if omitted\n    * @param {string} path - the path of the file or directory\n    * @param {Requestable.callback} cb - will receive a description of the requested object, including a `SHA` property\n    * @return {Promise} - the promise for the http request\n    */\n   getSha(branch, path, cb) {\n      branch = branch ? `?ref=${branch}` : '';\n      return this._request('GET', `/repos/${this.__fullname}/contents/${path}${branch}`, null, cb);\n   }\n\n   /**\n    * List the commit statuses for a particular sha, branch, or tag\n    * @see https://developer.github.com/v3/repos/statuses/#list-statuses-for-a-specific-ref\n    * @param {string} sha - the sha, branch, or tag to get statuses for\n    * @param {Requestable.callback} cb - will receive the list of statuses\n    * @return {Promise} - the promise for the http request\n    */\n   listStatuses(sha, cb) {\n      return this._request('GET', `/repos/${this.__fullname}/commits/${sha}/statuses`, null, cb);\n   }\n\n   /**\n    * Get a description of a git tree\n    * @see https://developer.github.com/v3/git/trees/#get-a-tree\n    * @param {string} treeSHA - the SHA of the tree to fetch\n    * @param {Requestable.callback} cb - will receive the callback data\n    * @return {Promise} - the promise for the http request\n    */\n   getTree(treeSHA, cb) {\n      return this._request('GET', `/repos/${this.__fullname}/git/trees/${treeSHA}`, null, cb);\n   }\n\n   /**\n    * Create a blob\n    * @see https://developer.github.com/v3/git/blobs/#create-a-blob\n    * @param {(string|Buffer|Blob)} content - the content to add to the repository\n    * @param {Requestable.callback} cb - will receive the details of the created blob\n    * @return {Promise} - the promise for the http request\n    */\n   createBlob(content, cb) {\n      let postBody = this._getContentObject(content);\n\n      log('sending content', postBody);\n      return this._request('POST', `/repos/${this.__fullname}/git/blobs`, postBody, cb);\n   }\n\n   /**\n    * Get the object that represents the provided content\n    * @param {string|Buffer|Blob} content - the content to send to the server\n    * @return {Object} the representation of `content` for the GitHub API\n    */\n   _getContentObject(content) {\n      if (typeof content === 'string') {\n         log('contet is a string');\n         return {\n            content: Utf8.encode(content),\n            encoding: 'utf-8',\n         };\n\n      } else if (typeof Buffer !== 'undefined' && content instanceof Buffer) {\n         log('We appear to be in Node');\n         return {\n            content: content.toString('base64'),\n            encoding: 'base64',\n         };\n\n      } else if (typeof Blob !== 'undefined' && content instanceof Blob) {\n         log('We appear to be in the browser');\n         return {\n            content: Base64.encode(content),\n            encoding: 'base64',\n         };\n\n      } else { // eslint-disable-line\n         log(`Not sure what this content is: ${typeof content}, ${JSON.stringify(content)}`);\n         throw new Error('Unknown content passed to postBlob. Must be string or Buffer (node) or Blob (web)');\n      }\n   }\n\n   /**\n    * Update a tree in Git\n    * @see https://developer.github.com/v3/git/trees/#create-a-tree\n    * @param {string} baseTreeSHA - the SHA of the tree to update\n    * @param {string} path - the path for the new file\n    * @param {string} blobSHA - the SHA for the blob to put at `path`\n    * @param {Requestable.callback} cb - will receive the new tree that is created\n    * @return {Promise} - the promise for the http request\n    * @deprecated use {@link Repository#createTree} instead\n    */\n   updateTree(baseTreeSHA, path, blobSHA, cb) {\n      let newTree = {\n         base_tree: baseTreeSHA, // eslint-disable-line\n         tree: [{\n            path: path,\n            sha: blobSHA,\n            mode: '100644',\n            type: 'blob',\n         }],\n      };\n\n      return this._request('POST', `/repos/${this.__fullname}/git/trees`, newTree, cb);\n   }\n\n   /**\n    * Create a new tree in git\n    * @see https://developer.github.com/v3/git/trees/#create-a-tree\n    * @param {Object} tree - the tree to create\n    * @param {string} baseSHA - the root sha of the tree\n    * @param {Requestable.callback} cb - will receive the new tree that is created\n    * @return {Promise} - the promise for the http request\n    */\n   createTree(tree, baseSHA, cb) {\n      return this._request('POST', `/repos/${this.__fullname}/git/trees`, {\n         tree,\n         base_tree: baseSHA, // eslint-disable-line camelcase\n      }, cb);\n   }\n\n   /**\n    * Add a commit to the repository\n    * @see https://developer.github.com/v3/git/commits/#create-a-commit\n    * @param {string} parent - the SHA of the parent commit\n    * @param {string} tree - the SHA of the tree for this commit\n    * @param {string} message - the commit message\n    * @param {Requestable.callback} cb - will receive the commit that is created\n    * @return {Promise} - the promise for the http request\n    */\n   commit(parent, tree, message, cb) {\n      let data = {\n         message,\n         tree,\n         parents: [parent],\n      };\n\n      return this._request('POST', `/repos/${this.__fullname}/git/commits`, data, cb)\n         .then((response) => {\n            this.__currentTree.sha = response.data.sha; // Update latest commit\n            return response;\n         });\n   }\n\n   /**\n    * Update a ref\n    * @see https://developer.github.com/v3/git/refs/#update-a-reference\n    * @param {string} ref - the ref to update\n    * @param {string} commitSHA - the SHA to point the reference to\n    * @param {boolean} force - indicates whether to force or ensure a fast-forward update\n    * @param {Requestable.callback} cb - will receive the updated ref back\n    * @return {Promise} - the promise for the http request\n    */\n   updateHead(ref, commitSHA, force, cb) {\n      return this._request('PATCH', `/repos/${this.__fullname}/git/refs/${ref}`, {\n         sha: commitSHA,\n         force: force,\n      }, cb);\n   }\n\n   /**\n    * Update commit status\n    * @see https://developer.github.com/v3/repos/statuses/\n    * @param {string} commitSHA - the SHA of the commit that should be updated\n    * @param {object} options - Commit status parameters\n    * @param {string} options.state - The state of the status. Can be one of: pending, success, error, or failure.\n    * @param {string} [options.target_url] - The target URL to associate with this status.\n    * @param {string} [options.description] - A short description of the status.\n    * @param {string} [options.context] - A string label to differentiate this status among CI systems.\n    * @param {Requestable.callback} cb - will receive the updated commit back\n    * @return {Promise} - the promise for the http request\n    */\n   updateStatus(commitSHA, options, cb) {\n      return this._request('POST', `/repos/${this.__fullname}/statuses/${commitSHA}`, options, cb);\n   }\n\n   /**\n    * Update repository information\n    * @see https://developer.github.com/v3/repos/#edit\n    * @param {object} options - New parameters that will be set to the repository\n    * @param {string} options.name - Name of the repository\n    * @param {string} [options.description] - A short description of the repository\n    * @param {string} [options.homepage] - A URL with more information about the repository\n    * @param {boolean} [options.private] - Either true to make the repository private, or false to make it public.\n    * @param {boolean} [options.has_issues] - Either true to enable issues for this repository, false to disable them.\n    * @param {boolean} [options.has_wiki] - Either true to enable the wiki for this repository, false to disable it.\n    * @param {boolean} [options.has_downloads] - Either true to enable downloads, false to disable them.\n    * @param {string} [options.default_branch] - Updates the default branch for this repository.\n    * @param {Requestable.callback} cb - will receive the updated repository back\n    * @return {Promise} - the promise for the http request\n    */\n   updateRepository(options, cb) {\n      return this._request('PATCH', `/repos/${this.__fullname}`, options, cb);\n   }\n\n  /**\n    * Get information about the repository\n    * @see https://developer.github.com/v3/repos/#get\n    * @param {Requestable.callback} cb - will receive the information about the repository\n    * @return {Promise} - the promise for the http request\n    */\n   getDetails(cb) {\n      return this._request('GET', `/repos/${this.__fullname}`, null, cb);\n   }\n\n   /**\n    * List the contributors to the repository\n    * @see https://developer.github.com/v3/repos/#list-contributors\n    * @param {Requestable.callback} cb - will receive the list of contributors\n    * @return {Promise} - the promise for the http request\n    */\n   getContributors(cb) {\n      return this._request('GET', `/repos/${this.__fullname}/contributors`, null, cb);\n   }\n\n   /**\n    * List the contributor stats to the repository\n    * @see https://developer.github.com/v3/repos/#list-contributors\n    * @param {Requestable.callback} cb - will receive the list of contributors\n    * @return {Promise} - the promise for the http request\n    */\n   getContributorStats(cb) {\n      return this._request('GET', `/repos/${this.__fullname}/stats/contributors`, null, cb);\n   }\n\n   /**\n    * List the users who are collaborators on the repository. The currently authenticated user must have\n    * push access to use this method\n    * @see https://developer.github.com/v3/repos/collaborators/#list-collaborators\n    * @param {Requestable.callback} cb - will receive the list of collaborators\n    * @return {Promise} - the promise for the http request\n    */\n   getCollaborators(cb) {\n      return this._request('GET', `/repos/${this.__fullname}/collaborators`, null, cb);\n   }\n\n   /**\n    * Check if a user is a collaborator on the repository\n    * @see https://developer.github.com/v3/repos/collaborators/#check-if-a-user-is-a-collaborator\n    * @param {string} username - the user to check\n    * @param {Requestable.callback} cb - will receive true if the user is a collaborator and false if they are not\n    * @return {Promise} - the promise for the http request {Boolean} [description]\n    */\n   isCollaborator(username, cb) {\n      return this._request('GET', `/repos/${this.__fullname}/collaborators/${username}`, null, cb);\n   }\n\n   /**\n    * Get the contents of a repository\n    * @see https://developer.github.com/v3/repos/contents/#get-contents\n    * @param {string} ref - the ref to check\n    * @param {string} path - the path containing the content to fetch\n    * @param {boolean} raw - `true` if the results should be returned raw instead of GitHub's normalized format\n    * @param {Requestable.callback} cb - will receive the fetched data\n    * @return {Promise} - the promise for the http request\n    */\n   getContents(ref, path, raw, cb) {\n      path = path ? `${encodeURI(path)}` : '';\n      return this._request('GET', `/repos/${this.__fullname}/contents/${path}`, {\n         ref,\n      }, cb, raw);\n   }\n\n   /**\n    * Get the README of a repository\n    * @see https://developer.github.com/v3/repos/contents/#get-the-readme\n    * @param {string} ref - the ref to check\n    * @param {boolean} raw - `true` if the results should be returned raw instead of GitHub's normalized format\n    * @param {Requestable.callback} cb - will receive the fetched data\n    * @return {Promise} - the promise for the http request\n    */\n   getReadme(ref, raw, cb) {\n      return this._request('GET', `/repos/${this.__fullname}/readme`, {\n         ref,\n      }, cb, raw);\n   }\n\n   /**\n    * Fork a repository\n    * @see https://developer.github.com/v3/repos/forks/#create-a-fork\n    * @param {Requestable.callback} cb - will receive the information about the newly created fork\n    * @return {Promise} - the promise for the http request\n    */\n   fork(cb) {\n      return this._request('POST', `/repos/${this.__fullname}/forks`, null, cb);\n   }\n\n   /**\n    * List a repository's forks\n    * @see https://developer.github.com/v3/repos/forks/#list-forks\n    * @param {Requestable.callback} cb - will receive the list of repositories forked from this one\n    * @return {Promise} - the promise for the http request\n    */\n   listForks(cb) {\n      return this._request('GET', `/repos/${this.__fullname}/forks`, null, cb);\n   }\n\n   /**\n    * Create a new branch from an existing branch.\n    * @param {string} [oldBranch=master] - the name of the existing branch\n    * @param {string} newBranch - the name of the new branch\n    * @param {Requestable.callback} cb - will receive the commit data for the head of the new branch\n    * @return {Promise} - the promise for the http request\n    */\n   createBranch(oldBranch, newBranch, cb) {\n      if (typeof newBranch === 'function') {\n         cb = newBranch;\n         newBranch = oldBranch;\n         oldBranch = 'master';\n      }\n\n      return this.getRef(`heads/${oldBranch}`)\n         .then((response) => {\n            let sha = response.data.object.sha;\n            return this.createRef({\n               sha,\n               ref: `refs/heads/${newBranch}`,\n            }, cb);\n         });\n   }\n\n   /**\n    * Create a new pull request\n    * @see https://developer.github.com/v3/pulls/#create-a-pull-request\n    * @param {Object} options - the pull request description\n    * @param {Requestable.callback} cb - will receive the new pull request\n    * @return {Promise} - the promise for the http request\n    */\n   createPullRequest(options, cb) {\n      return this._request('POST', `/repos/${this.__fullname}/pulls`, options, cb);\n   }\n\n   /**\n    * Update a pull request\n    * @see https://developer.github.com/v3/pulls/#update-a-pull-request\n    * @param {number|string} number - the number of the pull request to update\n    * @param {Object} options - the pull request description\n    * @param {Requestable.callback} [cb] - will receive the pull request information\n    * @return {Promise} - the promise for the http request\n    */\n   updatePullRequest(number, options, cb) {\n      return this._request('PATCH', `/repos/${this.__fullname}/pulls/${number}`, options, cb);\n   }\n\n   /**\n    * List the hooks for the repository\n    * @see https://developer.github.com/v3/repos/hooks/#list-hooks\n    * @param {Requestable.callback} cb - will receive the list of hooks\n    * @return {Promise} - the promise for the http request\n    */\n   listHooks(cb) {\n      return this._request('GET', `/repos/${this.__fullname}/hooks`, null, cb);\n   }\n\n   /**\n    * Get a hook for the repository\n    * @see https://developer.github.com/v3/repos/hooks/#get-single-hook\n    * @param {number} id - the id of the webook\n    * @param {Requestable.callback} cb - will receive the details of the webook\n    * @return {Promise} - the promise for the http request\n    */\n   getHook(id, cb) {\n      return this._request('GET', `/repos/${this.__fullname}/hooks/${id}`, null, cb);\n   }\n\n   /**\n    * Add a new hook to the repository\n    * @see https://developer.github.com/v3/repos/hooks/#create-a-hook\n    * @param {Object} options - the configuration describing the new hook\n    * @param {Requestable.callback} cb - will receive the new webhook\n    * @return {Promise} - the promise for the http request\n    */\n   createHook(options, cb) {\n      return this._request('POST', `/repos/${this.__fullname}/hooks`, options, cb);\n   }\n\n   /**\n    * Edit an existing webhook\n    * @see https://developer.github.com/v3/repos/hooks/#edit-a-hook\n    * @param {number} id - the id of the webhook\n    * @param {Object} options - the new description of the webhook\n    * @param {Requestable.callback} cb - will receive the updated webhook\n    * @return {Promise} - the promise for the http request\n    */\n   updateHook(id, options, cb) {\n      return this._request('PATCH', `/repos/${this.__fullname}/hooks/${id}`, options, cb);\n   }\n\n   /**\n    * Delete a webhook\n    * @see https://developer.github.com/v3/repos/hooks/#delete-a-hook\n    * @param {number} id - the id of the webhook to be deleted\n    * @param {Requestable.callback} cb - will receive true if the call is successful\n    * @return {Promise} - the promise for the http request\n    */\n   deleteHook(id, cb) {\n      return this._request('DELETE', `/repos/${this.__fullname}/hooks/${id}`, null, cb);\n   }\n\n   /**\n    * List the deploy keys for the repository\n    * @see https://developer.github.com/v3/repos/keys/#list-deploy-keys\n    * @param {Requestable.callback} cb - will receive the list of deploy keys\n    * @return {Promise} - the promise for the http request\n    */\n   listKeys(cb) {\n      return this._request('GET', `/repos/${this.__fullname}/keys`, null, cb);\n   }\n\n   /**\n    * Get a deploy key for the repository\n    * @see https://developer.github.com/v3/repos/keys/#get-a-deploy-key\n    * @param {number} id - the id of the deploy key\n    * @param {Requestable.callback} cb - will receive the details of the deploy key\n    * @return {Promise} - the promise for the http request\n    */\n   getKey(id, cb) {\n      return this._request('GET', `/repos/${this.__fullname}/keys/${id}`, null, cb);\n   }\n\n   /**\n    * Add a new deploy key to the repository\n    * @see https://developer.github.com/v3/repos/keys/#add-a-new-deploy-key\n    * @param {Object} options - the configuration describing the new deploy key\n    * @param {Requestable.callback} cb - will receive the new deploy key\n    * @return {Promise} - the promise for the http request\n    */\n   createKey(options, cb) {\n      return this._request('POST', `/repos/${this.__fullname}/keys`, options, cb);\n   }\n\n   /**\n    * Delete a deploy key\n    * @see https://developer.github.com/v3/repos/keys/#remove-a-deploy-key\n    * @param {number} id - the id of the deploy key to be deleted\n    * @param {Requestable.callback} cb - will receive true if the call is successful\n    * @return {Promise} - the promise for the http request\n    */\n   deleteKey(id, cb) {\n      return this._request('DELETE', `/repos/${this.__fullname}/keys/${id}`, null, cb);\n   }\n\n   /**\n    * Delete a file from a branch\n    * @see https://developer.github.com/v3/repos/contents/#delete-a-file\n    * @param {string} branch - the branch to delete from, or the default branch if not specified\n    * @param {string} path - the path of the file to remove\n    * @param {Requestable.callback} cb - will receive the commit in which the delete occurred\n    * @return {Promise} - the promise for the http request\n    */\n   deleteFile(branch, path, cb) {\n      return this.getSha(branch, path)\n         .then((response) => {\n            const deleteCommit = {\n               message: `Delete the file at '${path}'`,\n               sha: response.data.sha,\n               branch,\n            };\n            return this._request('DELETE', `/repos/${this.__fullname}/contents/${path}`, deleteCommit, cb);\n         });\n   }\n\n   /**\n    * Change all references in a repo from oldPath to new_path\n    * @param {string} branch - the branch to carry out the reference change, or the default branch if not specified\n    * @param {string} oldPath - original path\n    * @param {string} newPath - new reference path\n    * @param {Requestable.callback} cb - will receive the commit in which the move occurred\n    * @return {Promise} - the promise for the http request\n    */\n   move(branch, oldPath, newPath, cb) {\n      let oldSha;\n      return this.getRef(`heads/${branch}`)\n         .then(({data: {object}}) => this.getTree(`${object.sha}?recursive=true`))\n         .then(({data: {tree, sha}}) => {\n            oldSha = sha;\n            let newTree = tree.map((ref) => {\n               if (ref.path === oldPath) {\n                  ref.path = newPath;\n               }\n               if (ref.type === 'tree') {\n                  delete ref.sha;\n               }\n               return ref;\n            });\n            return this.createTree(newTree);\n         })\n         .then(({data: tree}) => this.commit(oldSha, tree.sha, `Renamed '${oldPath}' to '${newPath}'`))\n         .then(({data: commit}) => this.updateHead(`heads/${branch}`, commit.sha, true, cb));\n   }\n\n   /**\n    * Write a file to the repository\n    * @see https://developer.github.com/v3/repos/contents/#update-a-file\n    * @param {string} branch - the name of the branch\n    * @param {string} path - the path for the file\n    * @param {string} content - the contents of the file\n    * @param {string} message - the commit message\n    * @param {Object} [options] - commit options\n    * @param {Object} [options.author] - the author of the commit\n    * @param {Object} [options.commiter] - the committer\n    * @param {boolean} [options.encode] - true if the content should be base64 encoded\n    * @param {Requestable.callback} cb - will receive the new commit\n    * @return {Promise} - the promise for the http request\n    */\n   writeFile(branch, path, content, message, options, cb) {\n      if (typeof options === 'function') {\n         cb = options;\n         options = {};\n      }\n      let filePath = path ? encodeURI(path) : '';\n      let shouldEncode = options.encode !== false;\n      let commit = {\n         branch,\n         message,\n         author: options.author,\n         committer: options.committer,\n         content: shouldEncode ? Base64.encode(content) : content,\n      };\n\n      return this.getSha(branch, filePath)\n         .then((response) => {\n            commit.sha = response.data.sha;\n            return this._request('PUT', `/repos/${this.__fullname}/contents/${filePath}`, commit, cb);\n         }, () => {\n            return this._request('PUT', `/repos/${this.__fullname}/contents/${filePath}`, commit, cb);\n         });\n   }\n\n   /**\n    * Check if a repository is starred by you\n    * @see https://developer.github.com/v3/activity/starring/#check-if-you-are-starring-a-repository\n    * @param {Requestable.callback} cb - will receive true if the repository is starred and false if the repository\n    *                                  is not starred\n    * @return {Promise} - the promise for the http request {Boolean} [description]\n    */\n   isStarred(cb) {\n      return this._request204or404(`/user/starred/${this.__fullname}`, null, cb);\n   }\n\n   /**\n    * Star a repository\n    * @see https://developer.github.com/v3/activity/starring/#star-a-repository\n    * @param {Requestable.callback} cb - will receive true if the repository is starred\n    * @return {Promise} - the promise for the http request\n    */\n   star(cb) {\n      return this._request('PUT', `/user/starred/${this.__fullname}`, null, cb);\n   }\n\n   /**\n    * Unstar a repository\n    * @see https://developer.github.com/v3/activity/starring/#unstar-a-repository\n    * @param {Requestable.callback} cb - will receive true if the repository is unstarred\n    * @return {Promise} - the promise for the http request\n    */\n   unstar(cb) {\n      return this._request('DELETE', `/user/starred/${this.__fullname}`, null, cb);\n   }\n\n   /**\n    * Create a new release\n    * @see https://developer.github.com/v3/repos/releases/#create-a-release\n    * @param {Object} options - the description of the release\n    * @param {Requestable.callback} cb - will receive the newly created release\n    * @return {Promise} - the promise for the http request\n    */\n   createRelease(options, cb) {\n      return this._request('POST', `/repos/${this.__fullname}/releases`, options, cb);\n   }\n\n   /**\n    * Edit a release\n    * @see https://developer.github.com/v3/repos/releases/#edit-a-release\n    * @param {string} id - the id of the release\n    * @param {Object} options - the description of the release\n    * @param {Requestable.callback} cb - will receive the modified release\n    * @return {Promise} - the promise for the http request\n    */\n   updateRelease(id, options, cb) {\n      return this._request('PATCH', `/repos/${this.__fullname}/releases/${id}`, options, cb);\n   }\n\n   /**\n    * Get information about all releases\n    * @see https://developer.github.com/v3/repos/releases/#list-releases-for-a-repository\n    * @param {Requestable.callback} cb - will receive the release information\n    * @return {Promise} - the promise for the http request\n    */\n   listReleases(cb) {\n      return this._request('GET', `/repos/${this.__fullname}/releases`, null, cb);\n   }\n\n   /**\n    * Get information about a release\n    * @see https://developer.github.com/v3/repos/releases/#get-a-single-release\n    * @param {string} id - the id of the release\n    * @param {Requestable.callback} cb - will receive the release information\n    * @return {Promise} - the promise for the http request\n    */\n   getRelease(id, cb) {\n      return this._request('GET', `/repos/${this.__fullname}/releases/${id}`, null, cb);\n   }\n\n   /**\n    * Delete a release\n    * @see https://developer.github.com/v3/repos/releases/#delete-a-release\n    * @param {string} id - the release to be deleted\n    * @param {Requestable.callback} cb - will receive true if the operation is successful\n    * @return {Promise} - the promise for the http request\n    */\n   deleteRelease(id, cb) {\n      return this._request('DELETE', `/repos/${this.__fullname}/releases/${id}`, null, cb);\n   }\n\n   /**\n    * Merge a pull request\n    * @see https://developer.github.com/v3/pulls/#merge-a-pull-request-merge-button\n    * @param {number|string} number - the number of the pull request to merge\n    * @param {Object} options - the merge options for the pull request\n    * @param {Requestable.callback} [cb] - will receive the merge information if the operation is successful\n    * @return {Promise} - the promise for the http request\n    */\n   mergePullRequest(number, options, cb) {\n      return this._request('PUT', `/repos/${this.__fullname}/pulls/${number}/merge`, options, cb);\n   }\n\n   /**\n    * Get information about all projects\n    * @see https://developer.github.com/v3/projects/#list-repository-projects\n    * @param {Requestable.callback} [cb] - will receive the list of projects\n    * @return {Promise} - the promise for the http request\n    */\n   listProjects(cb) {\n      return this._requestAllPages(`/repos/${this.__fullname}/projects`, {AcceptHeader: 'inertia-preview'}, cb);\n   }\n\n   /**\n    * Create a new project\n    * @see https://developer.github.com/v3/projects/#create-a-repository-project\n    * @param {Object} options - the description of the project\n    * @param {Requestable.callback} cb - will receive the newly created project\n    * @return {Promise} - the promise for the http request\n    */\n   createProject(options, cb) {\n      options = options || {};\n      options.AcceptHeader = 'inertia-preview';\n      return this._request('POST', `/repos/${this.__fullname}/projects`, options, cb);\n   }\n\n}\n\nmodule.exports = Repository;\n","/**\n * @file\n * @copyright  2016 Yahoo Inc.\n * @license    Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n *             Github.js is freely distributable.\n */\n\nimport axios from 'axios';\nimport debug from 'debug';\nimport {Base64} from 'js-base64';\n\nconst log = debug('github:request');\n\n/**\n * The error structure returned when a network call fails\n */\nclass ResponseError extends Error {\n   /**\n    * Construct a new ResponseError\n    * @param {string} message - an message to return instead of the the default error message\n    * @param {string} path - the requested path\n    * @param {Object} response - the object returned by Axios\n    */\n   constructor(message, path, response) {\n      super(message);\n      this.path = path;\n      this.request = response.config;\n      this.response = (response || {}).response || response;\n      this.status = response.status;\n   }\n}\n\n/**\n * Requestable wraps the logic for making http requests to the API\n */\nclass Requestable {\n   /**\n    * Either a username and password or an oauth token for Github\n    * @typedef {Object} Requestable.auth\n    * @prop {string} [username] - the Github username\n    * @prop {string} [password] - the user's password\n    * @prop {token} [token] - an OAuth token\n    */\n   /**\n    * Initialize the http internals.\n    * @param {Requestable.auth} [auth] - the credentials to authenticate to Github. If auth is\n    *                                  not provided request will be made unauthenticated\n    * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n    * @param {string} [AcceptHeader=v3] - the accept header for the requests\n    */\n   constructor(auth, apiBase, AcceptHeader) {\n      this.__apiBase = apiBase || 'https://api.github.com';\n      this.__auth = {\n         token: auth.token,\n         username: auth.username,\n         password: auth.password,\n      };\n      this.__AcceptHeader = AcceptHeader || 'v3';\n\n      if (auth.token) {\n         this.__authorizationHeader = 'token ' + auth.token;\n      } else if (auth.username && auth.password) {\n         this.__authorizationHeader = 'Basic ' + Base64.encode(auth.username + ':' + auth.password);\n      }\n   }\n\n   /**\n    * Compute the URL to use to make a request.\n    * @private\n    * @param {string} path - either a URL relative to the API base or an absolute URL\n    * @return {string} - the URL to use\n    */\n   __getURL(path) {\n      let url = path;\n\n      if (path.indexOf('//') === -1) {\n         url = this.__apiBase + path;\n      }\n\n      let newCacheBuster = 'timestamp=' + new Date().getTime();\n      return url.replace(/(timestamp=\\d+)/, newCacheBuster);\n   }\n\n   /**\n    * Compute the headers required for an API request.\n    * @private\n    * @param {boolean} raw - if the request should be treated as JSON or as a raw request\n    * @param {string} AcceptHeader - the accept header for the request\n    * @return {Object} - the headers to use in the request\n    */\n   __getRequestHeaders(raw, AcceptHeader) {\n      let headers = {\n         'Content-Type': 'application/json;charset=UTF-8',\n         'Accept': 'application/vnd.github.' + (AcceptHeader || this.__AcceptHeader),\n      };\n\n      if (raw) {\n         headers.Accept += '.raw';\n      }\n      headers.Accept += '+json';\n\n      if (this.__authorizationHeader) {\n         headers.Authorization = this.__authorizationHeader;\n      }\n\n      return headers;\n   }\n\n   /**\n    * Sets the default options for API requests\n    * @protected\n    * @param {Object} [requestOptions={}] - the current options for the request\n    * @return {Object} - the options to pass to the request\n    */\n   _getOptionsWithDefaults(requestOptions = {}) {\n      if (!(requestOptions.visibility || requestOptions.affiliation)) {\n         requestOptions.type = requestOptions.type || 'all';\n      }\n      requestOptions.sort = requestOptions.sort || 'updated';\n      requestOptions.per_page = requestOptions.per_page || '100'; // eslint-disable-line\n\n      return requestOptions;\n   }\n\n   /**\n    * if a `Date` is passed to this function it will be converted to an ISO string\n    * @param {*} date - the object to attempt to cooerce into an ISO date string\n    * @return {string} - the ISO representation of `date` or whatever was passed in if it was not a date\n    */\n   _dateToISO(date) {\n      if (date && (date instanceof Date)) {\n         date = date.toISOString();\n      }\n\n      return date;\n   }\n\n   /**\n    * A function that receives the result of the API request.\n    * @callback Requestable.callback\n    * @param {Requestable.Error} error - the error returned by the API or `null`\n    * @param {(Object|true)} result - the data returned by the API or `true` if the API returns `204 No Content`\n    * @param {Object} request - the raw {@linkcode https://github.com/mzabriskie/axios#response-schema Response}\n    */\n   /**\n    * Make a request.\n    * @param {string} method - the method for the request (GET, PUT, POST, DELETE)\n    * @param {string} path - the path for the request\n    * @param {*} [data] - the data to send to the server. For HTTP methods that don't have a body the data\n    *                   will be sent as query parameters\n    * @param {Requestable.callback} [cb] - the callback for the request\n    * @param {boolean} [raw=false] - if the request should be sent as raw. If this is a falsy value then the\n    *                              request will be made as JSON\n    * @return {Promise} - the Promise for the http request\n    */\n   _request(method, path, data, cb, raw) {\n      const url = this.__getURL(path);\n\n      const AcceptHeader = (data || {}).AcceptHeader;\n      if (AcceptHeader) {\n         delete data.AcceptHeader;\n      }\n      const headers = this.__getRequestHeaders(raw, AcceptHeader);\n\n      let queryParams = {};\n\n      const shouldUseDataAsParams = data && (typeof data === 'object') && methodHasNoBody(method);\n      if (shouldUseDataAsParams) {\n         queryParams = data;\n         data = undefined;\n      }\n\n      const config = {\n         url: url,\n         method: method,\n         headers: headers,\n         params: queryParams,\n         data: data,\n         responseType: raw ? 'text' : 'json',\n      };\n\n      log(`${config.method} to ${config.url}`);\n      const requestPromise = axios(config).catch(callbackErrorOrThrow(cb, path));\n\n      if (cb) {\n         requestPromise.then((response) => {\n            if (response.data && Object.keys(response.data).length > 0) {\n               // When data has results\n               cb(null, response.data, response);\n            } else if (config.method !== 'GET' && Object.keys(response.data).length < 1) {\n               // True when successful submit a request and receive a empty object\n               cb(null, (response.status < 300), response);\n            } else {\n               cb(null, response.data, response);\n            }\n         });\n      }\n\n      return requestPromise;\n   }\n\n   /**\n    * Make a request to an endpoint the returns 204 when true and 404 when false\n    * @param {string} path - the path to request\n    * @param {Object} data - any query parameters for the request\n    * @param {Requestable.callback} cb - the callback that will receive `true` or `false`\n    * @param {method} [method=GET] - HTTP Method to use\n    * @return {Promise} - the promise for the http request\n    */\n   _request204or404(path, data, cb, method = 'GET') {\n      return this._request(method, path, data)\n         .then(function success(response) {\n            if (cb) {\n               cb(null, true, response);\n            }\n            return true;\n         }, function failure(response) {\n            if (response.response.status === 404) {\n               if (cb) {\n                  cb(null, false, response);\n               }\n               return false;\n            }\n\n            if (cb) {\n               cb(response);\n            }\n            throw response;\n         });\n   }\n\n   /**\n    * Make a request and fetch all the available data. Github will paginate responses so for queries\n    * that might span multiple pages this method is preferred to {@link Requestable#request}\n    * @param {string} path - the path to request\n    * @param {Object} options - the query parameters to include\n    * @param {Requestable.callback} [cb] - the function to receive the data. The returned data will always be an array.\n    * @param {Object[]} results - the partial results. This argument is intended for interal use only.\n    * @return {Promise} - a promise which will resolve when all pages have been fetched\n    * @deprecated This will be folded into {@link Requestable#_request} in the 2.0 release.\n    */\n   _requestAllPages(path, options, cb, results) {\n      results = results || [];\n\n      return this._request('GET', path, options)\n         .then((response) => {\n            let thisGroup;\n            if (response.data instanceof Array) {\n               thisGroup = response.data;\n            } else if (response.data.items instanceof Array) {\n               thisGroup = response.data.items;\n            } else {\n               let message = `cannot figure out how to append ${response.data} to the result set`;\n               throw new ResponseError(message, path, response);\n            }\n            results.push(...thisGroup);\n\n            const nextUrl = getNextPage(response.headers.link);\n            if (nextUrl && typeof options.page !== 'number') {\n               log(`getting next page: ${nextUrl}`);\n               return this._requestAllPages(nextUrl, options, cb, results);\n            }\n\n            if (cb) {\n               cb(null, results, response);\n            }\n\n            response.data = results;\n            return response;\n         }).catch(callbackErrorOrThrow(cb, path));\n   }\n}\n\nmodule.exports = Requestable;\n\n// ////////////////////////// //\n//  Private helper functions  //\n// ////////////////////////// //\nconst METHODS_WITH_NO_BODY = ['GET', 'HEAD', 'DELETE'];\nfunction methodHasNoBody(method) {\n   return METHODS_WITH_NO_BODY.indexOf(method) !== -1;\n}\n\nfunction getNextPage(linksHeader = '') {\n   const links = linksHeader.split(/\\s*,\\s*/); // splits and strips the urls\n   return links.reduce(function(nextUrl, link) {\n      if (link.search(/rel=\"next\"/) !== -1) {\n         return (link.match(/<(.*)>/) || [])[1];\n      }\n\n      return nextUrl;\n   }, undefined);\n}\n\nfunction callbackErrorOrThrow(cb, path) {\n   return function handler(object) {\n      let error;\n      if (object.hasOwnProperty('config')) {\n         const {response: {status, statusText}, config: {method, url}} = object;\n         let message = (`${status} error making request ${method} ${url}: \"${statusText}\"`);\n         error = new ResponseError(message, path, object);\n         log(`${message} ${JSON.stringify(object.data)}`);\n      } else {\n         error = object;\n      }\n      if (cb) {\n         log('going to error callback');\n         cb(error);\n      } else {\n         log('throwing error');\n         throw error;\n      }\n   };\n}\n","/**\n * @file\n * @copyright  2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license    Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n *             Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\nimport debug from 'debug';\nconst log = debug('github:search');\n\n/**\n * Wrap the Search API\n */\nclass Search extends Requestable {\n   /**\n    * Create a Search\n    * @param {Object} defaults - defaults for the search\n    * @param {Requestable.auth} [auth] - information required to authenticate to Github\n    * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n    */\n   constructor(defaults, auth, apiBase) {\n      super(auth, apiBase);\n      this.__defaults = this._getOptionsWithDefaults(defaults);\n   }\n\n   /**\n    * Available search options\n    * @see https://developer.github.com/v3/search/#parameters\n    * @typedef {Object} Search.Params\n    * @param {string} q - the query to make\n    * @param {string} sort - the sort field, one of `stars`, `forks`, or `updated`.\n    *                      Default is [best match](https://developer.github.com/v3/search/#ranking-search-results)\n    * @param {string} order - the ordering, either `asc` or `desc`\n    */\n   /**\n    * Perform a search on the GitHub API\n    * @private\n    * @param {string} path - the scope of the search\n    * @param {Search.Params} [withOptions] - additional parameters for the search\n    * @param {Requestable.callback} [cb] - will receive the results of the search\n    * @return {Promise} - the promise for the http request\n    */\n   _search(path, withOptions = {}, cb = undefined) {\n      let requestOptions = {};\n      Object.keys(this.__defaults).forEach((prop) => {\n         requestOptions[prop] = this.__defaults[prop];\n      });\n      Object.keys(withOptions).forEach((prop) => {\n         requestOptions[prop] = withOptions[prop];\n      });\n\n      log(`searching ${path} with options:`, requestOptions);\n      return this._requestAllPages(`/search/${path}`, requestOptions, cb);\n   }\n\n   /**\n    * Search for repositories\n    * @see https://developer.github.com/v3/search/#search-repositories\n    * @param {Search.Params} [options] - additional parameters for the search\n    * @param {Requestable.callback} [cb] - will receive the results of the search\n    * @return {Promise} - the promise for the http request\n    */\n   forRepositories(options, cb) {\n      return this._search('repositories', options, cb);\n   }\n\n   /**\n    * Search for code\n    * @see https://developer.github.com/v3/search/#search-code\n    * @param {Search.Params} [options] - additional parameters for the search\n    * @param {Requestable.callback} [cb] - will receive the results of the search\n    * @return {Promise} - the promise for the http request\n    */\n   forCode(options, cb) {\n      return this._search('code', options, cb);\n   }\n\n   /**\n    * Search for issues\n    * @see https://developer.github.com/v3/search/#search-issues\n    * @param {Search.Params} [options] - additional parameters for the search\n    * @param {Requestable.callback} [cb] - will receive the results of the search\n    * @return {Promise} - the promise for the http request\n    */\n   forIssues(options, cb) {\n      return this._search('issues', options, cb);\n   }\n\n   /**\n    * Search for users\n    * @see https://developer.github.com/v3/search/#search-users\n    * @param {Search.Params} [options] - additional parameters for the search\n    * @param {Requestable.callback} [cb] - will receive the results of the search\n    * @return {Promise} - the promise for the http request\n    */\n   forUsers(options, cb) {\n      return this._search('users', options, cb);\n   }\n}\n\nmodule.exports = Search;\n","/**\n * @file\n * @copyright  2016 Matt Smith (Development Seed)\n * @license    Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n *             Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\nimport debug from 'debug';\nconst log = debug('github:team');\n\n/**\n * A Team allows scoping of API requests to a particular Github Organization Team.\n */\nclass Team extends Requestable {\n   /**\n    * Create a Team.\n    * @param {string} [teamId] - the id for the team\n    * @param {Requestable.auth} [auth] - information required to authenticate to Github\n    * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n    */\n   constructor(teamId, auth, apiBase) {\n      super(auth, apiBase);\n      this.__teamId = teamId;\n   }\n\n   /**\n    * Get Team information\n    * @see https://developer.github.com/v3/orgs/teams/#get-team\n    * @param {Requestable.callback} [cb] - will receive the team\n    * @return {Promise} - the promise for the http request\n    */\n   getTeam(cb) {\n      log(`Fetching Team ${this.__teamId}`);\n      return this._request('Get', `/teams/${this.__teamId}`, undefined, cb);\n   }\n\n   /**\n    * List the Team's repositories\n    * @see https://developer.github.com/v3/orgs/teams/#list-team-repos\n    * @param {Requestable.callback} [cb] - will receive the list of repositories\n    * @return {Promise} - the promise for the http request\n    */\n   listRepos(cb) {\n      log(`Fetching repositories for Team ${this.__teamId}`);\n      return this._requestAllPages(`/teams/${this.__teamId}/repos`, undefined, cb);\n   }\n\n   /**\n    * Edit Team information\n    * @see https://developer.github.com/v3/orgs/teams/#edit-team\n    * @param {object} options - Parameters for team edit\n    * @param {string} options.name - The name of the team\n    * @param {string} [options.description] - Team description\n    * @param {string} [options.repo_names] - Repos to add the team to\n    * @param {string} [options.privacy=secret] - The level of privacy the team should have. Can be either one\n    * of: `secret`, or `closed`\n    * @param {Requestable.callback} [cb] - will receive the updated team\n    * @return {Promise} - the promise for the http request\n    */\n   editTeam(options, cb) {\n      log(`Editing Team ${this.__teamId}`);\n      return this._request('PATCH', `/teams/${this.__teamId}`, options, cb);\n   }\n\n   /**\n    * List the users who are members of the Team\n    * @see https://developer.github.com/v3/orgs/teams/#list-team-members\n    * @param {object} options - Parameters for listing team users\n    * @param {string} [options.role=all] - can be one of: `all`, `maintainer`, or `member`\n    * @param {Requestable.callback} [cb] - will receive the list of users\n    * @return {Promise} - the promise for the http request\n    */\n   listMembers(options, cb) {\n      log(`Getting members of Team ${this.__teamId}`);\n      return this._requestAllPages(`/teams/${this.__teamId}/members`, options, cb);\n   }\n\n   /**\n    * Get Team membership status for a user\n    * @see https://developer.github.com/v3/orgs/teams/#get-team-membership\n    * @param {string} username - can be one of: `all`, `maintainer`, or `member`\n    * @param {Requestable.callback} [cb] - will receive the membership status of a user\n    * @return {Promise} - the promise for the http request\n    */\n   getMembership(username, cb) {\n      log(`Getting membership of user ${username} in Team ${this.__teamId}`);\n      return this._request('GET', `/teams/${this.__teamId}/memberships/${username}`, undefined, cb);\n   }\n\n   /**\n    * Add a member to the Team\n    * @see https://developer.github.com/v3/orgs/teams/#add-team-membership\n    * @param {string} username - can be one of: `all`, `maintainer`, or `member`\n    * @param {object} options - Parameters for adding a team member\n    * @param {string} [options.role=member] - The role that this user should have in the team. Can be one\n    * of: `member`, or `maintainer`\n    * @param {Requestable.callback} [cb] - will receive the membership status of added user\n    * @return {Promise} - the promise for the http request\n    */\n   addMembership(username, options, cb) {\n      log(`Adding user ${username} to Team ${this.__teamId}`);\n      return this._request('PUT', `/teams/${this.__teamId}/memberships/${username}`, options, cb);\n   }\n\n   /**\n    * Get repo management status for team\n    * @see https://developer.github.com/v3/orgs/teams/#remove-team-membership\n    * @param {string} owner - Organization name\n    * @param {string} repo - Repo name\n    * @param {Requestable.callback} [cb] - will receive the membership status of added user\n    * @return {Promise} - the promise for the http request\n    */\n   isManagedRepo(owner, repo, cb) {\n      log(`Getting repo management by Team ${this.__teamId} for repo ${owner}/${repo}`);\n      return this._request204or404(`/teams/${this.__teamId}/repos/${owner}/${repo}`, undefined, cb);\n   }\n\n   /**\n    * Add or Update repo management status for team\n    * @see https://developer.github.com/v3/orgs/teams/#add-or-update-team-repository\n    * @param {string} owner - Organization name\n    * @param {string} repo - Repo name\n    * @param {object} options - Parameters for adding or updating repo management for the team\n    * @param {string} [options.permission] - The permission to grant the team on this repository. Can be one\n    * of: `pull`, `push`, or `admin`\n    * @param {Requestable.callback} [cb] - will receive the membership status of added user\n    * @return {Promise} - the promise for the http request\n    */\n   manageRepo(owner, repo, options, cb) {\n      log(`Adding or Updating repo management by Team ${this.__teamId} for repo ${owner}/${repo}`);\n      return this._request204or404(`/teams/${this.__teamId}/repos/${owner}/${repo}`, options, cb, 'PUT');\n   }\n\n   /**\n    * Remove repo management status for team\n    * @see https://developer.github.com/v3/orgs/teams/#remove-team-repository\n    * @param {string} owner - Organization name\n    * @param {string} repo - Repo name\n    * @param {Requestable.callback} [cb] - will receive the membership status of added user\n    * @return {Promise} - the promise for the http request\n    */\n   unmanageRepo(owner, repo, cb) {\n      log(`Remove repo management by Team ${this.__teamId} for repo ${owner}/${repo}`);\n      return this._request204or404(`/teams/${this.__teamId}/repos/${owner}/${repo}`, undefined, cb, 'DELETE');\n   }\n\n   /**\n    * Delete Team\n    * @see https://developer.github.com/v3/orgs/teams/#delete-team\n    * @param {Requestable.callback} [cb] - will receive the list of repositories\n    * @return {Promise} - the promise for the http request\n    */\n   deleteTeam(cb) {\n      log(`Deleting Team ${this.__teamId}`);\n      return this._request204or404(`/teams/${this.__teamId}`, undefined, cb, 'DELETE');\n   }\n}\n\nmodule.exports = Team;\n","/**\n * @file\n * @copyright  2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license    Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n *             Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\nimport debug from 'debug';\nconst log = debug('github:user');\n\n/**\n * A User allows scoping of API requests to a particular Github user.\n */\nclass User extends Requestable {\n   /**\n    * Create a User.\n    * @param {string} [username] - the user to use for user-scoped queries\n    * @param {Requestable.auth} [auth] - information required to authenticate to Github\n    * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n    */\n   constructor(username, auth, apiBase) {\n      super(auth, apiBase);\n      this.__user = username;\n   }\n\n   /**\n    * Get the url for the request. (dependent on if we're requesting for the authenticated user or not)\n    * @private\n    * @param {string} endpoint - the endpoint being requested\n    * @return {string} - the resolved endpoint\n    */\n   __getScopedUrl(endpoint) {\n      if (this.__user) {\n         return endpoint ?\n            `/users/${this.__user}/${endpoint}` :\n            `/users/${this.__user}`\n            ;\n\n      } else { // eslint-disable-line\n         switch (endpoint) {\n            case '':\n               return '/user';\n\n            case 'notifications':\n            case 'gists':\n               return `/${endpoint}`;\n\n            default:\n               return `/user/${endpoint}`;\n         }\n      }\n   }\n\n   /**\n    * List the user's repositories\n    * @see https://developer.github.com/v3/repos/#list-user-repositories\n    * @param {Object} [options={}] - any options to refine the search\n    * @param {Requestable.callback} [cb] - will receive the list of repositories\n    * @return {Promise} - the promise for the http request\n    */\n   listRepos(options, cb) {\n      if (typeof options === 'function') {\n         cb = options;\n         options = {};\n      }\n\n      options = this._getOptionsWithDefaults(options);\n\n      log(`Fetching repositories with options: ${JSON.stringify(options)}`);\n      return this._requestAllPages(this.__getScopedUrl('repos'), options, cb);\n   }\n\n   /**\n    * List the orgs that the user belongs to\n    * @see https://developer.github.com/v3/orgs/#list-user-organizations\n    * @param {Requestable.callback} [cb] - will receive the list of organizations\n    * @return {Promise} - the promise for the http request\n    */\n   listOrgs(cb) {\n      return this._request('GET', this.__getScopedUrl('orgs'), null, cb);\n   }\n\n   /**\n    * List the user's gists\n    * @see https://developer.github.com/v3/gists/#list-a-users-gists\n    * @param {Requestable.callback} [cb] - will receive the list of gists\n    * @return {Promise} - the promise for the http request\n    */\n   listGists(cb) {\n      return this._request('GET', this.__getScopedUrl('gists'), null, cb);\n   }\n\n   /**\n    * List the user's starred gists\n    * @see https://developer.github.com/v3/gists/#list-starred-gists\n    * @param {Requestable.callback} [cb] - will receive the list of gists\n    * @return {Promise} - the promise for the http request\n    */\n   listStarredGists(cb) {\n      return this._request('GET', this.__getScopedUrl('gists/starred'), null, cb);\n   }\n\n   /**\n    * List the user's notifications\n    * @see https://developer.github.com/v3/activity/notifications/#list-your-notifications\n    * @param {Object} [options={}] - any options to refine the search\n    * @param {Requestable.callback} [cb] - will receive the list of repositories\n    * @return {Promise} - the promise for the http request\n    */\n   listNotifications(options, cb) {\n      options = options || {};\n      if (typeof options === 'function') {\n         cb = options;\n         options = {};\n      }\n\n      options.since = this._dateToISO(options.since);\n      options.before = this._dateToISO(options.before);\n\n      return this._request('GET', this.__getScopedUrl('notifications'), options, cb);\n   }\n\n   /**\n    * Show the user's profile\n    * @see https://developer.github.com/v3/users/#get-a-single-user\n    * @param {Requestable.callback} [cb] - will receive the user's information\n    * @return {Promise} - the promise for the http request\n    */\n   getProfile(cb) {\n      return this._request('GET', this.__getScopedUrl(''), null, cb);\n   }\n\n   /**\n    * Gets the list of starred repositories for the user\n    * @see https://developer.github.com/v3/activity/starring/#list-repositories-being-starred\n    * @param {Requestable.callback} [cb] - will receive the list of starred repositories\n    * @return {Promise} - the promise for the http request\n    */\n   listStarredRepos(cb) {\n      let requestOptions = this._getOptionsWithDefaults();\n      return this._requestAllPages(this.__getScopedUrl('starred'), requestOptions, cb);\n   }\n\n   /**\n    * List email addresses for a user\n    * @see https://developer.github.com/v3/users/emails/#list-email-addresses-for-a-user\n    * @param {Requestable.callback} [cb] - will receive the list of emails\n    * @return {Promise} - the promise for the http request\n    */\n   getEmails(cb) {\n      return this._request('GET', '/user/emails', null, cb);\n   }\n\n   /**\n    * Have the authenticated user follow this user\n    * @see https://developer.github.com/v3/users/followers/#follow-a-user\n    * @param {string} username - the user to follow\n    * @param {Requestable.callback} [cb] - will receive true if the request succeeds\n    * @return {Promise} - the promise for the http request\n    */\n   follow(username, cb) {\n      return this._request('PUT', `/user/following/${this.__user}`, null, cb);\n   }\n\n   /**\n    * Have the currently authenticated user unfollow this user\n    * @see https://developer.github.com/v3/users/followers/#follow-a-user\n    * @param {string} username - the user to unfollow\n    * @param {Requestable.callback} [cb] - receives true if the request succeeds\n    * @return {Promise} - the promise for the http request\n    */\n   unfollow(username, cb) {\n      return this._request('DELETE', `/user/following/${this.__user}`, null, cb);\n   }\n\n   /**\n    * Create a new repository for the currently authenticated user\n    * @see https://developer.github.com/v3/repos/#create\n    * @param {object} options - the repository definition\n    * @param {Requestable.callback} [cb] - will receive the API response\n    * @return {Promise} - the promise for the http request\n    */\n   createRepo(options, cb) {\n      return this._request('POST', '/user/repos', options, cb);\n   }\n}\n\nmodule.exports = User;\n"]}"} \ No newline at end of file diff --git a/dist/GitHub.min.js b/dist/GitHub.min.js index 5298ef6b..b30a6efb 100644 --- a/dist/GitHub.min.js +++ b/dist/GitHub.min.js @@ -1,3 +1,3 @@ !function(e){if("object"==typeof exports&&"undefined"!=typeof module)module.exports=e();else if("function"==typeof define&&define.amd)define([],e);else{var t;t="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof self?self:this,t.GitHub=e()}}(function(){return function e(t,r,n){function u(o,i){if(!r[o]){if(!t[o]){var a="function"==typeof require&&require;if(!i&&a)return a(o,!0);if(s)return s(o,!0);var l=new Error("Cannot find module '"+o+"'");throw l.code="MODULE_NOT_FOUND",l}var c=r[o]={exports:{}};t[o][0].call(c.exports,function(e){var r=t[o][1][e];return u(r?r:e)},c,c.exports,e,t,r,n)}return r[o].exports}for(var s="function"==typeof require&&require,o=0;o1&&void 0!==arguments[1]?arguments[1]:"https://api.github.com";u(this,e),this.__apiBase=r,this.__auth=t||{}}return s(e,[{key:"getGist",value:function(e){return new i.default(e,this.__auth,this.__apiBase)}},{key:"getUser",value:function(e){return new l.default(e,this.__auth,this.__apiBase)}},{key:"getOrganization",value:function(e){return new b.default(e,this.__auth,this.__apiBase)}},{key:"getTeam",value:function(e){return new k.default(e,this.__auth,this.__apiBase)}},{key:"getRepo",value:function(e,t){return new m.default(this._getFullName(e,t),this.__auth,this.__apiBase)}},{key:"getIssues",value:function(e,t){return new f.default(this._getFullName(e,t),this.__auth,this.__apiBase)}},{key:"search",value:function(e){return new h.default(e,this.__auth,this.__apiBase)}},{key:"getRateLimit",value:function(){return new y.default(this.__auth,this.__apiBase)}},{key:"getMarkdown",value:function(){return new q.default(this.__auth,this.__apiBase)}},{key:"getProject",value:function(e){return new O.default(e,this.__auth,this.__apiBase)}},{key:"_getFullName",value:function(e,t){var r=e;return t&&(r=e+"/"+t),r}}]),e}();t.exports=w},{"./Gist":1,"./Issue":3,"./Markdown":4,"./Organization":5,"./Project":6,"./RateLimit":7,"./Repository":8,"./Search":10,"./Team":11,"./User":12}],3:[function(e,t,r){"use strict";function n(e){return e&&e.__esModule?e:{default:e}}function u(e,t){if(!(e instanceof t))throw new TypeError("Cannot call a class as a function")}function s(e,t){if(!e)throw new ReferenceError("this hasn't been initialised - super() hasn't been called");return!t||"object"!=typeof t&&"function"!=typeof t?e:t}function o(e,t){if("function"!=typeof t&&null!==t)throw new TypeError("Super expression must either be null or a function, not "+typeof t);e.prototype=Object.create(t&&t.prototype,{constructor:{value:e,enumerable:!1,writable:!0,configurable:!0}}),t&&(Object.setPrototypeOf?Object.setPrototypeOf(e,t):e.__proto__=t)}var i=function(){function e(e,t){for(var r=0;r0&&void 0!==arguments[0]?arguments[0]:"",t=e.split(/\s*,\s*/);return t.reduce(function(e,t){return t.search(/rel="next"/)!==-1?(t.match(/<(.*)>/)||[])[1]:e},void 0)}function c(e,t){return function(r){var n=void 0;if(r.hasOwnProperty("config")){var u=r.response,s=u.status,o=u.statusText,i=r.config,a=i.method,l=i.url,c=s+" error making request "+a+" "+l+': "'+o+'"';n=new b(c,t,r),v(c+" "+JSON.stringify(r.data))}else n=r;if(!e)throw v("throwing error"),n;v("going to error callback"),e(n)}}var f="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(e){return typeof e}:function(e){return e&&"function"==typeof Symbol&&e.constructor===Symbol&&e!==Symbol.prototype?"symbol":typeof e},_=function(){function e(e,t){for(var r=0;r0&&void 0!==arguments[0]?arguments[0]:{};return e.visibility||e.affiliation||(e.type=e.type||"all"),e.sort=e.sort||"updated",e.per_page=e.per_page||"100",e}},{key:"_dateToISO",value:function(e){return e&&e instanceof Date&&(e=e.toISOString()),e}},{key:"_request",value:function(e,t,r,n,u){var s=this.__getURL(t),o=(r||{}).AcceptHeader;o&&delete r.AcceptHeader;var i=this.__getRequestHeaders(u,o),l={},_=r&&"object"===("undefined"==typeof r?"undefined":f(r))&&a(e);_&&(l=r,r=void 0);var h={url:s,method:e,headers:i,params:l,data:r,responseType:u?"text":"json"};v(h.method+" to "+h.url);var y=(0,p.default)(h).catch(c(n,t));return n&&y.then(function(e){e.data&&Object.keys(e.data).length>0?n(null,e.data,e):"GET"!==h.method&&Object.keys(e.data).length<1?n(null,e.status<300,e):n(null,e.data,e)}),y}},{key:"_request204or404",value:function(e,t,r){var n=arguments.length>3&&void 0!==arguments[3]?arguments[3]:"GET";return this._request(n,e,t).then(function(e){return r&&r(null,!0,e),!0},function(e){if(404===e.response.status)return r&&r(null,!1,e),!1;throw r&&r(e),e})}},{key:"_requestAllPages",value:function(e,t,r,n){var s=this;return n=n||[],this._request("GET",e,t).then(function(o){var i,a=void 0;if(o.data instanceof Array)a=o.data;else{if(!(o.data.items instanceof Array)){var c="cannot figure out how to append "+o.data+" to the result set";throw new b(c,e,o)}a=o.data.items}(i=n).push.apply(i,u(a));var f=l(o.headers.link);return f&&"number"!=typeof t.page?(v("getting next page: "+f),s._requestAllPages(f,t,r,n)):(r&&r(null,n,o),o.data=n,o)}).catch(c(r,e))}}]),e}();t.exports=g;var k=["GET","HEAD","DELETE"]},{axios:void 0,debug:void 0,"js-base64":void 0}],10:[function(e,t,r){"use strict";function n(e){return e&&e.__esModule?e:{ -default:e}}function u(e,t){if(!(e instanceof t))throw new TypeError("Cannot call a class as a function")}function s(e,t){if(!e)throw new ReferenceError("this hasn't been initialised - super() hasn't been called");return!t||"object"!=typeof t&&"function"!=typeof t?e:t}function o(e,t){if("function"!=typeof t&&null!==t)throw new TypeError("Super expression must either be null or a function, not "+typeof t);e.prototype=Object.create(t&&t.prototype,{constructor:{value:e,enumerable:!1,writable:!0,configurable:!0}}),t&&(Object.setPrototypeOf?Object.setPrototypeOf(e,t):e.__proto__=t)}var i=function(){function e(e,t){for(var r=0;r1&&void 0!==arguments[1]?arguments[1]:{},n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:void 0,u={};return Object.keys(this.__defaults).forEach(function(e){u[e]=t.__defaults[e]}),Object.keys(r).forEach(function(e){u[e]=r[e]}),_("searching "+e+" with options:",u),this._requestAllPages("/search/"+e,u,n)}},{key:"forRepositories",value:function(e,t){return this._search("repositories",e,t)}},{key:"forCode",value:function(e,t){return this._search("code",e,t)}},{key:"forIssues",value:function(e,t){return this._search("issues",e,t)}},{key:"forUsers",value:function(e,t){return this._search("users",e,t)}}]),t}(l.default);t.exports=h},{"./Requestable":9,debug:void 0}],11:[function(e,t,r){"use strict";function n(e){return e&&e.__esModule?e:{default:e}}function u(e,t){if(!(e instanceof t))throw new TypeError("Cannot call a class as a function")}function s(e,t){if(!e)throw new ReferenceError("this hasn't been initialised - super() hasn't been called");return!t||"object"!=typeof t&&"function"!=typeof t?e:t}function o(e,t){if("function"!=typeof t&&null!==t)throw new TypeError("Super expression must either be null or a function, not "+typeof t);e.prototype=Object.create(t&&t.prototype,{constructor:{value:e,enumerable:!1,writable:!0,configurable:!0}}),t&&(Object.setPrototypeOf?Object.setPrototypeOf(e,t):e.__proto__=t)}var i=function(){function e(e,t){for(var r=0;r1&&void 0!==arguments[1]?arguments[1]:{},n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:void 0,u={};return Object.keys(this.__defaults).forEach(function(e){u[e]=t.__defaults[e]}),Object.keys(r).forEach(function(e){u[e]=r[e]}),_("searching "+e+" with options:",u),this._requestAllPages("/search/"+e,u,n)}},{key:"forRepositories",value:function(e,t){return this._search("repositories",e,t)}},{key:"forCode",value:function(e,t){return this._search("code",e,t)}},{key:"forIssues",value:function(e,t){return this._search("issues",e,t)}},{key:"forUsers",value:function(e,t){return this._search("users",e,t)}}]),t}(l.default);t.exports=h},{"./Requestable":9,debug:void 0}],11:[function(e,t,r){"use strict";function n(e){return e&&e.__esModule?e:{default:e}}function u(e,t){if(!(e instanceof t))throw new TypeError("Cannot call a class as a function")}function s(e,t){if(!e)throw new ReferenceError("this hasn't been initialised - super() hasn't been called");return!t||"object"!=typeof t&&"function"!=typeof t?e:t}function o(e,t){if("function"!=typeof t&&null!==t)throw new TypeError("Super expression must either be null or a function, not "+typeof t);e.prototype=Object.create(t&&t.prototype,{constructor:{value:e,enumerable:!1,writable:!0,configurable:!0}}),t&&(Object.setPrototypeOf?Object.setPrototypeOf(e,t):e.__proto__=t)}var i=function(){function e(e,t){for(var r=0;r {\n this.__id = response.data.id;\n return response;\n });\n }\n\n /**\n * Delete a gist.\n * @see https://developer.github.com/v3/gists/#delete-a-gist\n * @param {Requestable.callback} [cb] - will receive true if the request succeeds\n * @return {Promise} - the Promise for the http request\n */\n delete(cb) {\n return this._request('DELETE', `/gists/${this.__id}`, null, cb);\n }\n\n /**\n * Fork a gist.\n * @see https://developer.github.com/v3/gists/#fork-a-gist\n * @param {Requestable.callback} [cb] - the function that will receive the gist\n * @return {Promise} - the Promise for the http request\n */\n fork(cb) {\n return this._request('POST', `/gists/${this.__id}/forks`, null, cb);\n }\n\n /**\n * Update a gist.\n * @see https://developer.github.com/v3/gists/#edit-a-gist\n * @param {Object} gist - the new data for the gist\n * @param {Requestable.callback} [cb] - the function that receives the API result\n * @return {Promise} - the Promise for the http request\n */\n update(gist, cb) {\n return this._request('PATCH', `/gists/${this.__id}`, gist, cb);\n }\n\n /**\n * Star a gist.\n * @see https://developer.github.com/v3/gists/#star-a-gist\n * @param {Requestable.callback} [cb] - will receive true if the request is successful\n * @return {Promise} - the Promise for the http request\n */\n star(cb) {\n return this._request('PUT', `/gists/${this.__id}/star`, null, cb);\n }\n\n /**\n * Unstar a gist.\n * @see https://developer.github.com/v3/gists/#unstar-a-gist\n * @param {Requestable.callback} [cb] - will receive true if the request is successful\n * @return {Promise} - the Promise for the http request\n */\n unstar(cb) {\n return this._request('DELETE', `/gists/${this.__id}/star`, null, cb);\n }\n\n /**\n * Check if a gist is starred by the user.\n * @see https://developer.github.com/v3/gists/#check-if-a-gist-is-starred\n * @param {Requestable.callback} [cb] - will receive true if the gist is starred and false if the gist is not starred\n * @return {Promise} - the Promise for the http request\n */\n isStarred(cb) {\n return this._request204or404(`/gists/${this.__id}/star`, null, cb);\n }\n\n /**\n * List the gist's commits\n * @see https://developer.github.com/v3/gists/#list-gist-commits\n * @param {Requestable.callback} [cb] - will receive the array of commits\n * @return {Promise} - the Promise for the http request\n */\n listCommits(cb) {\n return this._requestAllPages(`/gists/${this.__id}/commits`, null, cb);\n }\n\n /**\n * Fetch one of the gist's revision.\n * @see https://developer.github.com/v3/gists/#get-a-specific-revision-of-a-gist\n * @param {string} revision - the id of the revision\n * @param {Requestable.callback} [cb] - will receive the revision\n * @return {Promise} - the Promise for the http request\n */\n getRevision(revision, cb) {\n return this._request('GET', `/gists/${this.__id}/${revision}`, null, cb);\n }\n\n /**\n * List the gist's comments\n * @see https://developer.github.com/v3/gists/comments/#list-comments-on-a-gist\n * @param {Requestable.callback} [cb] - will receive the array of comments\n * @return {Promise} - the promise for the http request\n */\n listComments(cb) {\n return this._requestAllPages(`/gists/${this.__id}/comments`, null, cb);\n }\n\n /**\n * Fetch one of the gist's comments\n * @see https://developer.github.com/v3/gists/comments/#get-a-single-comment\n * @param {number} comment - the id of the comment\n * @param {Requestable.callback} [cb] - will receive the comment\n * @return {Promise} - the Promise for the http request\n */\n getComment(comment, cb) {\n return this._request('GET', `/gists/${this.__id}/comments/${comment}`, null, cb);\n }\n\n /**\n * Comment on a gist\n * @see https://developer.github.com/v3/gists/comments/#create-a-comment\n * @param {string} comment - the comment to add\n * @param {Requestable.callback} [cb] - the function that receives the API result\n * @return {Promise} - the Promise for the http request\n */\n createComment(comment, cb) {\n return this._request('POST', `/gists/${this.__id}/comments`, {body: comment}, cb);\n }\n\n /**\n * Edit a comment on the gist\n * @see https://developer.github.com/v3/gists/comments/#edit-a-comment\n * @param {number} comment - the id of the comment\n * @param {string} body - the new comment\n * @param {Requestable.callback} [cb] - will receive the modified comment\n * @return {Promise} - the promise for the http request\n */\n editComment(comment, body, cb) {\n return this._request('PATCH', `/gists/${this.__id}/comments/${comment}`, {body: body}, cb);\n }\n\n /**\n * Delete a comment on the gist.\n * @see https://developer.github.com/v3/gists/comments/#delete-a-comment\n * @param {number} comment - the id of the comment\n * @param {Requestable.callback} [cb] - will receive true if the request succeeds\n * @return {Promise} - the Promise for the http request\n */\n deleteComment(comment, cb) {\n return this._request('DELETE', `/gists/${this.__id}/comments/${comment}`, null, cb);\n }\n}\n\nmodule.exports = Gist;\n","/**\n * @file\n * @copyright 2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n * Github.js is freely distributable.\n */\n/* eslint valid-jsdoc: [\"error\", {\"requireReturnDescription\": false}] */\n\nimport Gist from './Gist';\nimport User from './User';\nimport Issue from './Issue';\nimport Search from './Search';\nimport RateLimit from './RateLimit';\nimport Repository from './Repository';\nimport Organization from './Organization';\nimport Team from './Team';\nimport Markdown from './Markdown';\nimport Project from './Project';\n\n/**\n * GitHub encapsulates the functionality to create various API wrapper objects.\n */\nclass GitHub {\n /**\n * Create a new GitHub.\n * @param {Requestable.auth} [auth] - the credentials to authenticate to Github. If auth is\n * not provided requests will be made unauthenticated\n * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n */\n constructor(auth, apiBase = 'https://api.github.com') {\n this.__apiBase = apiBase;\n this.__auth = auth || {};\n }\n\n /**\n * Create a new Gist wrapper\n * @param {number} [id] - the id for the gist, leave undefined when creating a new gist\n * @return {Gist}\n */\n getGist(id) {\n return new Gist(id, this.__auth, this.__apiBase);\n }\n\n /**\n * Create a new User wrapper\n * @param {string} [user] - the name of the user to get information about\n * leave undefined for the authenticated user\n * @return {User}\n */\n getUser(user) {\n return new User(user, this.__auth, this.__apiBase);\n }\n\n /**\n * Create a new Organization wrapper\n * @param {string} organization - the name of the organization\n * @return {Organization}\n */\n getOrganization(organization) {\n return new Organization(organization, this.__auth, this.__apiBase);\n }\n\n /**\n * create a new Team wrapper\n * @param {string} teamId - the name of the team\n * @return {team}\n */\n getTeam(teamId) {\n return new Team(teamId, this.__auth, this.__apiBase);\n }\n\n /**\n * Create a new Repository wrapper\n * @param {string} user - the user who owns the respository\n * @param {string} repo - the name of the repository\n * @return {Repository}\n */\n getRepo(user, repo) {\n return new Repository(this._getFullName(user, repo), this.__auth, this.__apiBase);\n }\n\n /**\n * Create a new Issue wrapper\n * @param {string} user - the user who owns the respository\n * @param {string} repo - the name of the repository\n * @return {Issue}\n */\n getIssues(user, repo) {\n return new Issue(this._getFullName(user, repo), this.__auth, this.__apiBase);\n }\n\n /**\n * Create a new Search wrapper\n * @param {string} query - the query to search for\n * @return {Search}\n */\n search(query) {\n return new Search(query, this.__auth, this.__apiBase);\n }\n\n /**\n * Create a new RateLimit wrapper\n * @return {RateLimit}\n */\n getRateLimit() {\n return new RateLimit(this.__auth, this.__apiBase);\n }\n\n /**\n * Create a new Markdown wrapper\n * @return {Markdown}\n */\n getMarkdown() {\n return new Markdown(this.__auth, this.__apiBase);\n }\n\n /**\n * Create a new Project wrapper\n * @param {string} id - the id of the project\n * @return {Markdown}\n */\n getProject(id) {\n return new Project(id, this.__auth, this.__apiBase);\n }\n\n /**\n * Computes the full repository name\n * @param {string} user - the username (or the full name)\n * @param {string} repo - the repository name, must not be passed if `user` is the full name\n * @return {string} the repository's full name\n */\n _getFullName(user, repo) {\n let fullname = user;\n\n if (repo) {\n fullname = `${user}/${repo}`;\n }\n\n return fullname;\n }\n}\n\nmodule.exports = GitHub;\n","/**\n * @file\n * @copyright 2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n * Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\n\n/**\n * Issue wraps the functionality to get issues for repositories\n */\nclass Issue extends Requestable {\n /**\n * Create a new Issue\n * @param {string} repository - the full name of the repository (`:user/:repo`) to get issues for\n * @param {Requestable.auth} [auth] - information required to authenticate to Github\n * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n */\n constructor(repository, auth, apiBase) {\n super(auth, apiBase);\n this.__repository = repository;\n }\n\n /**\n * Create a new issue\n * @see https://developer.github.com/v3/issues/#create-an-issue\n * @param {Object} issueData - the issue to create\n * @param {Requestable.callback} [cb] - will receive the created issue\n * @return {Promise} - the promise for the http request\n */\n createIssue(issueData, cb) {\n return this._request('POST', `/repos/${this.__repository}/issues`, issueData, cb);\n }\n\n /**\n * List the issues for the repository\n * @see https://developer.github.com/v3/issues/#list-issues-for-a-repository\n * @param {Object} options - filtering options\n * @param {Requestable.callback} [cb] - will receive the array of issues\n * @return {Promise} - the promise for the http request\n */\n listIssues(options, cb) {\n return this._requestAllPages(`/repos/${this.__repository}/issues`, options, cb);\n }\n\n /**\n * List the events for an issue\n * @see https://developer.github.com/v3/issues/events/#list-events-for-an-issue\n * @param {number} issue - the issue to get events for\n * @param {Requestable.callback} [cb] - will receive the list of events\n * @return {Promise} - the promise for the http request\n */\n listIssueEvents(issue, cb) {\n return this._request('GET', `/repos/${this.__repository}/issues/${issue}/events`, null, cb);\n }\n\n /**\n * List comments on an issue\n * @see https://developer.github.com/v3/issues/comments/#list-comments-on-an-issue\n * @param {number} issue - the id of the issue to get comments from\n * @param {Requestable.callback} [cb] - will receive the comments\n * @return {Promise} - the promise for the http request\n */\n listIssueComments(issue, cb) {\n return this._request('GET', `/repos/${this.__repository}/issues/${issue}/comments`, null, cb);\n }\n\n /**\n * Get a single comment on an issue\n * @see https://developer.github.com/v3/issues/comments/#get-a-single-comment\n * @param {number} id - the comment id to get\n * @param {Requestable.callback} [cb] - will receive the comment\n * @return {Promise} - the promise for the http request\n */\n getIssueComment(id, cb) {\n return this._request('GET', `/repos/${this.__repository}/issues/comments/${id}`, null, cb);\n }\n\n /**\n * Comment on an issue\n * @see https://developer.github.com/v3/issues/comments/#create-a-comment\n * @param {number} issue - the id of the issue to comment on\n * @param {string} comment - the comment to add\n * @param {Requestable.callback} [cb] - will receive the created comment\n * @return {Promise} - the promise for the http request\n */\n createIssueComment(issue, comment, cb) {\n return this._request('POST', `/repos/${this.__repository}/issues/${issue}/comments`, {body: comment}, cb);\n }\n\n /**\n * Edit a comment on an issue\n * @see https://developer.github.com/v3/issues/comments/#edit-a-comment\n * @param {number} id - the comment id to edit\n * @param {string} comment - the comment to edit\n * @param {Requestable.callback} [cb] - will receive the edited comment\n * @return {Promise} - the promise for the http request\n */\n editIssueComment(id, comment, cb) {\n return this._request('PATCH', `/repos/${this.__repository}/issues/comments/${id}`, {body: comment}, cb);\n }\n\n /**\n * Delete a comment on an issue\n * @see https://developer.github.com/v3/issues/comments/#delete-a-comment\n * @param {number} id - the comment id to delete\n * @param {Requestable.callback} [cb] - will receive true if the request is successful\n * @return {Promise} - the promise for the http request\n */\n deleteIssueComment(id, cb) {\n return this._request('DELETE', `/repos/${this.__repository}/issues/comments/${id}`, null, cb);\n }\n\n /**\n * Edit an issue\n * @see https://developer.github.com/v3/issues/#edit-an-issue\n * @param {number} issue - the issue number to edit\n * @param {Object} issueData - the new issue data\n * @param {Requestable.callback} [cb] - will receive the modified issue\n * @return {Promise} - the promise for the http request\n */\n editIssue(issue, issueData, cb) {\n return this._request('PATCH', `/repos/${this.__repository}/issues/${issue}`, issueData, cb);\n }\n\n /**\n * Get a particular issue\n * @see https://developer.github.com/v3/issues/#get-a-single-issue\n * @param {number} issue - the issue number to fetch\n * @param {Requestable.callback} [cb] - will receive the issue\n * @return {Promise} - the promise for the http request\n */\n getIssue(issue, cb) {\n return this._request('GET', `/repos/${this.__repository}/issues/${issue}`, null, cb);\n }\n\n /**\n * List the milestones for the repository\n * @see https://developer.github.com/v3/issues/milestones/#list-milestones-for-a-repository\n * @param {Object} options - filtering options\n * @param {Requestable.callback} [cb] - will receive the array of milestones\n * @return {Promise} - the promise for the http request\n */\n listMilestones(options, cb) {\n return this._request('GET', `/repos/${this.__repository}/milestones`, options, cb);\n }\n\n /**\n * Get a milestone\n * @see https://developer.github.com/v3/issues/milestones/#get-a-single-milestone\n * @param {string} milestone - the id of the milestone to fetch\n * @param {Requestable.callback} [cb] - will receive the milestone\n * @return {Promise} - the promise for the http request\n */\n getMilestone(milestone, cb) {\n return this._request('GET', `/repos/${this.__repository}/milestones/${milestone}`, null, cb);\n }\n\n /**\n * Create a new milestone\n * @see https://developer.github.com/v3/issues/milestones/#create-a-milestone\n * @param {Object} milestoneData - the milestone definition\n * @param {Requestable.callback} [cb] - will receive the milestone\n * @return {Promise} - the promise for the http request\n */\n createMilestone(milestoneData, cb) {\n return this._request('POST', `/repos/${this.__repository}/milestones`, milestoneData, cb);\n }\n\n /**\n * Edit a milestone\n * @see https://developer.github.com/v3/issues/milestones/#update-a-milestone\n * @param {string} milestone - the id of the milestone to edit\n * @param {Object} milestoneData - the updates to make to the milestone\n * @param {Requestable.callback} [cb] - will receive the updated milestone\n * @return {Promise} - the promise for the http request\n */\n editMilestone(milestone, milestoneData, cb) {\n return this._request('PATCH', `/repos/${this.__repository}/milestones/${milestone}`, milestoneData, cb);\n }\n\n /**\n * Delete a milestone (this is distinct from closing a milestone)\n * @see https://developer.github.com/v3/issues/milestones/#delete-a-milestone\n * @param {string} milestone - the id of the milestone to delete\n * @param {Requestable.callback} [cb] - will receive the status\n * @return {Promise} - the promise for the http request\n */\n deleteMilestone(milestone, cb) {\n return this._request('DELETE', `/repos/${this.__repository}/milestones/${milestone}`, null, cb);\n }\n\n /**\n * Create a new label\n * @see https://developer.github.com/v3/issues/labels/#create-a-label\n * @param {Object} labelData - the label definition\n * @param {Requestable.callback} [cb] - will receive the object representing the label\n * @return {Promise} - the promise for the http request\n */\n createLabel(labelData, cb) {\n return this._request('POST', `/repos/${this.__repository}/labels`, labelData, cb);\n }\n\n /**\n * List the labels for the repository\n * @see https://developer.github.com/v3/issues/labels/#list-all-labels-for-this-repository\n * @param {Object} options - filtering options\n * @param {Requestable.callback} [cb] - will receive the array of labels\n * @return {Promise} - the promise for the http request\n */\n listLabels(options, cb) {\n return this._request('GET', `/repos/${this.__repository}/labels`, options, cb);\n }\n\n /**\n * Get a label\n * @see https://developer.github.com/v3/issues/labels/#get-a-single-label\n * @param {string} label - the name of the label to fetch\n * @param {Requestable.callback} [cb] - will receive the label\n * @return {Promise} - the promise for the http request\n */\n getLabel(label, cb) {\n return this._request('GET', `/repos/${this.__repository}/labels/${label}`, null, cb);\n }\n\n /**\n * Edit a label\n * @see https://developer.github.com/v3/issues/labels/#update-a-label\n * @param {string} label - the name of the label to edit\n * @param {Object} labelData - the updates to make to the label\n * @param {Requestable.callback} [cb] - will receive the updated label\n * @return {Promise} - the promise for the http request\n */\n editLabel(label, labelData, cb) {\n return this._request('PATCH', `/repos/${this.__repository}/labels/${label}`, labelData, cb);\n }\n\n /**\n * Delete a label\n * @see https://developer.github.com/v3/issues/labels/#delete-a-label\n * @param {string} label - the name of the label to delete\n * @param {Requestable.callback} [cb] - will receive the status\n * @return {Promise} - the promise for the http request\n */\n deleteLabel(label, cb) {\n return this._request('DELETE', `/repos/${this.__repository}/labels/${label}`, null, cb);\n }\n}\n\nmodule.exports = Issue;\n","/**\n * @file\n * @copyright 2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n * Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\n\n/**\n * Renders html from Markdown text\n */\nclass Markdown extends Requestable {\n /**\n * construct a Markdown\n * @param {Requestable.auth} auth - the credentials to authenticate to GitHub\n * @param {string} [apiBase] - the base Github API URL\n * @return {Promise} - the promise for the http request\n */\n constructor(auth, apiBase) {\n super(auth, apiBase);\n }\n\n /**\n * Render html from Markdown text.\n * @see https://developer.github.com/v3/markdown/#render-an-arbitrary-markdown-document\n * @param {Object} options - conversion options\n * @param {string} [options.text] - the markdown text to convert\n * @param {string} [options.mode=markdown] - can be either `markdown` or `gfm`\n * @param {string} [options.context] - repository name if mode is gfm\n * @param {Requestable.callback} [cb] - will receive the converted html\n * @return {Promise} - the promise for the http request\n */\n render(options, cb) {\n return this._request('POST', '/markdown', options, cb);\n }\n}\n\nmodule.exports = Markdown;\n","/**\n * @file\n * @copyright 2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n * Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\n\n/**\n * Organization encapsulates the functionality to create repositories in organizations\n */\nclass Organization extends Requestable {\n /**\n * Create a new Organization\n * @param {string} organization - the name of the organization\n * @param {Requestable.auth} [auth] - information required to authenticate to Github\n * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n */\n constructor(organization, auth, apiBase) {\n super(auth, apiBase);\n this.__name = organization;\n }\n\n /**\n * Create a repository in an organization\n * @see https://developer.github.com/v3/repos/#create\n * @param {Object} options - the repository definition\n * @param {Requestable.callback} [cb] - will receive the created repository\n * @return {Promise} - the promise for the http request\n */\n createRepo(options, cb) {\n return this._request('POST', `/orgs/${this.__name}/repos`, options, cb);\n }\n\n /**\n * List the repositories in an organization\n * @see https://developer.github.com/v3/repos/#list-organization-repositories\n * @param {Requestable.callback} [cb] - will receive the list of repositories\n * @return {Promise} - the promise for the http request\n */\n getRepos(cb) {\n let requestOptions = this._getOptionsWithDefaults({direction: 'desc'});\n\n return this._requestAllPages(`/orgs/${this.__name}/repos`, requestOptions, cb);\n }\n\n /**\n * Query if the user is a member or not\n * @param {string} username - the user in question\n * @param {Requestable.callback} [cb] - will receive true if the user is a member\n * @return {Promise} - the promise for the http request\n */\n isMember(username, cb) {\n return this._request204or404(`/orgs/${this.__name}/members/${username}`, null, cb);\n }\n\n /**\n * List the users who are members of the company\n * @see https://developer.github.com/v3/orgs/members/#members-list\n * @param {object} options - filtering options\n * @param {string} [options.filter=all] - can be either `2fa_disabled` or `all`\n * @param {string} [options.role=all] - can be one of: `all`, `admin`, or `member`\n * @param {Requestable.callback} [cb] - will receive the list of users\n * @return {Promise} - the promise for the http request\n */\n listMembers(options, cb) {\n return this._request('GET', `/orgs/${this.__name}/members`, options, cb);\n }\n\n /**\n * List the Teams in the Organization\n * @see https://developer.github.com/v3/orgs/teams/#list-teams\n * @param {Requestable.callback} [cb] - will receive the list of teams\n * @return {Promise} - the promise for the http request\n */\n getTeams(cb) {\n return this._requestAllPages(`/orgs/${this.__name}/teams`, undefined, cb);\n }\n\n /**\n * Create a team\n * @see https://developer.github.com/v3/orgs/teams/#create-team\n * @param {object} options - Team creation parameters\n * @param {string} options.name - The name of the team\n * @param {string} [options.description] - Team description\n * @param {string} [options.repo_names] - Repos to add the team to\n * @param {string} [options.privacy=secret] - The level of privacy the team should have. Can be either one\n * of: `secret`, or `closed`\n * @param {Requestable.callback} [cb] - will receive the created team\n * @return {Promise} - the promise for the http request\n */\n createTeam(options, cb) {\n return this._request('POST', `/orgs/${this.__name}/teams`, options, cb);\n }\n\n /**\n * Get information about all projects\n * @see https://developer.github.com/v3/projects/#list-organization-projects\n * @param {Requestable.callback} [cb] - will receive the list of projects\n * @return {Promise} - the promise for the http request\n */\n listProjects(cb) {\n return this._requestAllPages(`/orgs/${this.__name}/projects`, {AcceptHeader: 'inertia-preview'}, cb);\n }\n\n /**\n * Create a new project\n * @see https://developer.github.com/v3/repos/projects/#create-a-project\n * @param {Object} options - the description of the project\n * @param {Requestable.callback} cb - will receive the newly created project\n * @return {Promise} - the promise for the http request\n */\n createProject(options, cb) {\n options = options || {};\n options.AcceptHeader = 'inertia-preview';\n return this._request('POST', `/orgs/${this.__name}/projects`, options, cb);\n }\n}\n\nmodule.exports = Organization;\n","/**\n * @file\n * @copyright 2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n * Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\n\n/**\n * Project encapsulates the functionality to create, query, and modify cards and columns.\n */\nclass Project extends Requestable {\n /**\n * Create a Project.\n * @param {string} id - the id of the project\n * @param {Requestable.auth} [auth] - information required to authenticate to Github\n * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n */\n constructor(id, auth, apiBase) {\n super(auth, apiBase, 'inertia-preview');\n this.__id = id;\n }\n\n /**\n * Get information about a project\n * @see https://developer.github.com/v3/projects/#get-a-project\n * @param {Requestable.callback} cb - will receive the project information\n * @return {Promise} - the promise for the http request\n */\n getProject(cb) {\n return this._request('GET', `/projects/${this.__id}`, null, cb);\n }\n\n /**\n * Edit a project\n * @see https://developer.github.com/v3/projects/#update-a-project\n * @param {Object} options - the description of the project\n * @param {Requestable.callback} cb - will receive the modified project\n * @return {Promise} - the promise for the http request\n */\n updateProject(options, cb) {\n return this._request('PATCH', `/projects/${this.__id}`, options, cb);\n }\n\n /**\n * Delete a project\n * @see https://developer.github.com/v3/projects/#delete-a-project\n * @param {Requestable.callback} cb - will receive true if the operation is successful\n * @return {Promise} - the promise for the http request\n */\n deleteProject(cb) {\n return this._request('DELETE', `/projects/${this.__id}`, null, cb);\n }\n\n /**\n * Get information about all columns of a project\n * @see https://developer.github.com/v3/projects/columns/#list-project-columns\n * @param {Requestable.callback} [cb] - will receive the list of columns\n * @return {Promise} - the promise for the http request\n */\n listProjectColumns(cb) {\n return this._requestAllPages(`/projects/${this.__id}/columns`, null, cb);\n }\n\n /**\n * Get information about a column\n * @see https://developer.github.com/v3/projects/columns/#get-a-project-column\n * @param {string} colId - the id of the column\n * @param {Requestable.callback} cb - will receive the column information\n * @return {Promise} - the promise for the http request\n */\n getProjectColumn(colId, cb) {\n return this._request('GET', `/projects/columns/${colId}`, null, cb);\n }\n\n /**\n * Create a new column\n * @see https://developer.github.com/v3/projects/columns/#create-a-project-column\n * @param {Object} options - the description of the column\n * @param {Requestable.callback} cb - will receive the newly created column\n * @return {Promise} - the promise for the http request\n */\n createProjectColumn(options, cb) {\n return this._request('POST', `/projects/${this.__id}/columns`, options, cb);\n }\n\n /**\n * Edit a column\n * @see https://developer.github.com/v3/projects/columns/#update-a-project-column\n * @param {string} colId - the column id\n * @param {Object} options - the description of the column\n * @param {Requestable.callback} cb - will receive the modified column\n * @return {Promise} - the promise for the http request\n */\n updateProjectColumn(colId, options, cb) {\n return this._request('PATCH', `/projects/columns/${colId}`, options, cb);\n }\n\n /**\n * Delete a column\n * @see https://developer.github.com/v3/projects/columns/#delete-a-project-column\n * @param {string} colId - the column to be deleted\n * @param {Requestable.callback} cb - will receive true if the operation is successful\n * @return {Promise} - the promise for the http request\n */\n deleteProjectColumn(colId, cb) {\n return this._request('DELETE', `/projects/columns/${colId}`, null, cb);\n }\n\n /**\n * Move a column\n * @see https://developer.github.com/v3/projects/columns/#move-a-project-column\n * @param {string} colId - the column to be moved\n * @param {string} position - can be one of first, last, or after:,\n * where is the id value of a column in the same project.\n * @param {Requestable.callback} cb - will receive true if the operation is successful\n * @return {Promise} - the promise for the http request\n */\n moveProjectColumn(colId, position, cb) {\n return this._request(\n 'POST',\n `/projects/columns/${colId}/moves`,\n {position: position},\n cb\n );\n }\n\n /**\n * Get information about all cards of a project\n * @see https://developer.github.com/v3/projects/cards/#list-project-cards\n * @param {Requestable.callback} [cb] - will receive the list of cards\n * @return {Promise} - the promise for the http request\n */\n listProjectCards(cb) {\n return this.listProjectColumns()\n .then(({data}) => {\n return Promise.all(data.map((column) => {\n return this._requestAllPages(`/projects/columns/${column.id}/cards`, null);\n }));\n }).then((cardsInColumns) => {\n const cards = cardsInColumns.reduce((prev, {data}) => {\n prev.push(...data);\n return prev;\n }, []);\n if (cb) {\n cb(null, cards);\n }\n return cards;\n }).catch((err) => {\n if (cb) {\n cb(err);\n return;\n }\n throw err;\n });\n }\n\n /**\n * Get information about all cards of a column\n * @see https://developer.github.com/v3/projects/cards/#list-project-cards\n * @param {string} colId - the id of the column\n * @param {Requestable.callback} [cb] - will receive the list of cards\n * @return {Promise} - the promise for the http request\n */\n listColumnCards(colId, cb) {\n return this._requestAllPages(`/projects/columns/${colId}/cards`, null, cb);\n }\n\n /**\n * Get information about a card\n * @see https://developer.github.com/v3/projects/cards/#get-a-project-card\n * @param {string} cardId - the id of the card\n * @param {Requestable.callback} cb - will receive the card information\n * @return {Promise} - the promise for the http request\n */\n getProjectCard(cardId, cb) {\n return this._request('GET', `/projects/columns/cards/${cardId}`, null, cb);\n }\n\n /**\n * Create a new card\n * @see https://developer.github.com/v3/projects/cards/#create-a-project-card\n * @param {string} colId - the column id\n * @param {Object} options - the description of the card\n * @param {Requestable.callback} cb - will receive the newly created card\n * @return {Promise} - the promise for the http request\n */\n createProjectCard(colId, options, cb) {\n return this._request('POST', `/projects/columns/${colId}/cards`, options, cb);\n }\n\n /**\n * Edit a card\n * @see https://developer.github.com/v3/projects/cards/#update-a-project-card\n * @param {string} cardId - the card id\n * @param {Object} options - the description of the card\n * @param {Requestable.callback} cb - will receive the modified card\n * @return {Promise} - the promise for the http request\n */\n updateProjectCard(cardId, options, cb) {\n return this._request('PATCH', `/projects/columns/cards/${cardId}`, options, cb);\n }\n\n /**\n * Delete a card\n * @see https://developer.github.com/v3/projects/cards/#delete-a-project-card\n * @param {string} cardId - the card to be deleted\n * @param {Requestable.callback} cb - will receive true if the operation is successful\n * @return {Promise} - the promise for the http request\n */\n deleteProjectCard(cardId, cb) {\n return this._request('DELETE', `/projects/columns/cards/${cardId}`, null, cb);\n }\n\n /**\n * Move a card\n * @see https://developer.github.com/v3/projects/cards/#move-a-project-card\n * @param {string} cardId - the card to be moved\n * @param {string} position - can be one of top, bottom, or after:,\n * where is the id value of a card in the same project.\n * @param {string} colId - the id value of a column in the same project.\n * @param {Requestable.callback} cb - will receive true if the operation is successful\n * @return {Promise} - the promise for the http request\n */\n moveProjectCard(cardId, position, colId, cb) {\n return this._request(\n 'POST',\n `/projects/columns/cards/${cardId}/moves`,\n {position: position, column_id: colId}, // eslint-disable-line camelcase\n cb\n );\n }\n}\n\nmodule.exports = Project;\n","/**\n * @file\n * @copyright 2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n * Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\n\n/**\n * RateLimit allows users to query their rate-limit status\n */\nclass RateLimit extends Requestable {\n /**\n * construct a RateLimit\n * @param {Requestable.auth} auth - the credentials to authenticate to GitHub\n * @param {string} [apiBase] - the base Github API URL\n * @return {Promise} - the promise for the http request\n */\n constructor(auth, apiBase) {\n super(auth, apiBase);\n }\n\n /**\n * Query the current rate limit\n * @see https://developer.github.com/v3/rate_limit/\n * @param {Requestable.callback} [cb] - will receive the rate-limit data\n * @return {Promise} - the promise for the http request\n */\n getRateLimit(cb) {\n return this._request('GET', '/rate_limit', null, cb);\n }\n}\n\nmodule.exports = RateLimit;\n","/**\n * @file\n * @copyright 2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n * Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\nimport Utf8 from 'utf8';\nimport {\n Base64,\n} from 'js-base64';\nimport debug from 'debug';\nconst log = debug('github:repository');\n\n/**\n * Respository encapsulates the functionality to create, query, and modify files.\n */\nclass Repository extends Requestable {\n /**\n * Create a Repository.\n * @param {string} fullname - the full name of the repository\n * @param {Requestable.auth} [auth] - information required to authenticate to Github\n * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n */\n constructor(fullname, auth, apiBase) {\n super(auth, apiBase);\n this.__fullname = fullname;\n this.__currentTree = {\n branch: null,\n sha: null,\n };\n }\n\n /**\n * Get a reference\n * @see https://developer.github.com/v3/git/refs/#get-a-reference\n * @param {string} ref - the reference to get\n * @param {Requestable.callback} [cb] - will receive the reference's refSpec or a list of refSpecs that match `ref`\n * @return {Promise} - the promise for the http request\n */\n getRef(ref, cb) {\n return this._request('GET', `/repos/${this.__fullname}/git/refs/${ref}`, null, cb);\n }\n\n /**\n * Create a reference\n * @see https://developer.github.com/v3/git/refs/#create-a-reference\n * @param {Object} options - the object describing the ref\n * @param {Requestable.callback} [cb] - will receive the ref\n * @return {Promise} - the promise for the http request\n */\n createRef(options, cb) {\n return this._request('POST', `/repos/${this.__fullname}/git/refs`, options, cb);\n }\n\n /**\n * Delete a reference\n * @see https://developer.github.com/v3/git/refs/#delete-a-reference\n * @param {string} ref - the name of the ref to delte\n * @param {Requestable.callback} [cb] - will receive true if the request is successful\n * @return {Promise} - the promise for the http request\n */\n deleteRef(ref, cb) {\n return this._request('DELETE', `/repos/${this.__fullname}/git/refs/${ref}`, null, cb);\n }\n\n /**\n * Delete a repository\n * @see https://developer.github.com/v3/repos/#delete-a-repository\n * @param {Requestable.callback} [cb] - will receive true if the request is successful\n * @return {Promise} - the promise for the http request\n */\n deleteRepo(cb) {\n return this._request('DELETE', `/repos/${this.__fullname}`, null, cb);\n }\n\n /**\n * List the tags on a repository\n * @see https://developer.github.com/v3/repos/#list-tags\n * @param {Requestable.callback} [cb] - will receive the tag data\n * @return {Promise} - the promise for the http request\n */\n listTags(cb) {\n return this._request('GET', `/repos/${this.__fullname}/tags`, null, cb);\n }\n\n /**\n * List the open pull requests on the repository\n * @see https://developer.github.com/v3/pulls/#list-pull-requests\n * @param {Object} options - options to filter the search\n * @param {Requestable.callback} [cb] - will receive the list of PRs\n * @return {Promise} - the promise for the http request\n */\n listPullRequests(options, cb) {\n options = options || {};\n return this._request('GET', `/repos/${this.__fullname}/pulls`, options, cb);\n }\n\n /**\n * Get information about a specific pull request\n * @see https://developer.github.com/v3/pulls/#get-a-single-pull-request\n * @param {number} number - the PR you wish to fetch\n * @param {Requestable.callback} [cb] - will receive the PR from the API\n * @return {Promise} - the promise for the http request\n */\n getPullRequest(number, cb) {\n return this._request('GET', `/repos/${this.__fullname}/pulls/${number}`, null, cb);\n }\n\n /**\n * List the files of a specific pull request\n * @see https://developer.github.com/v3/pulls/#list-pull-requests-files\n * @param {number|string} number - the PR you wish to fetch\n * @param {Requestable.callback} [cb] - will receive the list of files from the API\n * @return {Promise} - the promise for the http request\n */\n listPullRequestFiles(number, cb) {\n return this._request('GET', `/repos/${this.__fullname}/pulls/${number}/files`, null, cb);\n }\n\n /**\n * Compare two branches/commits/repositories\n * @see https://developer.github.com/v3/repos/commits/#compare-two-commits\n * @param {string} base - the base commit\n * @param {string} head - the head commit\n * @param {Requestable.callback} cb - will receive the comparison\n * @return {Promise} - the promise for the http request\n */\n compareBranches(base, head, cb) {\n return this._request('GET', `/repos/${this.__fullname}/compare/${base}...${head}`, null, cb);\n }\n\n /**\n * List all the branches for the repository\n * @see https://developer.github.com/v3/repos/#list-branches\n * @param {Requestable.callback} cb - will receive the list of branches\n * @return {Promise} - the promise for the http request\n */\n listBranches(cb) {\n return this._request('GET', `/repos/${this.__fullname}/branches`, null, cb);\n }\n\n /**\n * Get a raw blob from the repository\n * @see https://developer.github.com/v3/git/blobs/#get-a-blob\n * @param {string} sha - the sha of the blob to fetch\n * @param {Requestable.callback} cb - will receive the blob from the API\n * @return {Promise} - the promise for the http request\n */\n getBlob(sha, cb) {\n return this._request('GET', `/repos/${this.__fullname}/git/blobs/${sha}`, null, cb, 'raw');\n }\n\n /**\n * Get a single branch\n * @see https://developer.github.com/v3/repos/branches/#get-branch\n * @param {string} branch - the name of the branch to fetch\n * @param {Requestable.callback} cb - will receive the branch from the API\n * @returns {Promise} - the promise for the http request\n */\n getBranch(branch, cb) {\n return this._request('GET', `/repos/${this.__fullname}/branches/${branch}`, null, cb);\n }\n\n /**\n * Get a commit from the repository\n * @see https://developer.github.com/v3/repos/commits/#get-a-single-commit\n * @param {string} sha - the sha for the commit to fetch\n * @param {Requestable.callback} cb - will receive the commit data\n * @return {Promise} - the promise for the http request\n */\n getCommit(sha, cb) {\n return this._request('GET', `/repos/${this.__fullname}/git/commits/${sha}`, null, cb);\n }\n\n /**\n * List the commits on a repository, optionally filtering by path, author or time range\n * @see https://developer.github.com/v3/repos/commits/#list-commits-on-a-repository\n * @param {Object} [options] - the filtering options for commits\n * @param {string} [options.sha] - the SHA or branch to start from\n * @param {string} [options.path] - the path to search on\n * @param {string} [options.author] - the commit author\n * @param {(Date|string)} [options.since] - only commits after this date will be returned\n * @param {(Date|string)} [options.until] - only commits before this date will be returned\n * @param {Requestable.callback} cb - will receive the list of commits found matching the criteria\n * @return {Promise} - the promise for the http request\n */\n listCommits(options, cb) {\n options = options || {};\n\n options.since = this._dateToISO(options.since);\n options.until = this._dateToISO(options.until);\n\n return this._request('GET', `/repos/${this.__fullname}/commits`, options, cb);\n }\n\n /**\n * Gets a single commit information for a repository\n * @see https://developer.github.com/v3/repos/commits/#get-a-single-commit\n * @param {string} ref - the reference for the commit-ish\n * @param {Requestable.callback} cb - will receive the commit information\n * @return {Promise} - the promise for the http request\n */\n getSingleCommit(ref, cb) {\n ref = ref || '';\n return this._request('GET', `/repos/${this.__fullname}/commits/${ref}`, null, cb);\n }\n\n /**\n * Get tha sha for a particular object in the repository. This is a convenience function\n * @see https://developer.github.com/v3/repos/contents/#get-contents\n * @param {string} [branch] - the branch to look in, or the repository's default branch if omitted\n * @param {string} path - the path of the file or directory\n * @param {Requestable.callback} cb - will receive a description of the requested object, including a `SHA` property\n * @return {Promise} - the promise for the http request\n */\n getSha(branch, path, cb) {\n branch = branch ? `?ref=${branch}` : '';\n return this._request('GET', `/repos/${this.__fullname}/contents/${path}${branch}`, null, cb);\n }\n\n /**\n * List the commit statuses for a particular sha, branch, or tag\n * @see https://developer.github.com/v3/repos/statuses/#list-statuses-for-a-specific-ref\n * @param {string} sha - the sha, branch, or tag to get statuses for\n * @param {Requestable.callback} cb - will receive the list of statuses\n * @return {Promise} - the promise for the http request\n */\n listStatuses(sha, cb) {\n return this._request('GET', `/repos/${this.__fullname}/commits/${sha}/statuses`, null, cb);\n }\n\n /**\n * Get a description of a git tree\n * @see https://developer.github.com/v3/git/trees/#get-a-tree\n * @param {string} treeSHA - the SHA of the tree to fetch\n * @param {Requestable.callback} cb - will receive the callback data\n * @return {Promise} - the promise for the http request\n */\n getTree(treeSHA, cb) {\n return this._request('GET', `/repos/${this.__fullname}/git/trees/${treeSHA}`, null, cb);\n }\n\n /**\n * Create a blob\n * @see https://developer.github.com/v3/git/blobs/#create-a-blob\n * @param {(string|Buffer|Blob)} content - the content to add to the repository\n * @param {Requestable.callback} cb - will receive the details of the created blob\n * @return {Promise} - the promise for the http request\n */\n createBlob(content, cb) {\n let postBody = this._getContentObject(content);\n\n log('sending content', postBody);\n return this._request('POST', `/repos/${this.__fullname}/git/blobs`, postBody, cb);\n }\n\n /**\n * Get the object that represents the provided content\n * @param {string|Buffer|Blob} content - the content to send to the server\n * @return {Object} the representation of `content` for the GitHub API\n */\n _getContentObject(content) {\n if (typeof content === 'string') {\n log('contet is a string');\n return {\n content: Utf8.encode(content),\n encoding: 'utf-8',\n };\n\n } else if (typeof Buffer !== 'undefined' && content instanceof Buffer) {\n log('We appear to be in Node');\n return {\n content: content.toString('base64'),\n encoding: 'base64',\n };\n\n } else if (typeof Blob !== 'undefined' && content instanceof Blob) {\n log('We appear to be in the browser');\n return {\n content: Base64.encode(content),\n encoding: 'base64',\n };\n\n } else { // eslint-disable-line\n log(`Not sure what this content is: ${typeof content}, ${JSON.stringify(content)}`);\n throw new Error('Unknown content passed to postBlob. Must be string or Buffer (node) or Blob (web)');\n }\n }\n\n /**\n * Update a tree in Git\n * @see https://developer.github.com/v3/git/trees/#create-a-tree\n * @param {string} baseTreeSHA - the SHA of the tree to update\n * @param {string} path - the path for the new file\n * @param {string} blobSHA - the SHA for the blob to put at `path`\n * @param {Requestable.callback} cb - will receive the new tree that is created\n * @return {Promise} - the promise for the http request\n * @deprecated use {@link Repository#createTree} instead\n */\n updateTree(baseTreeSHA, path, blobSHA, cb) {\n let newTree = {\n base_tree: baseTreeSHA, // eslint-disable-line\n tree: [{\n path: path,\n sha: blobSHA,\n mode: '100644',\n type: 'blob',\n }],\n };\n\n return this._request('POST', `/repos/${this.__fullname}/git/trees`, newTree, cb);\n }\n\n /**\n * Create a new tree in git\n * @see https://developer.github.com/v3/git/trees/#create-a-tree\n * @param {Object} tree - the tree to create\n * @param {string} baseSHA - the root sha of the tree\n * @param {Requestable.callback} cb - will receive the new tree that is created\n * @return {Promise} - the promise for the http request\n */\n createTree(tree, baseSHA, cb) {\n return this._request('POST', `/repos/${this.__fullname}/git/trees`, {\n tree,\n base_tree: baseSHA, // eslint-disable-line camelcase\n }, cb);\n }\n\n /**\n * Add a commit to the repository\n * @see https://developer.github.com/v3/git/commits/#create-a-commit\n * @param {string} parent - the SHA of the parent commit\n * @param {string} tree - the SHA of the tree for this commit\n * @param {string} message - the commit message\n * @param {Requestable.callback} cb - will receive the commit that is created\n * @return {Promise} - the promise for the http request\n */\n commit(parent, tree, message, cb) {\n let data = {\n message,\n tree,\n parents: [parent],\n };\n\n return this._request('POST', `/repos/${this.__fullname}/git/commits`, data, cb)\n .then((response) => {\n this.__currentTree.sha = response.data.sha; // Update latest commit\n return response;\n });\n }\n\n /**\n * Update a ref\n * @see https://developer.github.com/v3/git/refs/#update-a-reference\n * @param {string} ref - the ref to update\n * @param {string} commitSHA - the SHA to point the reference to\n * @param {boolean} force - indicates whether to force or ensure a fast-forward update\n * @param {Requestable.callback} cb - will receive the updated ref back\n * @return {Promise} - the promise for the http request\n */\n updateHead(ref, commitSHA, force, cb) {\n return this._request('PATCH', `/repos/${this.__fullname}/git/refs/${ref}`, {\n sha: commitSHA,\n force: force,\n }, cb);\n }\n\n /**\n * Update commit status\n * @see https://developer.github.com/v3/repos/statuses/\n * @param {string} commitSHA - the SHA of the commit that should be updated\n * @param {object} options - Commit status parameters\n * @param {string} options.state - The state of the status. Can be one of: pending, success, error, or failure.\n * @param {string} [options.target_url] - The target URL to associate with this status.\n * @param {string} [options.description] - A short description of the status.\n * @param {string} [options.context] - A string label to differentiate this status among CI systems.\n * @param {Requestable.callback} cb - will receive the updated commit back\n * @return {Promise} - the promise for the http request\n */\n updateStatus(commitSHA, options, cb) {\n return this._request('POST', `/repos/${this.__fullname}/statuses/${commitSHA}`, options, cb);\n }\n\n /**\n * Update repository information\n * @see https://developer.github.com/v3/repos/#edit\n * @param {object} options - New parameters that will be set to the repository\n * @param {string} options.name - Name of the repository\n * @param {string} [options.description] - A short description of the repository\n * @param {string} [options.homepage] - A URL with more information about the repository\n * @param {boolean} [options.private] - Either true to make the repository private, or false to make it public.\n * @param {boolean} [options.has_issues] - Either true to enable issues for this repository, false to disable them.\n * @param {boolean} [options.has_wiki] - Either true to enable the wiki for this repository, false to disable it.\n * @param {boolean} [options.has_downloads] - Either true to enable downloads, false to disable them.\n * @param {string} [options.default_branch] - Updates the default branch for this repository.\n * @param {Requestable.callback} cb - will receive the updated repository back\n * @return {Promise} - the promise for the http request\n */\n updateRepository(options, cb) {\n return this._request('PATCH', `/repos/${this.__fullname}`, options, cb);\n }\n\n /**\n * Get information about the repository\n * @see https://developer.github.com/v3/repos/#get\n * @param {Requestable.callback} cb - will receive the information about the repository\n * @return {Promise} - the promise for the http request\n */\n getDetails(cb) {\n return this._request('GET', `/repos/${this.__fullname}`, null, cb);\n }\n\n /**\n * List the contributors to the repository\n * @see https://developer.github.com/v3/repos/#list-contributors\n * @param {Requestable.callback} cb - will receive the list of contributors\n * @return {Promise} - the promise for the http request\n */\n getContributors(cb) {\n return this._request('GET', `/repos/${this.__fullname}/contributors`, null, cb);\n }\n\n /**\n * List the contributor stats to the repository\n * @see https://developer.github.com/v3/repos/#list-contributors\n * @param {Requestable.callback} cb - will receive the list of contributors\n * @return {Promise} - the promise for the http request\n */\n getContributorStats(cb) {\n return this._request('GET', `/repos/${this.__fullname}/stats/contributors`, null, cb);\n }\n\n /**\n * List the users who are collaborators on the repository. The currently authenticated user must have\n * push access to use this method\n * @see https://developer.github.com/v3/repos/collaborators/#list-collaborators\n * @param {Requestable.callback} cb - will receive the list of collaborators\n * @return {Promise} - the promise for the http request\n */\n getCollaborators(cb) {\n return this._request('GET', `/repos/${this.__fullname}/collaborators`, null, cb);\n }\n\n /**\n * Check if a user is a collaborator on the repository\n * @see https://developer.github.com/v3/repos/collaborators/#check-if-a-user-is-a-collaborator\n * @param {string} username - the user to check\n * @param {Requestable.callback} cb - will receive true if the user is a collaborator and false if they are not\n * @return {Promise} - the promise for the http request {Boolean} [description]\n */\n isCollaborator(username, cb) {\n return this._request('GET', `/repos/${this.__fullname}/collaborators/${username}`, null, cb);\n }\n\n /**\n * Get the contents of a repository\n * @see https://developer.github.com/v3/repos/contents/#get-contents\n * @param {string} ref - the ref to check\n * @param {string} path - the path containing the content to fetch\n * @param {boolean} raw - `true` if the results should be returned raw instead of GitHub's normalized format\n * @param {Requestable.callback} cb - will receive the fetched data\n * @return {Promise} - the promise for the http request\n */\n getContents(ref, path, raw, cb) {\n path = path ? `${encodeURI(path)}` : '';\n return this._request('GET', `/repos/${this.__fullname}/contents/${path}`, {\n ref,\n }, cb, raw);\n }\n\n /**\n * Get the README of a repository\n * @see https://developer.github.com/v3/repos/contents/#get-the-readme\n * @param {string} ref - the ref to check\n * @param {boolean} raw - `true` if the results should be returned raw instead of GitHub's normalized format\n * @param {Requestable.callback} cb - will receive the fetched data\n * @return {Promise} - the promise for the http request\n */\n getReadme(ref, raw, cb) {\n return this._request('GET', `/repos/${this.__fullname}/readme`, {\n ref,\n }, cb, raw);\n }\n\n /**\n * Fork a repository\n * @see https://developer.github.com/v3/repos/forks/#create-a-fork\n * @param {Requestable.callback} cb - will receive the information about the newly created fork\n * @return {Promise} - the promise for the http request\n */\n fork(cb) {\n return this._request('POST', `/repos/${this.__fullname}/forks`, null, cb);\n }\n\n /**\n * List a repository's forks\n * @see https://developer.github.com/v3/repos/forks/#list-forks\n * @param {Requestable.callback} cb - will receive the list of repositories forked from this one\n * @return {Promise} - the promise for the http request\n */\n listForks(cb) {\n return this._request('GET', `/repos/${this.__fullname}/forks`, null, cb);\n }\n\n /**\n * Create a new branch from an existing branch.\n * @param {string} [oldBranch=master] - the name of the existing branch\n * @param {string} newBranch - the name of the new branch\n * @param {Requestable.callback} cb - will receive the commit data for the head of the new branch\n * @return {Promise} - the promise for the http request\n */\n createBranch(oldBranch, newBranch, cb) {\n if (typeof newBranch === 'function') {\n cb = newBranch;\n newBranch = oldBranch;\n oldBranch = 'master';\n }\n\n return this.getRef(`heads/${oldBranch}`)\n .then((response) => {\n let sha = response.data.object.sha;\n return this.createRef({\n sha,\n ref: `refs/heads/${newBranch}`,\n }, cb);\n });\n }\n\n /**\n * Create a new pull request\n * @see https://developer.github.com/v3/pulls/#create-a-pull-request\n * @param {Object} options - the pull request description\n * @param {Requestable.callback} cb - will receive the new pull request\n * @return {Promise} - the promise for the http request\n */\n createPullRequest(options, cb) {\n return this._request('POST', `/repos/${this.__fullname}/pulls`, options, cb);\n }\n\n /**\n * Update a pull request\n * @see https://developer.github.com/v3/pulls/#update-a-pull-request\n * @param {number|string} number - the number of the pull request to update\n * @param {Object} options - the pull request description\n * @param {Requestable.callback} [cb] - will receive the pull request information\n * @return {Promise} - the promise for the http request\n */\n updatePullRequest(number, options, cb) {\n return this._request('PATCH', `/repos/${this.__fullname}/pulls/${number}`, options, cb);\n }\n\n /**\n * List the hooks for the repository\n * @see https://developer.github.com/v3/repos/hooks/#list-hooks\n * @param {Requestable.callback} cb - will receive the list of hooks\n * @return {Promise} - the promise for the http request\n */\n listHooks(cb) {\n return this._request('GET', `/repos/${this.__fullname}/hooks`, null, cb);\n }\n\n /**\n * Get a hook for the repository\n * @see https://developer.github.com/v3/repos/hooks/#get-single-hook\n * @param {number} id - the id of the webook\n * @param {Requestable.callback} cb - will receive the details of the webook\n * @return {Promise} - the promise for the http request\n */\n getHook(id, cb) {\n return this._request('GET', `/repos/${this.__fullname}/hooks/${id}`, null, cb);\n }\n\n /**\n * Add a new hook to the repository\n * @see https://developer.github.com/v3/repos/hooks/#create-a-hook\n * @param {Object} options - the configuration describing the new hook\n * @param {Requestable.callback} cb - will receive the new webhook\n * @return {Promise} - the promise for the http request\n */\n createHook(options, cb) {\n return this._request('POST', `/repos/${this.__fullname}/hooks`, options, cb);\n }\n\n /**\n * Edit an existing webhook\n * @see https://developer.github.com/v3/repos/hooks/#edit-a-hook\n * @param {number} id - the id of the webhook\n * @param {Object} options - the new description of the webhook\n * @param {Requestable.callback} cb - will receive the updated webhook\n * @return {Promise} - the promise for the http request\n */\n updateHook(id, options, cb) {\n return this._request('PATCH', `/repos/${this.__fullname}/hooks/${id}`, options, cb);\n }\n\n /**\n * Delete a webhook\n * @see https://developer.github.com/v3/repos/hooks/#delete-a-hook\n * @param {number} id - the id of the webhook to be deleted\n * @param {Requestable.callback} cb - will receive true if the call is successful\n * @return {Promise} - the promise for the http request\n */\n deleteHook(id, cb) {\n return this._request('DELETE', `/repos/${this.__fullname}/hooks/${id}`, null, cb);\n }\n\n /**\n * List the deploy keys for the repository\n * @see https://developer.github.com/v3/repos/keys/#list-deploy-keys\n * @param {Requestable.callback} cb - will receive the list of deploy keys\n * @return {Promise} - the promise for the http request\n */\n listKeys(cb) {\n return this._request('GET', `/repos/${this.__fullname}/keys`, null, cb);\n }\n\n /**\n * Get a deploy key for the repository\n * @see https://developer.github.com/v3/repos/keys/#get-a-deploy-key\n * @param {number} id - the id of the deploy key\n * @param {Requestable.callback} cb - will receive the details of the deploy key\n * @return {Promise} - the promise for the http request\n */\n getKey(id, cb) {\n return this._request('GET', `/repos/${this.__fullname}/keys/${id}`, null, cb);\n }\n\n /**\n * Add a new deploy key to the repository\n * @see https://developer.github.com/v3/repos/keys/#add-a-new-deploy-key\n * @param {Object} options - the configuration describing the new deploy key\n * @param {Requestable.callback} cb - will receive the new deploy key\n * @return {Promise} - the promise for the http request\n */\n createKey(options, cb) {\n return this._request('POST', `/repos/${this.__fullname}/keys`, options, cb);\n }\n\n /**\n * Delete a deploy key\n * @see https://developer.github.com/v3/repos/keys/#remove-a-deploy-key\n * @param {number} id - the id of the deploy key to be deleted\n * @param {Requestable.callback} cb - will receive true if the call is successful\n * @return {Promise} - the promise for the http request\n */\n deleteKey(id, cb) {\n return this._request('DELETE', `/repos/${this.__fullname}/keys/${id}`, null, cb);\n }\n\n /**\n * Delete a file from a branch\n * @see https://developer.github.com/v3/repos/contents/#delete-a-file\n * @param {string} branch - the branch to delete from, or the default branch if not specified\n * @param {string} path - the path of the file to remove\n * @param {Requestable.callback} cb - will receive the commit in which the delete occurred\n * @return {Promise} - the promise for the http request\n */\n deleteFile(branch, path, cb) {\n return this.getSha(branch, path)\n .then((response) => {\n const deleteCommit = {\n message: `Delete the file at '${path}'`,\n sha: response.data.sha,\n branch,\n };\n return this._request('DELETE', `/repos/${this.__fullname}/contents/${path}`, deleteCommit, cb);\n });\n }\n\n /**\n * Change all references in a repo from oldPath to new_path\n * @param {string} branch - the branch to carry out the reference change, or the default branch if not specified\n * @param {string} oldPath - original path\n * @param {string} newPath - new reference path\n * @param {Requestable.callback} cb - will receive the commit in which the move occurred\n * @return {Promise} - the promise for the http request\n */\n move(branch, oldPath, newPath, cb) {\n let oldSha;\n return this.getRef(`heads/${branch}`)\n .then(({data: {object}}) => this.getTree(`${object.sha}?recursive=true`))\n .then(({data: {tree, sha}}) => {\n oldSha = sha;\n let newTree = tree.map((ref) => {\n if (ref.path === oldPath) {\n ref.path = newPath;\n }\n if (ref.type === 'tree') {\n delete ref.sha;\n }\n return ref;\n });\n return this.createTree(newTree);\n })\n .then(({data: tree}) => this.commit(oldSha, tree.sha, `Renamed '${oldPath}' to '${newPath}'`))\n .then(({data: commit}) => this.updateHead(`heads/${branch}`, commit.sha, true, cb));\n }\n\n /**\n * Write a file to the repository\n * @see https://developer.github.com/v3/repos/contents/#update-a-file\n * @param {string} branch - the name of the branch\n * @param {string} path - the path for the file\n * @param {string} content - the contents of the file\n * @param {string} message - the commit message\n * @param {Object} [options] - commit options\n * @param {Object} [options.author] - the author of the commit\n * @param {Object} [options.commiter] - the committer\n * @param {boolean} [options.encode] - true if the content should be base64 encoded\n * @param {Requestable.callback} cb - will receive the new commit\n * @return {Promise} - the promise for the http request\n */\n writeFile(branch, path, content, message, options, cb) {\n if (typeof options === 'function') {\n cb = options;\n options = {};\n }\n let filePath = path ? encodeURI(path) : '';\n let shouldEncode = options.encode !== false;\n let commit = {\n branch,\n message,\n author: options.author,\n committer: options.committer,\n content: shouldEncode ? Base64.encode(content) : content,\n };\n\n return this.getSha(branch, filePath)\n .then((response) => {\n commit.sha = response.data.sha;\n return this._request('PUT', `/repos/${this.__fullname}/contents/${filePath}`, commit, cb);\n }, () => {\n return this._request('PUT', `/repos/${this.__fullname}/contents/${filePath}`, commit, cb);\n });\n }\n\n /**\n * Check if a repository is starred by you\n * @see https://developer.github.com/v3/activity/starring/#check-if-you-are-starring-a-repository\n * @param {Requestable.callback} cb - will receive true if the repository is starred and false if the repository\n * is not starred\n * @return {Promise} - the promise for the http request {Boolean} [description]\n */\n isStarred(cb) {\n return this._request204or404(`/user/starred/${this.__fullname}`, null, cb);\n }\n\n /**\n * Star a repository\n * @see https://developer.github.com/v3/activity/starring/#star-a-repository\n * @param {Requestable.callback} cb - will receive true if the repository is starred\n * @return {Promise} - the promise for the http request\n */\n star(cb) {\n return this._request('PUT', `/user/starred/${this.__fullname}`, null, cb);\n }\n\n /**\n * Unstar a repository\n * @see https://developer.github.com/v3/activity/starring/#unstar-a-repository\n * @param {Requestable.callback} cb - will receive true if the repository is unstarred\n * @return {Promise} - the promise for the http request\n */\n unstar(cb) {\n return this._request('DELETE', `/user/starred/${this.__fullname}`, null, cb);\n }\n\n /**\n * Create a new release\n * @see https://developer.github.com/v3/repos/releases/#create-a-release\n * @param {Object} options - the description of the release\n * @param {Requestable.callback} cb - will receive the newly created release\n * @return {Promise} - the promise for the http request\n */\n createRelease(options, cb) {\n return this._request('POST', `/repos/${this.__fullname}/releases`, options, cb);\n }\n\n /**\n * Edit a release\n * @see https://developer.github.com/v3/repos/releases/#edit-a-release\n * @param {string} id - the id of the release\n * @param {Object} options - the description of the release\n * @param {Requestable.callback} cb - will receive the modified release\n * @return {Promise} - the promise for the http request\n */\n updateRelease(id, options, cb) {\n return this._request('PATCH', `/repos/${this.__fullname}/releases/${id}`, options, cb);\n }\n\n /**\n * Get information about all releases\n * @see https://developer.github.com/v3/repos/releases/#list-releases-for-a-repository\n * @param {Requestable.callback} cb - will receive the release information\n * @return {Promise} - the promise for the http request\n */\n listReleases(cb) {\n return this._request('GET', `/repos/${this.__fullname}/releases`, null, cb);\n }\n\n /**\n * Get information about a release\n * @see https://developer.github.com/v3/repos/releases/#get-a-single-release\n * @param {string} id - the id of the release\n * @param {Requestable.callback} cb - will receive the release information\n * @return {Promise} - the promise for the http request\n */\n getRelease(id, cb) {\n return this._request('GET', `/repos/${this.__fullname}/releases/${id}`, null, cb);\n }\n\n /**\n * Delete a release\n * @see https://developer.github.com/v3/repos/releases/#delete-a-release\n * @param {string} id - the release to be deleted\n * @param {Requestable.callback} cb - will receive true if the operation is successful\n * @return {Promise} - the promise for the http request\n */\n deleteRelease(id, cb) {\n return this._request('DELETE', `/repos/${this.__fullname}/releases/${id}`, null, cb);\n }\n\n /**\n * Merge a pull request\n * @see https://developer.github.com/v3/pulls/#merge-a-pull-request-merge-button\n * @param {number|string} number - the number of the pull request to merge\n * @param {Object} options - the merge options for the pull request\n * @param {Requestable.callback} [cb] - will receive the merge information if the operation is successful\n * @return {Promise} - the promise for the http request\n */\n mergePullRequest(number, options, cb) {\n return this._request('PUT', `/repos/${this.__fullname}/pulls/${number}/merge`, options, cb);\n }\n\n /**\n * Get information about all projects\n * @see https://developer.github.com/v3/projects/#list-repository-projects\n * @param {Requestable.callback} [cb] - will receive the list of projects\n * @return {Promise} - the promise for the http request\n */\n listProjects(cb) {\n return this._requestAllPages(`/repos/${this.__fullname}/projects`, {AcceptHeader: 'inertia-preview'}, cb);\n }\n\n /**\n * Create a new project\n * @see https://developer.github.com/v3/projects/#create-a-repository-project\n * @param {Object} options - the description of the project\n * @param {Requestable.callback} cb - will receive the newly created project\n * @return {Promise} - the promise for the http request\n */\n createProject(options, cb) {\n options = options || {};\n options.AcceptHeader = 'inertia-preview';\n return this._request('POST', `/repos/${this.__fullname}/projects`, options, cb);\n }\n\n}\n\nmodule.exports = Repository;\n","/**\n * @file\n * @copyright 2016 Yahoo Inc.\n * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n * Github.js is freely distributable.\n */\n\nimport axios from 'axios';\nimport debug from 'debug';\nimport {Base64} from 'js-base64';\n\nconst log = debug('github:request');\n\n/**\n * The error structure returned when a network call fails\n */\nclass ResponseError extends Error {\n /**\n * Construct a new ResponseError\n * @param {string} message - an message to return instead of the the default error message\n * @param {string} path - the requested path\n * @param {Object} response - the object returned by Axios\n */\n constructor(message, path, response) {\n super(message);\n this.path = path;\n this.request = response.config;\n this.response = (response || {}).response || response;\n this.status = response.status;\n }\n}\n\n/**\n * Requestable wraps the logic for making http requests to the API\n */\nclass Requestable {\n /**\n * Either a username and password or an oauth token for Github\n * @typedef {Object} Requestable.auth\n * @prop {string} [username] - the Github username\n * @prop {string} [password] - the user's password\n * @prop {token} [token] - an OAuth token\n */\n /**\n * Initialize the http internals.\n * @param {Requestable.auth} [auth] - the credentials to authenticate to Github. If auth is\n * not provided request will be made unauthenticated\n * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n * @param {string} [AcceptHeader=v3] - the accept header for the requests\n */\n constructor(auth, apiBase, AcceptHeader) {\n this.__apiBase = apiBase || 'https://api.github.com';\n this.__auth = {\n token: auth.token,\n username: auth.username,\n password: auth.password,\n };\n this.__AcceptHeader = AcceptHeader || 'v3';\n\n if (auth.token) {\n this.__authorizationHeader = 'token ' + auth.token;\n } else if (auth.username && auth.password) {\n this.__authorizationHeader = 'Basic ' + Base64.encode(auth.username + ':' + auth.password);\n }\n }\n\n /**\n * Compute the URL to use to make a request.\n * @private\n * @param {string} path - either a URL relative to the API base or an absolute URL\n * @return {string} - the URL to use\n */\n __getURL(path) {\n let url = path;\n\n if (path.indexOf('//') === -1) {\n url = this.__apiBase + path;\n }\n\n let newCacheBuster = 'timestamp=' + new Date().getTime();\n return url.replace(/(timestamp=\\d+)/, newCacheBuster);\n }\n\n /**\n * Compute the headers required for an API request.\n * @private\n * @param {boolean} raw - if the request should be treated as JSON or as a raw request\n * @param {string} AcceptHeader - the accept header for the request\n * @return {Object} - the headers to use in the request\n */\n __getRequestHeaders(raw, AcceptHeader) {\n let headers = {\n 'Content-Type': 'application/json;charset=UTF-8',\n 'Accept': 'application/vnd.github.' + (AcceptHeader || this.__AcceptHeader),\n };\n\n if (raw) {\n headers.Accept += '.raw';\n }\n headers.Accept += '+json';\n\n if (this.__authorizationHeader) {\n headers.Authorization = this.__authorizationHeader;\n }\n\n return headers;\n }\n\n /**\n * Sets the default options for API requests\n * @protected\n * @param {Object} [requestOptions={}] - the current options for the request\n * @return {Object} - the options to pass to the request\n */\n _getOptionsWithDefaults(requestOptions = {}) {\n if (!(requestOptions.visibility || requestOptions.affiliation)) {\n requestOptions.type = requestOptions.type || 'all';\n }\n requestOptions.sort = requestOptions.sort || 'updated';\n requestOptions.per_page = requestOptions.per_page || '100'; // eslint-disable-line\n\n return requestOptions;\n }\n\n /**\n * if a `Date` is passed to this function it will be converted to an ISO string\n * @param {*} date - the object to attempt to cooerce into an ISO date string\n * @return {string} - the ISO representation of `date` or whatever was passed in if it was not a date\n */\n _dateToISO(date) {\n if (date && (date instanceof Date)) {\n date = date.toISOString();\n }\n\n return date;\n }\n\n /**\n * A function that receives the result of the API request.\n * @callback Requestable.callback\n * @param {Requestable.Error} error - the error returned by the API or `null`\n * @param {(Object|true)} result - the data returned by the API or `true` if the API returns `204 No Content`\n * @param {Object} request - the raw {@linkcode https://github.com/mzabriskie/axios#response-schema Response}\n */\n /**\n * Make a request.\n * @param {string} method - the method for the request (GET, PUT, POST, DELETE)\n * @param {string} path - the path for the request\n * @param {*} [data] - the data to send to the server. For HTTP methods that don't have a body the data\n * will be sent as query parameters\n * @param {Requestable.callback} [cb] - the callback for the request\n * @param {boolean} [raw=false] - if the request should be sent as raw. If this is a falsy value then the\n * request will be made as JSON\n * @return {Promise} - the Promise for the http request\n */\n _request(method, path, data, cb, raw) {\n const url = this.__getURL(path);\n\n const AcceptHeader = (data || {}).AcceptHeader;\n if (AcceptHeader) {\n delete data.AcceptHeader;\n }\n const headers = this.__getRequestHeaders(raw, AcceptHeader);\n\n let queryParams = {};\n\n const shouldUseDataAsParams = data && (typeof data === 'object') && methodHasNoBody(method);\n if (shouldUseDataAsParams) {\n queryParams = data;\n data = undefined;\n }\n\n const config = {\n url: url,\n method: method,\n headers: headers,\n params: queryParams,\n data: data,\n responseType: raw ? 'text' : 'json',\n };\n\n log(`${config.method} to ${config.url}`);\n const requestPromise = axios(config).catch(callbackErrorOrThrow(cb, path));\n\n if (cb) {\n requestPromise.then((response) => {\n if (response.data && Object.keys(response.data).length > 0) {\n // When data has results\n cb(null, response.data, response);\n } else if (config.method !== 'GET' && Object.keys(response.data).length < 1) {\n // True when successful submit a request and receive a empty object\n cb(null, (response.status < 300), response);\n } else {\n cb(null, response.data, response);\n }\n });\n }\n\n return requestPromise;\n }\n\n /**\n * Make a request to an endpoint the returns 204 when true and 404 when false\n * @param {string} path - the path to request\n * @param {Object} data - any query parameters for the request\n * @param {Requestable.callback} cb - the callback that will receive `true` or `false`\n * @param {method} [method=GET] - HTTP Method to use\n * @return {Promise} - the promise for the http request\n */\n _request204or404(path, data, cb, method = 'GET') {\n return this._request(method, path, data)\n .then(function success(response) {\n if (cb) {\n cb(null, true, response);\n }\n return true;\n }, function failure(response) {\n if (response.response.status === 404) {\n if (cb) {\n cb(null, false, response);\n }\n return false;\n }\n\n if (cb) {\n cb(response);\n }\n throw response;\n });\n }\n\n /**\n * Make a request and fetch all the available data. Github will paginate responses so for queries\n * that might span multiple pages this method is preferred to {@link Requestable#request}\n * @param {string} path - the path to request\n * @param {Object} options - the query parameters to include\n * @param {Requestable.callback} [cb] - the function to receive the data. The returned data will always be an array.\n * @param {Object[]} results - the partial results. This argument is intended for interal use only.\n * @return {Promise} - a promise which will resolve when all pages have been fetched\n * @deprecated This will be folded into {@link Requestable#_request} in the 2.0 release.\n */\n _requestAllPages(path, options, cb, results) {\n results = results || [];\n\n return this._request('GET', path, options)\n .then((response) => {\n let thisGroup;\n if (response.data instanceof Array) {\n thisGroup = response.data;\n } else if (response.data.items instanceof Array) {\n thisGroup = response.data.items;\n } else {\n let message = `cannot figure out how to append ${response.data} to the result set`;\n throw new ResponseError(message, path, response);\n }\n results.push(...thisGroup);\n\n const nextUrl = getNextPage(response.headers.link);\n if (nextUrl && typeof options.page !== 'number') {\n log(`getting next page: ${nextUrl}`);\n return this._requestAllPages(nextUrl, options, cb, results);\n }\n\n if (cb) {\n cb(null, results, response);\n }\n\n response.data = results;\n return response;\n }).catch(callbackErrorOrThrow(cb, path));\n }\n}\n\nmodule.exports = Requestable;\n\n// ////////////////////////// //\n// Private helper functions //\n// ////////////////////////// //\nconst METHODS_WITH_NO_BODY = ['GET', 'HEAD', 'DELETE'];\nfunction methodHasNoBody(method) {\n return METHODS_WITH_NO_BODY.indexOf(method) !== -1;\n}\n\nfunction getNextPage(linksHeader = '') {\n const links = linksHeader.split(/\\s*,\\s*/); // splits and strips the urls\n return links.reduce(function(nextUrl, link) {\n if (link.search(/rel=\"next\"/) !== -1) {\n return (link.match(/<(.*)>/) || [])[1];\n }\n\n return nextUrl;\n }, undefined);\n}\n\nfunction callbackErrorOrThrow(cb, path) {\n return function handler(object) {\n let error;\n if (object.hasOwnProperty('config')) {\n const {response: {status, statusText}, config: {method, url}} = object;\n let message = (`${status} error making request ${method} ${url}: \"${statusText}\"`);\n error = new ResponseError(message, path, object);\n log(`${message} ${JSON.stringify(object.data)}`);\n } else {\n error = object;\n }\n if (cb) {\n log('going to error callback');\n cb(error);\n } else {\n log('throwing error');\n throw error;\n }\n };\n}\n","/**\n * @file\n * @copyright 2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n * Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\nimport debug from 'debug';\nconst log = debug('github:search');\n\n/**\n * Wrap the Search API\n */\nclass Search extends Requestable {\n /**\n * Create a Search\n * @param {Object} defaults - defaults for the search\n * @param {Requestable.auth} [auth] - information required to authenticate to Github\n * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n */\n constructor(defaults, auth, apiBase) {\n super(auth, apiBase);\n this.__defaults = this._getOptionsWithDefaults(defaults);\n }\n\n /**\n * Available search options\n * @see https://developer.github.com/v3/search/#parameters\n * @typedef {Object} Search.Params\n * @param {string} q - the query to make\n * @param {string} sort - the sort field, one of `stars`, `forks`, or `updated`.\n * Default is [best match](https://developer.github.com/v3/search/#ranking-search-results)\n * @param {string} order - the ordering, either `asc` or `desc`\n */\n /**\n * Perform a search on the GitHub API\n * @private\n * @param {string} path - the scope of the search\n * @param {Search.Params} [withOptions] - additional parameters for the search\n * @param {Requestable.callback} [cb] - will receive the results of the search\n * @return {Promise} - the promise for the http request\n */\n _search(path, withOptions = {}, cb = undefined) {\n let requestOptions = {};\n Object.keys(this.__defaults).forEach((prop) => {\n requestOptions[prop] = this.__defaults[prop];\n });\n Object.keys(withOptions).forEach((prop) => {\n requestOptions[prop] = withOptions[prop];\n });\n\n log(`searching ${path} with options:`, requestOptions);\n return this._requestAllPages(`/search/${path}`, requestOptions, cb);\n }\n\n /**\n * Search for repositories\n * @see https://developer.github.com/v3/search/#search-repositories\n * @param {Search.Params} [options] - additional parameters for the search\n * @param {Requestable.callback} [cb] - will receive the results of the search\n * @return {Promise} - the promise for the http request\n */\n forRepositories(options, cb) {\n return this._search('repositories', options, cb);\n }\n\n /**\n * Search for code\n * @see https://developer.github.com/v3/search/#search-code\n * @param {Search.Params} [options] - additional parameters for the search\n * @param {Requestable.callback} [cb] - will receive the results of the search\n * @return {Promise} - the promise for the http request\n */\n forCode(options, cb) {\n return this._search('code', options, cb);\n }\n\n /**\n * Search for issues\n * @see https://developer.github.com/v3/search/#search-issues\n * @param {Search.Params} [options] - additional parameters for the search\n * @param {Requestable.callback} [cb] - will receive the results of the search\n * @return {Promise} - the promise for the http request\n */\n forIssues(options, cb) {\n return this._search('issues', options, cb);\n }\n\n /**\n * Search for users\n * @see https://developer.github.com/v3/search/#search-users\n * @param {Search.Params} [options] - additional parameters for the search\n * @param {Requestable.callback} [cb] - will receive the results of the search\n * @return {Promise} - the promise for the http request\n */\n forUsers(options, cb) {\n return this._search('users', options, cb);\n }\n}\n\nmodule.exports = Search;\n","/**\n * @file\n * @copyright 2016 Matt Smith (Development Seed)\n * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n * Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\nimport debug from 'debug';\nconst log = debug('github:team');\n\n/**\n * A Team allows scoping of API requests to a particular Github Organization Team.\n */\nclass Team extends Requestable {\n /**\n * Create a Team.\n * @param {string} [teamId] - the id for the team\n * @param {Requestable.auth} [auth] - information required to authenticate to Github\n * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n */\n constructor(teamId, auth, apiBase) {\n super(auth, apiBase);\n this.__teamId = teamId;\n }\n\n /**\n * Get Team information\n * @see https://developer.github.com/v3/orgs/teams/#get-team\n * @param {Requestable.callback} [cb] - will receive the team\n * @return {Promise} - the promise for the http request\n */\n getTeam(cb) {\n log(`Fetching Team ${this.__teamId}`);\n return this._request('Get', `/teams/${this.__teamId}`, undefined, cb);\n }\n\n /**\n * List the Team's repositories\n * @see https://developer.github.com/v3/orgs/teams/#list-team-repos\n * @param {Requestable.callback} [cb] - will receive the list of repositories\n * @return {Promise} - the promise for the http request\n */\n listRepos(cb) {\n log(`Fetching repositories for Team ${this.__teamId}`);\n return this._requestAllPages(`/teams/${this.__teamId}/repos`, undefined, cb);\n }\n\n /**\n * Edit Team information\n * @see https://developer.github.com/v3/orgs/teams/#edit-team\n * @param {object} options - Parameters for team edit\n * @param {string} options.name - The name of the team\n * @param {string} [options.description] - Team description\n * @param {string} [options.repo_names] - Repos to add the team to\n * @param {string} [options.privacy=secret] - The level of privacy the team should have. Can be either one\n * of: `secret`, or `closed`\n * @param {Requestable.callback} [cb] - will receive the updated team\n * @return {Promise} - the promise for the http request\n */\n editTeam(options, cb) {\n log(`Editing Team ${this.__teamId}`);\n return this._request('PATCH', `/teams/${this.__teamId}`, options, cb);\n }\n\n /**\n * List the users who are members of the Team\n * @see https://developer.github.com/v3/orgs/teams/#list-team-members\n * @param {object} options - Parameters for listing team users\n * @param {string} [options.role=all] - can be one of: `all`, `maintainer`, or `member`\n * @param {Requestable.callback} [cb] - will receive the list of users\n * @return {Promise} - the promise for the http request\n */\n listMembers(options, cb) {\n log(`Getting members of Team ${this.__teamId}`);\n return this._requestAllPages(`/teams/${this.__teamId}/members`, options, cb);\n }\n\n /**\n * Get Team membership status for a user\n * @see https://developer.github.com/v3/orgs/teams/#get-team-membership\n * @param {string} username - can be one of: `all`, `maintainer`, or `member`\n * @param {Requestable.callback} [cb] - will receive the membership status of a user\n * @return {Promise} - the promise for the http request\n */\n getMembership(username, cb) {\n log(`Getting membership of user ${username} in Team ${this.__teamId}`);\n return this._request('GET', `/teams/${this.__teamId}/memberships/${username}`, undefined, cb);\n }\n\n /**\n * Add a member to the Team\n * @see https://developer.github.com/v3/orgs/teams/#add-team-membership\n * @param {string} username - can be one of: `all`, `maintainer`, or `member`\n * @param {object} options - Parameters for adding a team member\n * @param {string} [options.role=member] - The role that this user should have in the team. Can be one\n * of: `member`, or `maintainer`\n * @param {Requestable.callback} [cb] - will receive the membership status of added user\n * @return {Promise} - the promise for the http request\n */\n addMembership(username, options, cb) {\n log(`Adding user ${username} to Team ${this.__teamId}`);\n return this._request('PUT', `/teams/${this.__teamId}/memberships/${username}`, options, cb);\n }\n\n /**\n * Get repo management status for team\n * @see https://developer.github.com/v3/orgs/teams/#remove-team-membership\n * @param {string} owner - Organization name\n * @param {string} repo - Repo name\n * @param {Requestable.callback} [cb] - will receive the membership status of added user\n * @return {Promise} - the promise for the http request\n */\n isManagedRepo(owner, repo, cb) {\n log(`Getting repo management by Team ${this.__teamId} for repo ${owner}/${repo}`);\n return this._request204or404(`/teams/${this.__teamId}/repos/${owner}/${repo}`, undefined, cb);\n }\n\n /**\n * Add or Update repo management status for team\n * @see https://developer.github.com/v3/orgs/teams/#add-or-update-team-repository\n * @param {string} owner - Organization name\n * @param {string} repo - Repo name\n * @param {object} options - Parameters for adding or updating repo management for the team\n * @param {string} [options.permission] - The permission to grant the team on this repository. Can be one\n * of: `pull`, `push`, or `admin`\n * @param {Requestable.callback} [cb] - will receive the membership status of added user\n * @return {Promise} - the promise for the http request\n */\n manageRepo(owner, repo, options, cb) {\n log(`Adding or Updating repo management by Team ${this.__teamId} for repo ${owner}/${repo}`);\n return this._request204or404(`/teams/${this.__teamId}/repos/${owner}/${repo}`, options, cb, 'PUT');\n }\n\n /**\n * Remove repo management status for team\n * @see https://developer.github.com/v3/orgs/teams/#remove-team-repository\n * @param {string} owner - Organization name\n * @param {string} repo - Repo name\n * @param {Requestable.callback} [cb] - will receive the membership status of added user\n * @return {Promise} - the promise for the http request\n */\n unmanageRepo(owner, repo, cb) {\n log(`Remove repo management by Team ${this.__teamId} for repo ${owner}/${repo}`);\n return this._request204or404(`/teams/${this.__teamId}/repos/${owner}/${repo}`, undefined, cb, 'DELETE');\n }\n\n /**\n * Delete Team\n * @see https://developer.github.com/v3/orgs/teams/#delete-team\n * @param {Requestable.callback} [cb] - will receive the list of repositories\n * @return {Promise} - the promise for the http request\n */\n deleteTeam(cb) {\n log(`Deleting Team ${this.__teamId}`);\n return this._request204or404(`/teams/${this.__teamId}`, undefined, cb, 'DELETE');\n }\n}\n\nmodule.exports = Team;\n","/**\n * @file\n * @copyright 2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n * Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\nimport debug from 'debug';\nconst log = debug('github:user');\n\n/**\n * A User allows scoping of API requests to a particular Github user.\n */\nclass User extends Requestable {\n /**\n * Create a User.\n * @param {string} [username] - the user to use for user-scoped queries\n * @param {Requestable.auth} [auth] - information required to authenticate to Github\n * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n */\n constructor(username, auth, apiBase) {\n super(auth, apiBase);\n this.__user = username;\n }\n\n /**\n * Get the url for the request. (dependent on if we're requesting for the authenticated user or not)\n * @private\n * @param {string} endpoint - the endpoint being requested\n * @return {string} - the resolved endpoint\n */\n __getScopedUrl(endpoint) {\n if (this.__user) {\n return endpoint ?\n `/users/${this.__user}/${endpoint}` :\n `/users/${this.__user}`\n ;\n\n } else { // eslint-disable-line\n switch (endpoint) {\n case '':\n return '/user';\n\n case 'notifications':\n case 'gists':\n return `/${endpoint}`;\n\n default:\n return `/user/${endpoint}`;\n }\n }\n }\n\n /**\n * List the user's repositories\n * @see https://developer.github.com/v3/repos/#list-user-repositories\n * @param {Object} [options={}] - any options to refine the search\n * @param {Requestable.callback} [cb] - will receive the list of repositories\n * @return {Promise} - the promise for the http request\n */\n listRepos(options, cb) {\n if (typeof options === 'function') {\n cb = options;\n options = {};\n }\n\n options = this._getOptionsWithDefaults(options);\n\n log(`Fetching repositories with options: ${JSON.stringify(options)}`);\n return this._requestAllPages(this.__getScopedUrl('repos'), options, cb);\n }\n\n /**\n * List the orgs that the user belongs to\n * @see https://developer.github.com/v3/orgs/#list-user-organizations\n * @param {Requestable.callback} [cb] - will receive the list of organizations\n * @return {Promise} - the promise for the http request\n */\n listOrgs(cb) {\n return this._request('GET', this.__getScopedUrl('orgs'), null, cb);\n }\n\n /**\n * List the user's gists\n * @see https://developer.github.com/v3/gists/#list-a-users-gists\n * @param {Requestable.callback} [cb] - will receive the list of gists\n * @return {Promise} - the promise for the http request\n */\n listGists(cb) {\n return this._request('GET', this.__getScopedUrl('gists'), null, cb);\n }\n\n /**\n * List the user's starred gists\n * @see https://developer.github.com/v3/gists/#list-starred-gists\n * @param {Requestable.callback} [cb] - will receive the list of gists\n * @return {Promise} - the promise for the http request\n */\n listStarredGists(cb) {\n return this._request('GET', this.__getScopedUrl('gists/starred'), null, cb);\n }\n\n /**\n * List the user's gists\n * @see https://developer.github.com/v3/gists/#list-a-users-gists\n * @param {Requestable.callback} [cb] - will receive the list of gists\n * @return {Promise} - the promise for the http request\n */\n listStarredGists(cb) {\n return this._request('GET', this.__getScopedUrl('gists'), null, cb);\n }\n\n /**\n * List the user's notifications\n * @see https://developer.github.com/v3/activity/notifications/#list-your-notifications\n * @param {Object} [options={}] - any options to refine the search\n * @param {Requestable.callback} [cb] - will receive the list of repositories\n * @return {Promise} - the promise for the http request\n */\n listNotifications(options, cb) {\n options = options || {};\n if (typeof options === 'function') {\n cb = options;\n options = {};\n }\n\n options.since = this._dateToISO(options.since);\n options.before = this._dateToISO(options.before);\n\n return this._request('GET', this.__getScopedUrl('notifications'), options, cb);\n }\n\n /**\n * Show the user's profile\n * @see https://developer.github.com/v3/users/#get-a-single-user\n * @param {Requestable.callback} [cb] - will receive the user's information\n * @return {Promise} - the promise for the http request\n */\n getProfile(cb) {\n return this._request('GET', this.__getScopedUrl(''), null, cb);\n }\n\n /**\n * Gets the list of starred repositories for the user\n * @see https://developer.github.com/v3/activity/starring/#list-repositories-being-starred\n * @param {Requestable.callback} [cb] - will receive the list of starred repositories\n * @return {Promise} - the promise for the http request\n */\n listStarredRepos(cb) {\n let requestOptions = this._getOptionsWithDefaults();\n return this._requestAllPages(this.__getScopedUrl('starred'), requestOptions, cb);\n }\n\n /**\n * List email addresses for a user\n * @see https://developer.github.com/v3/users/emails/#list-email-addresses-for-a-user\n * @param {Requestable.callback} [cb] - will receive the list of emails\n * @return {Promise} - the promise for the http request\n */\n getEmails(cb) {\n return this._request('GET', '/user/emails', null, cb);\n }\n\n /**\n * Have the authenticated user follow this user\n * @see https://developer.github.com/v3/users/followers/#follow-a-user\n * @param {string} username - the user to follow\n * @param {Requestable.callback} [cb] - will receive true if the request succeeds\n * @return {Promise} - the promise for the http request\n */\n follow(username, cb) {\n return this._request('PUT', `/user/following/${this.__user}`, null, cb);\n }\n\n /**\n * Have the currently authenticated user unfollow this user\n * @see https://developer.github.com/v3/users/followers/#follow-a-user\n * @param {string} username - the user to unfollow\n * @param {Requestable.callback} [cb] - receives true if the request succeeds\n * @return {Promise} - the promise for the http request\n */\n unfollow(username, cb) {\n return this._request('DELETE', `/user/following/${this.__user}`, null, cb);\n }\n\n /**\n * Create a new repository for the currently authenticated user\n * @see https://developer.github.com/v3/repos/#create\n * @param {object} options - the repository definition\n * @param {Requestable.callback} [cb] - will receive the API response\n * @return {Promise} - the promise for the http request\n */\n createRepo(options, cb) {\n return this._request('POST', '/user/repos', options, cb);\n }\n}\n\nmodule.exports = User;\n"]} \ No newline at end of file +{"version":3,"sources":["node_modules/browser-pack/_prelude.js","lib/Gist.js","lib/GitHub.js","lib/Issue.js","lib/Markdown.js","lib/Organization.js","lib/Project.js","lib/RateLimit.js","lib/Repository.js","lib/Requestable.js","lib/Search.js","lib/Team.js","lib/User.js"],"names":["f","exports","module","define","amd","g","window","global","self","this","GitHub","e","t","n","r","s","o","u","a","require","i","Error","code","l","call","length","1","_Requestable2","Gist","id","auth","apiBase","_classCallCheck","_this","_possibleConstructorReturn","__proto__","Object","getPrototypeOf","__id","cb","_request","gist","_this2","then","response","data","_request204or404","_requestAllPages","revision","comment","body","_Gist","_User","_Issue","_Search","_RateLimit","_Repository","_Organization","_Team","_Markdown","_Project","arguments","undefined","__apiBase","__auth","_Gist2","default","user","_User2","organization","_Organization2","teamId","_Team2","repo","_Repository2","_getFullName","_Issue2","query","_Search2","_RateLimit2","_Markdown2","_Project2","fullname","Issue","repository","__repository","issueData","options","issue","milestone","milestoneData","labelData","label","Markdown","Organization","__name","requestOptions","_getOptionsWithDefaults","direction","username","AcceptHeader","Project","colId","position","listProjectColumns","_ref","Promise","all","map","column","cardsInColumns","cards","reduce","prev","_ref2","push","apply","_toConsumableArray","catch","err","cardId","column_id","RateLimit","_utf","_jsBase","_debug","log","_debug2","Repository","__fullname","__currentTree","branch","sha","ref","number","base","head","since","_dateToISO","until","path","treeSHA","content","postBody","_getContentObject","_utf2","encode","encoding","Buffer","toString","Blob","Base64","_typeof","JSON","stringify","baseTreeSHA","blobSHA","newTree","base_tree","tree","mode","type","baseSHA","parent","message","parents","commitSHA","force","raw","encodeURI","oldBranch","newBranch","_this3","getRef","object","createRef","_this4","getSha","deleteCommit","oldPath","newPath","_this5","oldSha","getTree","_ref2$data","createTree","_ref3","commit","_ref4","updateHead","_this6","filePath","shouldEncode","author","committer","methodHasNoBody","method","METHODS_WITH_NO_BODY","indexOf","getNextPage","linksHeader","links","split","nextUrl","link","search","match","callbackErrorOrThrow","error","hasOwnProperty","_object$response","status","statusText","_object$config","config","url","ResponseError","_axios","request","Requestable","token","password","__AcceptHeader","__authorizationHeader","newCacheBuster","Date","getTime","replace","headers","Content-Type","Accept","Authorization","visibility","affiliation","sort","per_page","date","toISOString","__getURL","__getRequestHeaders","queryParams","shouldUseDataAsParams","params","responseType","requestPromise","_axios2","keys","results","_results","thisGroup","Array","items","page","Search","defaults","__defaults","withOptions","forEach","prop","_search","Team","__teamId","owner","User","__user","endpoint","__getScopedUrl","before"],"mappings":"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","file":"GitHub.min.js","sourcesContent":["(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require==\"function\"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error(\"Cannot find module '\"+o+\"'\");throw f.code=\"MODULE_NOT_FOUND\",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require==\"function\"&&require;for(var o=0;o {\n this.__id = response.data.id;\n return response;\n });\n }\n\n /**\n * Delete a gist.\n * @see https://developer.github.com/v3/gists/#delete-a-gist\n * @param {Requestable.callback} [cb] - will receive true if the request succeeds\n * @return {Promise} - the Promise for the http request\n */\n delete(cb) {\n return this._request('DELETE', `/gists/${this.__id}`, null, cb);\n }\n\n /**\n * Fork a gist.\n * @see https://developer.github.com/v3/gists/#fork-a-gist\n * @param {Requestable.callback} [cb] - the function that will receive the gist\n * @return {Promise} - the Promise for the http request\n */\n fork(cb) {\n return this._request('POST', `/gists/${this.__id}/forks`, null, cb);\n }\n\n /**\n * Update a gist.\n * @see https://developer.github.com/v3/gists/#edit-a-gist\n * @param {Object} gist - the new data for the gist\n * @param {Requestable.callback} [cb] - the function that receives the API result\n * @return {Promise} - the Promise for the http request\n */\n update(gist, cb) {\n return this._request('PATCH', `/gists/${this.__id}`, gist, cb);\n }\n\n /**\n * Star a gist.\n * @see https://developer.github.com/v3/gists/#star-a-gist\n * @param {Requestable.callback} [cb] - will receive true if the request is successful\n * @return {Promise} - the Promise for the http request\n */\n star(cb) {\n return this._request('PUT', `/gists/${this.__id}/star`, null, cb);\n }\n\n /**\n * Unstar a gist.\n * @see https://developer.github.com/v3/gists/#unstar-a-gist\n * @param {Requestable.callback} [cb] - will receive true if the request is successful\n * @return {Promise} - the Promise for the http request\n */\n unstar(cb) {\n return this._request('DELETE', `/gists/${this.__id}/star`, null, cb);\n }\n\n /**\n * Check if a gist is starred by the user.\n * @see https://developer.github.com/v3/gists/#check-if-a-gist-is-starred\n * @param {Requestable.callback} [cb] - will receive true if the gist is starred and false if the gist is not starred\n * @return {Promise} - the Promise for the http request\n */\n isStarred(cb) {\n return this._request204or404(`/gists/${this.__id}/star`, null, cb);\n }\n\n /**\n * List the gist's commits\n * @see https://developer.github.com/v3/gists/#list-gist-commits\n * @param {Requestable.callback} [cb] - will receive the array of commits\n * @return {Promise} - the Promise for the http request\n */\n listCommits(cb) {\n return this._requestAllPages(`/gists/${this.__id}/commits`, null, cb);\n }\n\n /**\n * Fetch one of the gist's revision.\n * @see https://developer.github.com/v3/gists/#get-a-specific-revision-of-a-gist\n * @param {string} revision - the id of the revision\n * @param {Requestable.callback} [cb] - will receive the revision\n * @return {Promise} - the Promise for the http request\n */\n getRevision(revision, cb) {\n return this._request('GET', `/gists/${this.__id}/${revision}`, null, cb);\n }\n\n /**\n * List the gist's comments\n * @see https://developer.github.com/v3/gists/comments/#list-comments-on-a-gist\n * @param {Requestable.callback} [cb] - will receive the array of comments\n * @return {Promise} - the promise for the http request\n */\n listComments(cb) {\n return this._requestAllPages(`/gists/${this.__id}/comments`, null, cb);\n }\n\n /**\n * Fetch one of the gist's comments\n * @see https://developer.github.com/v3/gists/comments/#get-a-single-comment\n * @param {number} comment - the id of the comment\n * @param {Requestable.callback} [cb] - will receive the comment\n * @return {Promise} - the Promise for the http request\n */\n getComment(comment, cb) {\n return this._request('GET', `/gists/${this.__id}/comments/${comment}`, null, cb);\n }\n\n /**\n * Comment on a gist\n * @see https://developer.github.com/v3/gists/comments/#create-a-comment\n * @param {string} comment - the comment to add\n * @param {Requestable.callback} [cb] - the function that receives the API result\n * @return {Promise} - the Promise for the http request\n */\n createComment(comment, cb) {\n return this._request('POST', `/gists/${this.__id}/comments`, {body: comment}, cb);\n }\n\n /**\n * Edit a comment on the gist\n * @see https://developer.github.com/v3/gists/comments/#edit-a-comment\n * @param {number} comment - the id of the comment\n * @param {string} body - the new comment\n * @param {Requestable.callback} [cb] - will receive the modified comment\n * @return {Promise} - the promise for the http request\n */\n editComment(comment, body, cb) {\n return this._request('PATCH', `/gists/${this.__id}/comments/${comment}`, {body: body}, cb);\n }\n\n /**\n * Delete a comment on the gist.\n * @see https://developer.github.com/v3/gists/comments/#delete-a-comment\n * @param {number} comment - the id of the comment\n * @param {Requestable.callback} [cb] - will receive true if the request succeeds\n * @return {Promise} - the Promise for the http request\n */\n deleteComment(comment, cb) {\n return this._request('DELETE', `/gists/${this.__id}/comments/${comment}`, null, cb);\n }\n}\n\nmodule.exports = Gist;\n","/**\n * @file\n * @copyright 2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n * Github.js is freely distributable.\n */\n/* eslint valid-jsdoc: [\"error\", {\"requireReturnDescription\": false}] */\n\nimport Gist from './Gist';\nimport User from './User';\nimport Issue from './Issue';\nimport Search from './Search';\nimport RateLimit from './RateLimit';\nimport Repository from './Repository';\nimport Organization from './Organization';\nimport Team from './Team';\nimport Markdown from './Markdown';\nimport Project from './Project';\n\n/**\n * GitHub encapsulates the functionality to create various API wrapper objects.\n */\nclass GitHub {\n /**\n * Create a new GitHub.\n * @param {Requestable.auth} [auth] - the credentials to authenticate to Github. If auth is\n * not provided requests will be made unauthenticated\n * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n */\n constructor(auth, apiBase = 'https://api.github.com') {\n this.__apiBase = apiBase;\n this.__auth = auth || {};\n }\n\n /**\n * Create a new Gist wrapper\n * @param {number} [id] - the id for the gist, leave undefined when creating a new gist\n * @return {Gist}\n */\n getGist(id) {\n return new Gist(id, this.__auth, this.__apiBase);\n }\n\n /**\n * Create a new User wrapper\n * @param {string} [user] - the name of the user to get information about\n * leave undefined for the authenticated user\n * @return {User}\n */\n getUser(user) {\n return new User(user, this.__auth, this.__apiBase);\n }\n\n /**\n * Create a new Organization wrapper\n * @param {string} organization - the name of the organization\n * @return {Organization}\n */\n getOrganization(organization) {\n return new Organization(organization, this.__auth, this.__apiBase);\n }\n\n /**\n * create a new Team wrapper\n * @param {string} teamId - the name of the team\n * @return {team}\n */\n getTeam(teamId) {\n return new Team(teamId, this.__auth, this.__apiBase);\n }\n\n /**\n * Create a new Repository wrapper\n * @param {string} user - the user who owns the respository\n * @param {string} repo - the name of the repository\n * @return {Repository}\n */\n getRepo(user, repo) {\n return new Repository(this._getFullName(user, repo), this.__auth, this.__apiBase);\n }\n\n /**\n * Create a new Issue wrapper\n * @param {string} user - the user who owns the respository\n * @param {string} repo - the name of the repository\n * @return {Issue}\n */\n getIssues(user, repo) {\n return new Issue(this._getFullName(user, repo), this.__auth, this.__apiBase);\n }\n\n /**\n * Create a new Search wrapper\n * @param {string} query - the query to search for\n * @return {Search}\n */\n search(query) {\n return new Search(query, this.__auth, this.__apiBase);\n }\n\n /**\n * Create a new RateLimit wrapper\n * @return {RateLimit}\n */\n getRateLimit() {\n return new RateLimit(this.__auth, this.__apiBase);\n }\n\n /**\n * Create a new Markdown wrapper\n * @return {Markdown}\n */\n getMarkdown() {\n return new Markdown(this.__auth, this.__apiBase);\n }\n\n /**\n * Create a new Project wrapper\n * @param {string} id - the id of the project\n * @return {Markdown}\n */\n getProject(id) {\n return new Project(id, this.__auth, this.__apiBase);\n }\n\n /**\n * Computes the full repository name\n * @param {string} user - the username (or the full name)\n * @param {string} repo - the repository name, must not be passed if `user` is the full name\n * @return {string} the repository's full name\n */\n _getFullName(user, repo) {\n let fullname = user;\n\n if (repo) {\n fullname = `${user}/${repo}`;\n }\n\n return fullname;\n }\n}\n\nmodule.exports = GitHub;\n","/**\n * @file\n * @copyright 2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n * Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\n\n/**\n * Issue wraps the functionality to get issues for repositories\n */\nclass Issue extends Requestable {\n /**\n * Create a new Issue\n * @param {string} repository - the full name of the repository (`:user/:repo`) to get issues for\n * @param {Requestable.auth} [auth] - information required to authenticate to Github\n * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n */\n constructor(repository, auth, apiBase) {\n super(auth, apiBase);\n this.__repository = repository;\n }\n\n /**\n * Create a new issue\n * @see https://developer.github.com/v3/issues/#create-an-issue\n * @param {Object} issueData - the issue to create\n * @param {Requestable.callback} [cb] - will receive the created issue\n * @return {Promise} - the promise for the http request\n */\n createIssue(issueData, cb) {\n return this._request('POST', `/repos/${this.__repository}/issues`, issueData, cb);\n }\n\n /**\n * List the issues for the repository\n * @see https://developer.github.com/v3/issues/#list-issues-for-a-repository\n * @param {Object} options - filtering options\n * @param {Requestable.callback} [cb] - will receive the array of issues\n * @return {Promise} - the promise for the http request\n */\n listIssues(options, cb) {\n return this._requestAllPages(`/repos/${this.__repository}/issues`, options, cb);\n }\n\n /**\n * List the events for an issue\n * @see https://developer.github.com/v3/issues/events/#list-events-for-an-issue\n * @param {number} issue - the issue to get events for\n * @param {Requestable.callback} [cb] - will receive the list of events\n * @return {Promise} - the promise for the http request\n */\n listIssueEvents(issue, cb) {\n return this._request('GET', `/repos/${this.__repository}/issues/${issue}/events`, null, cb);\n }\n\n /**\n * List comments on an issue\n * @see https://developer.github.com/v3/issues/comments/#list-comments-on-an-issue\n * @param {number} issue - the id of the issue to get comments from\n * @param {Requestable.callback} [cb] - will receive the comments\n * @return {Promise} - the promise for the http request\n */\n listIssueComments(issue, cb) {\n return this._request('GET', `/repos/${this.__repository}/issues/${issue}/comments`, null, cb);\n }\n\n /**\n * Get a single comment on an issue\n * @see https://developer.github.com/v3/issues/comments/#get-a-single-comment\n * @param {number} id - the comment id to get\n * @param {Requestable.callback} [cb] - will receive the comment\n * @return {Promise} - the promise for the http request\n */\n getIssueComment(id, cb) {\n return this._request('GET', `/repos/${this.__repository}/issues/comments/${id}`, null, cb);\n }\n\n /**\n * Comment on an issue\n * @see https://developer.github.com/v3/issues/comments/#create-a-comment\n * @param {number} issue - the id of the issue to comment on\n * @param {string} comment - the comment to add\n * @param {Requestable.callback} [cb] - will receive the created comment\n * @return {Promise} - the promise for the http request\n */\n createIssueComment(issue, comment, cb) {\n return this._request('POST', `/repos/${this.__repository}/issues/${issue}/comments`, {body: comment}, cb);\n }\n\n /**\n * Edit a comment on an issue\n * @see https://developer.github.com/v3/issues/comments/#edit-a-comment\n * @param {number} id - the comment id to edit\n * @param {string} comment - the comment to edit\n * @param {Requestable.callback} [cb] - will receive the edited comment\n * @return {Promise} - the promise for the http request\n */\n editIssueComment(id, comment, cb) {\n return this._request('PATCH', `/repos/${this.__repository}/issues/comments/${id}`, {body: comment}, cb);\n }\n\n /**\n * Delete a comment on an issue\n * @see https://developer.github.com/v3/issues/comments/#delete-a-comment\n * @param {number} id - the comment id to delete\n * @param {Requestable.callback} [cb] - will receive true if the request is successful\n * @return {Promise} - the promise for the http request\n */\n deleteIssueComment(id, cb) {\n return this._request('DELETE', `/repos/${this.__repository}/issues/comments/${id}`, null, cb);\n }\n\n /**\n * Edit an issue\n * @see https://developer.github.com/v3/issues/#edit-an-issue\n * @param {number} issue - the issue number to edit\n * @param {Object} issueData - the new issue data\n * @param {Requestable.callback} [cb] - will receive the modified issue\n * @return {Promise} - the promise for the http request\n */\n editIssue(issue, issueData, cb) {\n return this._request('PATCH', `/repos/${this.__repository}/issues/${issue}`, issueData, cb);\n }\n\n /**\n * Get a particular issue\n * @see https://developer.github.com/v3/issues/#get-a-single-issue\n * @param {number} issue - the issue number to fetch\n * @param {Requestable.callback} [cb] - will receive the issue\n * @return {Promise} - the promise for the http request\n */\n getIssue(issue, cb) {\n return this._request('GET', `/repos/${this.__repository}/issues/${issue}`, null, cb);\n }\n\n /**\n * List the milestones for the repository\n * @see https://developer.github.com/v3/issues/milestones/#list-milestones-for-a-repository\n * @param {Object} options - filtering options\n * @param {Requestable.callback} [cb] - will receive the array of milestones\n * @return {Promise} - the promise for the http request\n */\n listMilestones(options, cb) {\n return this._request('GET', `/repos/${this.__repository}/milestones`, options, cb);\n }\n\n /**\n * Get a milestone\n * @see https://developer.github.com/v3/issues/milestones/#get-a-single-milestone\n * @param {string} milestone - the id of the milestone to fetch\n * @param {Requestable.callback} [cb] - will receive the milestone\n * @return {Promise} - the promise for the http request\n */\n getMilestone(milestone, cb) {\n return this._request('GET', `/repos/${this.__repository}/milestones/${milestone}`, null, cb);\n }\n\n /**\n * Create a new milestone\n * @see https://developer.github.com/v3/issues/milestones/#create-a-milestone\n * @param {Object} milestoneData - the milestone definition\n * @param {Requestable.callback} [cb] - will receive the milestone\n * @return {Promise} - the promise for the http request\n */\n createMilestone(milestoneData, cb) {\n return this._request('POST', `/repos/${this.__repository}/milestones`, milestoneData, cb);\n }\n\n /**\n * Edit a milestone\n * @see https://developer.github.com/v3/issues/milestones/#update-a-milestone\n * @param {string} milestone - the id of the milestone to edit\n * @param {Object} milestoneData - the updates to make to the milestone\n * @param {Requestable.callback} [cb] - will receive the updated milestone\n * @return {Promise} - the promise for the http request\n */\n editMilestone(milestone, milestoneData, cb) {\n return this._request('PATCH', `/repos/${this.__repository}/milestones/${milestone}`, milestoneData, cb);\n }\n\n /**\n * Delete a milestone (this is distinct from closing a milestone)\n * @see https://developer.github.com/v3/issues/milestones/#delete-a-milestone\n * @param {string} milestone - the id of the milestone to delete\n * @param {Requestable.callback} [cb] - will receive the status\n * @return {Promise} - the promise for the http request\n */\n deleteMilestone(milestone, cb) {\n return this._request('DELETE', `/repos/${this.__repository}/milestones/${milestone}`, null, cb);\n }\n\n /**\n * Create a new label\n * @see https://developer.github.com/v3/issues/labels/#create-a-label\n * @param {Object} labelData - the label definition\n * @param {Requestable.callback} [cb] - will receive the object representing the label\n * @return {Promise} - the promise for the http request\n */\n createLabel(labelData, cb) {\n return this._request('POST', `/repos/${this.__repository}/labels`, labelData, cb);\n }\n\n /**\n * List the labels for the repository\n * @see https://developer.github.com/v3/issues/labels/#list-all-labels-for-this-repository\n * @param {Object} options - filtering options\n * @param {Requestable.callback} [cb] - will receive the array of labels\n * @return {Promise} - the promise for the http request\n */\n listLabels(options, cb) {\n return this._request('GET', `/repos/${this.__repository}/labels`, options, cb);\n }\n\n /**\n * Get a label\n * @see https://developer.github.com/v3/issues/labels/#get-a-single-label\n * @param {string} label - the name of the label to fetch\n * @param {Requestable.callback} [cb] - will receive the label\n * @return {Promise} - the promise for the http request\n */\n getLabel(label, cb) {\n return this._request('GET', `/repos/${this.__repository}/labels/${label}`, null, cb);\n }\n\n /**\n * Edit a label\n * @see https://developer.github.com/v3/issues/labels/#update-a-label\n * @param {string} label - the name of the label to edit\n * @param {Object} labelData - the updates to make to the label\n * @param {Requestable.callback} [cb] - will receive the updated label\n * @return {Promise} - the promise for the http request\n */\n editLabel(label, labelData, cb) {\n return this._request('PATCH', `/repos/${this.__repository}/labels/${label}`, labelData, cb);\n }\n\n /**\n * Delete a label\n * @see https://developer.github.com/v3/issues/labels/#delete-a-label\n * @param {string} label - the name of the label to delete\n * @param {Requestable.callback} [cb] - will receive the status\n * @return {Promise} - the promise for the http request\n */\n deleteLabel(label, cb) {\n return this._request('DELETE', `/repos/${this.__repository}/labels/${label}`, null, cb);\n }\n}\n\nmodule.exports = Issue;\n","/**\n * @file\n * @copyright 2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n * Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\n\n/**\n * Renders html from Markdown text\n */\nclass Markdown extends Requestable {\n /**\n * construct a Markdown\n * @param {Requestable.auth} auth - the credentials to authenticate to GitHub\n * @param {string} [apiBase] - the base Github API URL\n * @return {Promise} - the promise for the http request\n */\n constructor(auth, apiBase) {\n super(auth, apiBase);\n }\n\n /**\n * Render html from Markdown text.\n * @see https://developer.github.com/v3/markdown/#render-an-arbitrary-markdown-document\n * @param {Object} options - conversion options\n * @param {string} [options.text] - the markdown text to convert\n * @param {string} [options.mode=markdown] - can be either `markdown` or `gfm`\n * @param {string} [options.context] - repository name if mode is gfm\n * @param {Requestable.callback} [cb] - will receive the converted html\n * @return {Promise} - the promise for the http request\n */\n render(options, cb) {\n return this._request('POST', '/markdown', options, cb);\n }\n}\n\nmodule.exports = Markdown;\n","/**\n * @file\n * @copyright 2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n * Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\n\n/**\n * Organization encapsulates the functionality to create repositories in organizations\n */\nclass Organization extends Requestable {\n /**\n * Create a new Organization\n * @param {string} organization - the name of the organization\n * @param {Requestable.auth} [auth] - information required to authenticate to Github\n * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n */\n constructor(organization, auth, apiBase) {\n super(auth, apiBase);\n this.__name = organization;\n }\n\n /**\n * Create a repository in an organization\n * @see https://developer.github.com/v3/repos/#create\n * @param {Object} options - the repository definition\n * @param {Requestable.callback} [cb] - will receive the created repository\n * @return {Promise} - the promise for the http request\n */\n createRepo(options, cb) {\n return this._request('POST', `/orgs/${this.__name}/repos`, options, cb);\n }\n\n /**\n * List the repositories in an organization\n * @see https://developer.github.com/v3/repos/#list-organization-repositories\n * @param {Requestable.callback} [cb] - will receive the list of repositories\n * @return {Promise} - the promise for the http request\n */\n getRepos(cb) {\n let requestOptions = this._getOptionsWithDefaults({direction: 'desc'});\n\n return this._requestAllPages(`/orgs/${this.__name}/repos`, requestOptions, cb);\n }\n\n /**\n * Query if the user is a member or not\n * @param {string} username - the user in question\n * @param {Requestable.callback} [cb] - will receive true if the user is a member\n * @return {Promise} - the promise for the http request\n */\n isMember(username, cb) {\n return this._request204or404(`/orgs/${this.__name}/members/${username}`, null, cb);\n }\n\n /**\n * List the users who are members of the company\n * @see https://developer.github.com/v3/orgs/members/#members-list\n * @param {object} options - filtering options\n * @param {string} [options.filter=all] - can be either `2fa_disabled` or `all`\n * @param {string} [options.role=all] - can be one of: `all`, `admin`, or `member`\n * @param {Requestable.callback} [cb] - will receive the list of users\n * @return {Promise} - the promise for the http request\n */\n listMembers(options, cb) {\n return this._request('GET', `/orgs/${this.__name}/members`, options, cb);\n }\n\n /**\n * List the Teams in the Organization\n * @see https://developer.github.com/v3/orgs/teams/#list-teams\n * @param {Requestable.callback} [cb] - will receive the list of teams\n * @return {Promise} - the promise for the http request\n */\n getTeams(cb) {\n return this._requestAllPages(`/orgs/${this.__name}/teams`, undefined, cb);\n }\n\n /**\n * Create a team\n * @see https://developer.github.com/v3/orgs/teams/#create-team\n * @param {object} options - Team creation parameters\n * @param {string} options.name - The name of the team\n * @param {string} [options.description] - Team description\n * @param {string} [options.repo_names] - Repos to add the team to\n * @param {string} [options.privacy=secret] - The level of privacy the team should have. Can be either one\n * of: `secret`, or `closed`\n * @param {Requestable.callback} [cb] - will receive the created team\n * @return {Promise} - the promise for the http request\n */\n createTeam(options, cb) {\n return this._request('POST', `/orgs/${this.__name}/teams`, options, cb);\n }\n\n /**\n * Get information about all projects\n * @see https://developer.github.com/v3/projects/#list-organization-projects\n * @param {Requestable.callback} [cb] - will receive the list of projects\n * @return {Promise} - the promise for the http request\n */\n listProjects(cb) {\n return this._requestAllPages(`/orgs/${this.__name}/projects`, {AcceptHeader: 'inertia-preview'}, cb);\n }\n\n /**\n * Create a new project\n * @see https://developer.github.com/v3/repos/projects/#create-a-project\n * @param {Object} options - the description of the project\n * @param {Requestable.callback} cb - will receive the newly created project\n * @return {Promise} - the promise for the http request\n */\n createProject(options, cb) {\n options = options || {};\n options.AcceptHeader = 'inertia-preview';\n return this._request('POST', `/orgs/${this.__name}/projects`, options, cb);\n }\n}\n\nmodule.exports = Organization;\n","/**\n * @file\n * @copyright 2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n * Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\n\n/**\n * Project encapsulates the functionality to create, query, and modify cards and columns.\n */\nclass Project extends Requestable {\n /**\n * Create a Project.\n * @param {string} id - the id of the project\n * @param {Requestable.auth} [auth] - information required to authenticate to Github\n * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n */\n constructor(id, auth, apiBase) {\n super(auth, apiBase, 'inertia-preview');\n this.__id = id;\n }\n\n /**\n * Get information about a project\n * @see https://developer.github.com/v3/projects/#get-a-project\n * @param {Requestable.callback} cb - will receive the project information\n * @return {Promise} - the promise for the http request\n */\n getProject(cb) {\n return this._request('GET', `/projects/${this.__id}`, null, cb);\n }\n\n /**\n * Edit a project\n * @see https://developer.github.com/v3/projects/#update-a-project\n * @param {Object} options - the description of the project\n * @param {Requestable.callback} cb - will receive the modified project\n * @return {Promise} - the promise for the http request\n */\n updateProject(options, cb) {\n return this._request('PATCH', `/projects/${this.__id}`, options, cb);\n }\n\n /**\n * Delete a project\n * @see https://developer.github.com/v3/projects/#delete-a-project\n * @param {Requestable.callback} cb - will receive true if the operation is successful\n * @return {Promise} - the promise for the http request\n */\n deleteProject(cb) {\n return this._request('DELETE', `/projects/${this.__id}`, null, cb);\n }\n\n /**\n * Get information about all columns of a project\n * @see https://developer.github.com/v3/projects/columns/#list-project-columns\n * @param {Requestable.callback} [cb] - will receive the list of columns\n * @return {Promise} - the promise for the http request\n */\n listProjectColumns(cb) {\n return this._requestAllPages(`/projects/${this.__id}/columns`, null, cb);\n }\n\n /**\n * Get information about a column\n * @see https://developer.github.com/v3/projects/columns/#get-a-project-column\n * @param {string} colId - the id of the column\n * @param {Requestable.callback} cb - will receive the column information\n * @return {Promise} - the promise for the http request\n */\n getProjectColumn(colId, cb) {\n return this._request('GET', `/projects/columns/${colId}`, null, cb);\n }\n\n /**\n * Create a new column\n * @see https://developer.github.com/v3/projects/columns/#create-a-project-column\n * @param {Object} options - the description of the column\n * @param {Requestable.callback} cb - will receive the newly created column\n * @return {Promise} - the promise for the http request\n */\n createProjectColumn(options, cb) {\n return this._request('POST', `/projects/${this.__id}/columns`, options, cb);\n }\n\n /**\n * Edit a column\n * @see https://developer.github.com/v3/projects/columns/#update-a-project-column\n * @param {string} colId - the column id\n * @param {Object} options - the description of the column\n * @param {Requestable.callback} cb - will receive the modified column\n * @return {Promise} - the promise for the http request\n */\n updateProjectColumn(colId, options, cb) {\n return this._request('PATCH', `/projects/columns/${colId}`, options, cb);\n }\n\n /**\n * Delete a column\n * @see https://developer.github.com/v3/projects/columns/#delete-a-project-column\n * @param {string} colId - the column to be deleted\n * @param {Requestable.callback} cb - will receive true if the operation is successful\n * @return {Promise} - the promise for the http request\n */\n deleteProjectColumn(colId, cb) {\n return this._request('DELETE', `/projects/columns/${colId}`, null, cb);\n }\n\n /**\n * Move a column\n * @see https://developer.github.com/v3/projects/columns/#move-a-project-column\n * @param {string} colId - the column to be moved\n * @param {string} position - can be one of first, last, or after:,\n * where is the id value of a column in the same project.\n * @param {Requestable.callback} cb - will receive true if the operation is successful\n * @return {Promise} - the promise for the http request\n */\n moveProjectColumn(colId, position, cb) {\n return this._request(\n 'POST',\n `/projects/columns/${colId}/moves`,\n {position: position},\n cb\n );\n }\n\n /**\n * Get information about all cards of a project\n * @see https://developer.github.com/v3/projects/cards/#list-project-cards\n * @param {Requestable.callback} [cb] - will receive the list of cards\n * @return {Promise} - the promise for the http request\n */\n listProjectCards(cb) {\n return this.listProjectColumns()\n .then(({data}) => {\n return Promise.all(data.map((column) => {\n return this._requestAllPages(`/projects/columns/${column.id}/cards`, null);\n }));\n }).then((cardsInColumns) => {\n const cards = cardsInColumns.reduce((prev, {data}) => {\n prev.push(...data);\n return prev;\n }, []);\n if (cb) {\n cb(null, cards);\n }\n return cards;\n }).catch((err) => {\n if (cb) {\n cb(err);\n return;\n }\n throw err;\n });\n }\n\n /**\n * Get information about all cards of a column\n * @see https://developer.github.com/v3/projects/cards/#list-project-cards\n * @param {string} colId - the id of the column\n * @param {Requestable.callback} [cb] - will receive the list of cards\n * @return {Promise} - the promise for the http request\n */\n listColumnCards(colId, cb) {\n return this._requestAllPages(`/projects/columns/${colId}/cards`, null, cb);\n }\n\n /**\n * Get information about a card\n * @see https://developer.github.com/v3/projects/cards/#get-a-project-card\n * @param {string} cardId - the id of the card\n * @param {Requestable.callback} cb - will receive the card information\n * @return {Promise} - the promise for the http request\n */\n getProjectCard(cardId, cb) {\n return this._request('GET', `/projects/columns/cards/${cardId}`, null, cb);\n }\n\n /**\n * Create a new card\n * @see https://developer.github.com/v3/projects/cards/#create-a-project-card\n * @param {string} colId - the column id\n * @param {Object} options - the description of the card\n * @param {Requestable.callback} cb - will receive the newly created card\n * @return {Promise} - the promise for the http request\n */\n createProjectCard(colId, options, cb) {\n return this._request('POST', `/projects/columns/${colId}/cards`, options, cb);\n }\n\n /**\n * Edit a card\n * @see https://developer.github.com/v3/projects/cards/#update-a-project-card\n * @param {string} cardId - the card id\n * @param {Object} options - the description of the card\n * @param {Requestable.callback} cb - will receive the modified card\n * @return {Promise} - the promise for the http request\n */\n updateProjectCard(cardId, options, cb) {\n return this._request('PATCH', `/projects/columns/cards/${cardId}`, options, cb);\n }\n\n /**\n * Delete a card\n * @see https://developer.github.com/v3/projects/cards/#delete-a-project-card\n * @param {string} cardId - the card to be deleted\n * @param {Requestable.callback} cb - will receive true if the operation is successful\n * @return {Promise} - the promise for the http request\n */\n deleteProjectCard(cardId, cb) {\n return this._request('DELETE', `/projects/columns/cards/${cardId}`, null, cb);\n }\n\n /**\n * Move a card\n * @see https://developer.github.com/v3/projects/cards/#move-a-project-card\n * @param {string} cardId - the card to be moved\n * @param {string} position - can be one of top, bottom, or after:,\n * where is the id value of a card in the same project.\n * @param {string} colId - the id value of a column in the same project.\n * @param {Requestable.callback} cb - will receive true if the operation is successful\n * @return {Promise} - the promise for the http request\n */\n moveProjectCard(cardId, position, colId, cb) {\n return this._request(\n 'POST',\n `/projects/columns/cards/${cardId}/moves`,\n {position: position, column_id: colId}, // eslint-disable-line camelcase\n cb\n );\n }\n}\n\nmodule.exports = Project;\n","/**\n * @file\n * @copyright 2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n * Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\n\n/**\n * RateLimit allows users to query their rate-limit status\n */\nclass RateLimit extends Requestable {\n /**\n * construct a RateLimit\n * @param {Requestable.auth} auth - the credentials to authenticate to GitHub\n * @param {string} [apiBase] - the base Github API URL\n * @return {Promise} - the promise for the http request\n */\n constructor(auth, apiBase) {\n super(auth, apiBase);\n }\n\n /**\n * Query the current rate limit\n * @see https://developer.github.com/v3/rate_limit/\n * @param {Requestable.callback} [cb] - will receive the rate-limit data\n * @return {Promise} - the promise for the http request\n */\n getRateLimit(cb) {\n return this._request('GET', '/rate_limit', null, cb);\n }\n}\n\nmodule.exports = RateLimit;\n","/**\n * @file\n * @copyright 2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n * Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\nimport Utf8 from 'utf8';\nimport {\n Base64,\n} from 'js-base64';\nimport debug from 'debug';\nconst log = debug('github:repository');\n\n/**\n * Respository encapsulates the functionality to create, query, and modify files.\n */\nclass Repository extends Requestable {\n /**\n * Create a Repository.\n * @param {string} fullname - the full name of the repository\n * @param {Requestable.auth} [auth] - information required to authenticate to Github\n * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n */\n constructor(fullname, auth, apiBase) {\n super(auth, apiBase);\n this.__fullname = fullname;\n this.__currentTree = {\n branch: null,\n sha: null,\n };\n }\n\n /**\n * Get a reference\n * @see https://developer.github.com/v3/git/refs/#get-a-reference\n * @param {string} ref - the reference to get\n * @param {Requestable.callback} [cb] - will receive the reference's refSpec or a list of refSpecs that match `ref`\n * @return {Promise} - the promise for the http request\n */\n getRef(ref, cb) {\n return this._request('GET', `/repos/${this.__fullname}/git/refs/${ref}`, null, cb);\n }\n\n /**\n * Create a reference\n * @see https://developer.github.com/v3/git/refs/#create-a-reference\n * @param {Object} options - the object describing the ref\n * @param {Requestable.callback} [cb] - will receive the ref\n * @return {Promise} - the promise for the http request\n */\n createRef(options, cb) {\n return this._request('POST', `/repos/${this.__fullname}/git/refs`, options, cb);\n }\n\n /**\n * Delete a reference\n * @see https://developer.github.com/v3/git/refs/#delete-a-reference\n * @param {string} ref - the name of the ref to delte\n * @param {Requestable.callback} [cb] - will receive true if the request is successful\n * @return {Promise} - the promise for the http request\n */\n deleteRef(ref, cb) {\n return this._request('DELETE', `/repos/${this.__fullname}/git/refs/${ref}`, null, cb);\n }\n\n /**\n * Delete a repository\n * @see https://developer.github.com/v3/repos/#delete-a-repository\n * @param {Requestable.callback} [cb] - will receive true if the request is successful\n * @return {Promise} - the promise for the http request\n */\n deleteRepo(cb) {\n return this._request('DELETE', `/repos/${this.__fullname}`, null, cb);\n }\n\n /**\n * List the tags on a repository\n * @see https://developer.github.com/v3/repos/#list-tags\n * @param {Requestable.callback} [cb] - will receive the tag data\n * @return {Promise} - the promise for the http request\n */\n listTags(cb) {\n return this._request('GET', `/repos/${this.__fullname}/tags`, null, cb);\n }\n\n /**\n * List the open pull requests on the repository\n * @see https://developer.github.com/v3/pulls/#list-pull-requests\n * @param {Object} options - options to filter the search\n * @param {Requestable.callback} [cb] - will receive the list of PRs\n * @return {Promise} - the promise for the http request\n */\n listPullRequests(options, cb) {\n options = options || {};\n return this._request('GET', `/repos/${this.__fullname}/pulls`, options, cb);\n }\n\n /**\n * Get information about a specific pull request\n * @see https://developer.github.com/v3/pulls/#get-a-single-pull-request\n * @param {number} number - the PR you wish to fetch\n * @param {Requestable.callback} [cb] - will receive the PR from the API\n * @return {Promise} - the promise for the http request\n */\n getPullRequest(number, cb) {\n return this._request('GET', `/repos/${this.__fullname}/pulls/${number}`, null, cb);\n }\n\n /**\n * List the files of a specific pull request\n * @see https://developer.github.com/v3/pulls/#list-pull-requests-files\n * @param {number|string} number - the PR you wish to fetch\n * @param {Requestable.callback} [cb] - will receive the list of files from the API\n * @return {Promise} - the promise for the http request\n */\n listPullRequestFiles(number, cb) {\n return this._request('GET', `/repos/${this.__fullname}/pulls/${number}/files`, null, cb);\n }\n\n /**\n * Compare two branches/commits/repositories\n * @see https://developer.github.com/v3/repos/commits/#compare-two-commits\n * @param {string} base - the base commit\n * @param {string} head - the head commit\n * @param {Requestable.callback} cb - will receive the comparison\n * @return {Promise} - the promise for the http request\n */\n compareBranches(base, head, cb) {\n return this._request('GET', `/repos/${this.__fullname}/compare/${base}...${head}`, null, cb);\n }\n\n /**\n * List all the branches for the repository\n * @see https://developer.github.com/v3/repos/#list-branches\n * @param {Requestable.callback} cb - will receive the list of branches\n * @return {Promise} - the promise for the http request\n */\n listBranches(cb) {\n return this._request('GET', `/repos/${this.__fullname}/branches`, null, cb);\n }\n\n /**\n * Get a raw blob from the repository\n * @see https://developer.github.com/v3/git/blobs/#get-a-blob\n * @param {string} sha - the sha of the blob to fetch\n * @param {Requestable.callback} cb - will receive the blob from the API\n * @return {Promise} - the promise for the http request\n */\n getBlob(sha, cb) {\n return this._request('GET', `/repos/${this.__fullname}/git/blobs/${sha}`, null, cb, 'raw');\n }\n\n /**\n * Get a single branch\n * @see https://developer.github.com/v3/repos/branches/#get-branch\n * @param {string} branch - the name of the branch to fetch\n * @param {Requestable.callback} cb - will receive the branch from the API\n * @returns {Promise} - the promise for the http request\n */\n getBranch(branch, cb) {\n return this._request('GET', `/repos/${this.__fullname}/branches/${branch}`, null, cb);\n }\n\n /**\n * Get a commit from the repository\n * @see https://developer.github.com/v3/repos/commits/#get-a-single-commit\n * @param {string} sha - the sha for the commit to fetch\n * @param {Requestable.callback} cb - will receive the commit data\n * @return {Promise} - the promise for the http request\n */\n getCommit(sha, cb) {\n return this._request('GET', `/repos/${this.__fullname}/git/commits/${sha}`, null, cb);\n }\n\n /**\n * List the commits on a repository, optionally filtering by path, author or time range\n * @see https://developer.github.com/v3/repos/commits/#list-commits-on-a-repository\n * @param {Object} [options] - the filtering options for commits\n * @param {string} [options.sha] - the SHA or branch to start from\n * @param {string} [options.path] - the path to search on\n * @param {string} [options.author] - the commit author\n * @param {(Date|string)} [options.since] - only commits after this date will be returned\n * @param {(Date|string)} [options.until] - only commits before this date will be returned\n * @param {Requestable.callback} cb - will receive the list of commits found matching the criteria\n * @return {Promise} - the promise for the http request\n */\n listCommits(options, cb) {\n options = options || {};\n\n options.since = this._dateToISO(options.since);\n options.until = this._dateToISO(options.until);\n\n return this._request('GET', `/repos/${this.__fullname}/commits`, options, cb);\n }\n\n /**\n * Gets a single commit information for a repository\n * @see https://developer.github.com/v3/repos/commits/#get-a-single-commit\n * @param {string} ref - the reference for the commit-ish\n * @param {Requestable.callback} cb - will receive the commit information\n * @return {Promise} - the promise for the http request\n */\n getSingleCommit(ref, cb) {\n ref = ref || '';\n return this._request('GET', `/repos/${this.__fullname}/commits/${ref}`, null, cb);\n }\n\n /**\n * Get tha sha for a particular object in the repository. This is a convenience function\n * @see https://developer.github.com/v3/repos/contents/#get-contents\n * @param {string} [branch] - the branch to look in, or the repository's default branch if omitted\n * @param {string} path - the path of the file or directory\n * @param {Requestable.callback} cb - will receive a description of the requested object, including a `SHA` property\n * @return {Promise} - the promise for the http request\n */\n getSha(branch, path, cb) {\n branch = branch ? `?ref=${branch}` : '';\n return this._request('GET', `/repos/${this.__fullname}/contents/${path}${branch}`, null, cb);\n }\n\n /**\n * List the commit statuses for a particular sha, branch, or tag\n * @see https://developer.github.com/v3/repos/statuses/#list-statuses-for-a-specific-ref\n * @param {string} sha - the sha, branch, or tag to get statuses for\n * @param {Requestable.callback} cb - will receive the list of statuses\n * @return {Promise} - the promise for the http request\n */\n listStatuses(sha, cb) {\n return this._request('GET', `/repos/${this.__fullname}/commits/${sha}/statuses`, null, cb);\n }\n\n /**\n * Get a description of a git tree\n * @see https://developer.github.com/v3/git/trees/#get-a-tree\n * @param {string} treeSHA - the SHA of the tree to fetch\n * @param {Requestable.callback} cb - will receive the callback data\n * @return {Promise} - the promise for the http request\n */\n getTree(treeSHA, cb) {\n return this._request('GET', `/repos/${this.__fullname}/git/trees/${treeSHA}`, null, cb);\n }\n\n /**\n * Create a blob\n * @see https://developer.github.com/v3/git/blobs/#create-a-blob\n * @param {(string|Buffer|Blob)} content - the content to add to the repository\n * @param {Requestable.callback} cb - will receive the details of the created blob\n * @return {Promise} - the promise for the http request\n */\n createBlob(content, cb) {\n let postBody = this._getContentObject(content);\n\n log('sending content', postBody);\n return this._request('POST', `/repos/${this.__fullname}/git/blobs`, postBody, cb);\n }\n\n /**\n * Get the object that represents the provided content\n * @param {string|Buffer|Blob} content - the content to send to the server\n * @return {Object} the representation of `content` for the GitHub API\n */\n _getContentObject(content) {\n if (typeof content === 'string') {\n log('contet is a string');\n return {\n content: Utf8.encode(content),\n encoding: 'utf-8',\n };\n\n } else if (typeof Buffer !== 'undefined' && content instanceof Buffer) {\n log('We appear to be in Node');\n return {\n content: content.toString('base64'),\n encoding: 'base64',\n };\n\n } else if (typeof Blob !== 'undefined' && content instanceof Blob) {\n log('We appear to be in the browser');\n return {\n content: Base64.encode(content),\n encoding: 'base64',\n };\n\n } else { // eslint-disable-line\n log(`Not sure what this content is: ${typeof content}, ${JSON.stringify(content)}`);\n throw new Error('Unknown content passed to postBlob. Must be string or Buffer (node) or Blob (web)');\n }\n }\n\n /**\n * Update a tree in Git\n * @see https://developer.github.com/v3/git/trees/#create-a-tree\n * @param {string} baseTreeSHA - the SHA of the tree to update\n * @param {string} path - the path for the new file\n * @param {string} blobSHA - the SHA for the blob to put at `path`\n * @param {Requestable.callback} cb - will receive the new tree that is created\n * @return {Promise} - the promise for the http request\n * @deprecated use {@link Repository#createTree} instead\n */\n updateTree(baseTreeSHA, path, blobSHA, cb) {\n let newTree = {\n base_tree: baseTreeSHA, // eslint-disable-line\n tree: [{\n path: path,\n sha: blobSHA,\n mode: '100644',\n type: 'blob',\n }],\n };\n\n return this._request('POST', `/repos/${this.__fullname}/git/trees`, newTree, cb);\n }\n\n /**\n * Create a new tree in git\n * @see https://developer.github.com/v3/git/trees/#create-a-tree\n * @param {Object} tree - the tree to create\n * @param {string} baseSHA - the root sha of the tree\n * @param {Requestable.callback} cb - will receive the new tree that is created\n * @return {Promise} - the promise for the http request\n */\n createTree(tree, baseSHA, cb) {\n return this._request('POST', `/repos/${this.__fullname}/git/trees`, {\n tree,\n base_tree: baseSHA, // eslint-disable-line camelcase\n }, cb);\n }\n\n /**\n * Add a commit to the repository\n * @see https://developer.github.com/v3/git/commits/#create-a-commit\n * @param {string} parent - the SHA of the parent commit\n * @param {string} tree - the SHA of the tree for this commit\n * @param {string} message - the commit message\n * @param {Requestable.callback} cb - will receive the commit that is created\n * @return {Promise} - the promise for the http request\n */\n commit(parent, tree, message, cb) {\n let data = {\n message,\n tree,\n parents: [parent],\n };\n\n return this._request('POST', `/repos/${this.__fullname}/git/commits`, data, cb)\n .then((response) => {\n this.__currentTree.sha = response.data.sha; // Update latest commit\n return response;\n });\n }\n\n /**\n * Update a ref\n * @see https://developer.github.com/v3/git/refs/#update-a-reference\n * @param {string} ref - the ref to update\n * @param {string} commitSHA - the SHA to point the reference to\n * @param {boolean} force - indicates whether to force or ensure a fast-forward update\n * @param {Requestable.callback} cb - will receive the updated ref back\n * @return {Promise} - the promise for the http request\n */\n updateHead(ref, commitSHA, force, cb) {\n return this._request('PATCH', `/repos/${this.__fullname}/git/refs/${ref}`, {\n sha: commitSHA,\n force: force,\n }, cb);\n }\n\n /**\n * Update commit status\n * @see https://developer.github.com/v3/repos/statuses/\n * @param {string} commitSHA - the SHA of the commit that should be updated\n * @param {object} options - Commit status parameters\n * @param {string} options.state - The state of the status. Can be one of: pending, success, error, or failure.\n * @param {string} [options.target_url] - The target URL to associate with this status.\n * @param {string} [options.description] - A short description of the status.\n * @param {string} [options.context] - A string label to differentiate this status among CI systems.\n * @param {Requestable.callback} cb - will receive the updated commit back\n * @return {Promise} - the promise for the http request\n */\n updateStatus(commitSHA, options, cb) {\n return this._request('POST', `/repos/${this.__fullname}/statuses/${commitSHA}`, options, cb);\n }\n\n /**\n * Update repository information\n * @see https://developer.github.com/v3/repos/#edit\n * @param {object} options - New parameters that will be set to the repository\n * @param {string} options.name - Name of the repository\n * @param {string} [options.description] - A short description of the repository\n * @param {string} [options.homepage] - A URL with more information about the repository\n * @param {boolean} [options.private] - Either true to make the repository private, or false to make it public.\n * @param {boolean} [options.has_issues] - Either true to enable issues for this repository, false to disable them.\n * @param {boolean} [options.has_wiki] - Either true to enable the wiki for this repository, false to disable it.\n * @param {boolean} [options.has_downloads] - Either true to enable downloads, false to disable them.\n * @param {string} [options.default_branch] - Updates the default branch for this repository.\n * @param {Requestable.callback} cb - will receive the updated repository back\n * @return {Promise} - the promise for the http request\n */\n updateRepository(options, cb) {\n return this._request('PATCH', `/repos/${this.__fullname}`, options, cb);\n }\n\n /**\n * Get information about the repository\n * @see https://developer.github.com/v3/repos/#get\n * @param {Requestable.callback} cb - will receive the information about the repository\n * @return {Promise} - the promise for the http request\n */\n getDetails(cb) {\n return this._request('GET', `/repos/${this.__fullname}`, null, cb);\n }\n\n /**\n * List the contributors to the repository\n * @see https://developer.github.com/v3/repos/#list-contributors\n * @param {Requestable.callback} cb - will receive the list of contributors\n * @return {Promise} - the promise for the http request\n */\n getContributors(cb) {\n return this._request('GET', `/repos/${this.__fullname}/contributors`, null, cb);\n }\n\n /**\n * List the contributor stats to the repository\n * @see https://developer.github.com/v3/repos/#list-contributors\n * @param {Requestable.callback} cb - will receive the list of contributors\n * @return {Promise} - the promise for the http request\n */\n getContributorStats(cb) {\n return this._request('GET', `/repos/${this.__fullname}/stats/contributors`, null, cb);\n }\n\n /**\n * List the users who are collaborators on the repository. The currently authenticated user must have\n * push access to use this method\n * @see https://developer.github.com/v3/repos/collaborators/#list-collaborators\n * @param {Requestable.callback} cb - will receive the list of collaborators\n * @return {Promise} - the promise for the http request\n */\n getCollaborators(cb) {\n return this._request('GET', `/repos/${this.__fullname}/collaborators`, null, cb);\n }\n\n /**\n * Check if a user is a collaborator on the repository\n * @see https://developer.github.com/v3/repos/collaborators/#check-if-a-user-is-a-collaborator\n * @param {string} username - the user to check\n * @param {Requestable.callback} cb - will receive true if the user is a collaborator and false if they are not\n * @return {Promise} - the promise for the http request {Boolean} [description]\n */\n isCollaborator(username, cb) {\n return this._request('GET', `/repos/${this.__fullname}/collaborators/${username}`, null, cb);\n }\n\n /**\n * Get the contents of a repository\n * @see https://developer.github.com/v3/repos/contents/#get-contents\n * @param {string} ref - the ref to check\n * @param {string} path - the path containing the content to fetch\n * @param {boolean} raw - `true` if the results should be returned raw instead of GitHub's normalized format\n * @param {Requestable.callback} cb - will receive the fetched data\n * @return {Promise} - the promise for the http request\n */\n getContents(ref, path, raw, cb) {\n path = path ? `${encodeURI(path)}` : '';\n return this._request('GET', `/repos/${this.__fullname}/contents/${path}`, {\n ref,\n }, cb, raw);\n }\n\n /**\n * Get the README of a repository\n * @see https://developer.github.com/v3/repos/contents/#get-the-readme\n * @param {string} ref - the ref to check\n * @param {boolean} raw - `true` if the results should be returned raw instead of GitHub's normalized format\n * @param {Requestable.callback} cb - will receive the fetched data\n * @return {Promise} - the promise for the http request\n */\n getReadme(ref, raw, cb) {\n return this._request('GET', `/repos/${this.__fullname}/readme`, {\n ref,\n }, cb, raw);\n }\n\n /**\n * Fork a repository\n * @see https://developer.github.com/v3/repos/forks/#create-a-fork\n * @param {Requestable.callback} cb - will receive the information about the newly created fork\n * @return {Promise} - the promise for the http request\n */\n fork(cb) {\n return this._request('POST', `/repos/${this.__fullname}/forks`, null, cb);\n }\n\n /**\n * List a repository's forks\n * @see https://developer.github.com/v3/repos/forks/#list-forks\n * @param {Requestable.callback} cb - will receive the list of repositories forked from this one\n * @return {Promise} - the promise for the http request\n */\n listForks(cb) {\n return this._request('GET', `/repos/${this.__fullname}/forks`, null, cb);\n }\n\n /**\n * Create a new branch from an existing branch.\n * @param {string} [oldBranch=master] - the name of the existing branch\n * @param {string} newBranch - the name of the new branch\n * @param {Requestable.callback} cb - will receive the commit data for the head of the new branch\n * @return {Promise} - the promise for the http request\n */\n createBranch(oldBranch, newBranch, cb) {\n if (typeof newBranch === 'function') {\n cb = newBranch;\n newBranch = oldBranch;\n oldBranch = 'master';\n }\n\n return this.getRef(`heads/${oldBranch}`)\n .then((response) => {\n let sha = response.data.object.sha;\n return this.createRef({\n sha,\n ref: `refs/heads/${newBranch}`,\n }, cb);\n });\n }\n\n /**\n * Create a new pull request\n * @see https://developer.github.com/v3/pulls/#create-a-pull-request\n * @param {Object} options - the pull request description\n * @param {Requestable.callback} cb - will receive the new pull request\n * @return {Promise} - the promise for the http request\n */\n createPullRequest(options, cb) {\n return this._request('POST', `/repos/${this.__fullname}/pulls`, options, cb);\n }\n\n /**\n * Update a pull request\n * @see https://developer.github.com/v3/pulls/#update-a-pull-request\n * @param {number|string} number - the number of the pull request to update\n * @param {Object} options - the pull request description\n * @param {Requestable.callback} [cb] - will receive the pull request information\n * @return {Promise} - the promise for the http request\n */\n updatePullRequest(number, options, cb) {\n return this._request('PATCH', `/repos/${this.__fullname}/pulls/${number}`, options, cb);\n }\n\n /**\n * List the hooks for the repository\n * @see https://developer.github.com/v3/repos/hooks/#list-hooks\n * @param {Requestable.callback} cb - will receive the list of hooks\n * @return {Promise} - the promise for the http request\n */\n listHooks(cb) {\n return this._request('GET', `/repos/${this.__fullname}/hooks`, null, cb);\n }\n\n /**\n * Get a hook for the repository\n * @see https://developer.github.com/v3/repos/hooks/#get-single-hook\n * @param {number} id - the id of the webook\n * @param {Requestable.callback} cb - will receive the details of the webook\n * @return {Promise} - the promise for the http request\n */\n getHook(id, cb) {\n return this._request('GET', `/repos/${this.__fullname}/hooks/${id}`, null, cb);\n }\n\n /**\n * Add a new hook to the repository\n * @see https://developer.github.com/v3/repos/hooks/#create-a-hook\n * @param {Object} options - the configuration describing the new hook\n * @param {Requestable.callback} cb - will receive the new webhook\n * @return {Promise} - the promise for the http request\n */\n createHook(options, cb) {\n return this._request('POST', `/repos/${this.__fullname}/hooks`, options, cb);\n }\n\n /**\n * Edit an existing webhook\n * @see https://developer.github.com/v3/repos/hooks/#edit-a-hook\n * @param {number} id - the id of the webhook\n * @param {Object} options - the new description of the webhook\n * @param {Requestable.callback} cb - will receive the updated webhook\n * @return {Promise} - the promise for the http request\n */\n updateHook(id, options, cb) {\n return this._request('PATCH', `/repos/${this.__fullname}/hooks/${id}`, options, cb);\n }\n\n /**\n * Delete a webhook\n * @see https://developer.github.com/v3/repos/hooks/#delete-a-hook\n * @param {number} id - the id of the webhook to be deleted\n * @param {Requestable.callback} cb - will receive true if the call is successful\n * @return {Promise} - the promise for the http request\n */\n deleteHook(id, cb) {\n return this._request('DELETE', `/repos/${this.__fullname}/hooks/${id}`, null, cb);\n }\n\n /**\n * List the deploy keys for the repository\n * @see https://developer.github.com/v3/repos/keys/#list-deploy-keys\n * @param {Requestable.callback} cb - will receive the list of deploy keys\n * @return {Promise} - the promise for the http request\n */\n listKeys(cb) {\n return this._request('GET', `/repos/${this.__fullname}/keys`, null, cb);\n }\n\n /**\n * Get a deploy key for the repository\n * @see https://developer.github.com/v3/repos/keys/#get-a-deploy-key\n * @param {number} id - the id of the deploy key\n * @param {Requestable.callback} cb - will receive the details of the deploy key\n * @return {Promise} - the promise for the http request\n */\n getKey(id, cb) {\n return this._request('GET', `/repos/${this.__fullname}/keys/${id}`, null, cb);\n }\n\n /**\n * Add a new deploy key to the repository\n * @see https://developer.github.com/v3/repos/keys/#add-a-new-deploy-key\n * @param {Object} options - the configuration describing the new deploy key\n * @param {Requestable.callback} cb - will receive the new deploy key\n * @return {Promise} - the promise for the http request\n */\n createKey(options, cb) {\n return this._request('POST', `/repos/${this.__fullname}/keys`, options, cb);\n }\n\n /**\n * Delete a deploy key\n * @see https://developer.github.com/v3/repos/keys/#remove-a-deploy-key\n * @param {number} id - the id of the deploy key to be deleted\n * @param {Requestable.callback} cb - will receive true if the call is successful\n * @return {Promise} - the promise for the http request\n */\n deleteKey(id, cb) {\n return this._request('DELETE', `/repos/${this.__fullname}/keys/${id}`, null, cb);\n }\n\n /**\n * Delete a file from a branch\n * @see https://developer.github.com/v3/repos/contents/#delete-a-file\n * @param {string} branch - the branch to delete from, or the default branch if not specified\n * @param {string} path - the path of the file to remove\n * @param {Requestable.callback} cb - will receive the commit in which the delete occurred\n * @return {Promise} - the promise for the http request\n */\n deleteFile(branch, path, cb) {\n return this.getSha(branch, path)\n .then((response) => {\n const deleteCommit = {\n message: `Delete the file at '${path}'`,\n sha: response.data.sha,\n branch,\n };\n return this._request('DELETE', `/repos/${this.__fullname}/contents/${path}`, deleteCommit, cb);\n });\n }\n\n /**\n * Change all references in a repo from oldPath to new_path\n * @param {string} branch - the branch to carry out the reference change, or the default branch if not specified\n * @param {string} oldPath - original path\n * @param {string} newPath - new reference path\n * @param {Requestable.callback} cb - will receive the commit in which the move occurred\n * @return {Promise} - the promise for the http request\n */\n move(branch, oldPath, newPath, cb) {\n let oldSha;\n return this.getRef(`heads/${branch}`)\n .then(({data: {object}}) => this.getTree(`${object.sha}?recursive=true`))\n .then(({data: {tree, sha}}) => {\n oldSha = sha;\n let newTree = tree.map((ref) => {\n if (ref.path === oldPath) {\n ref.path = newPath;\n }\n if (ref.type === 'tree') {\n delete ref.sha;\n }\n return ref;\n });\n return this.createTree(newTree);\n })\n .then(({data: tree}) => this.commit(oldSha, tree.sha, `Renamed '${oldPath}' to '${newPath}'`))\n .then(({data: commit}) => this.updateHead(`heads/${branch}`, commit.sha, true, cb));\n }\n\n /**\n * Write a file to the repository\n * @see https://developer.github.com/v3/repos/contents/#update-a-file\n * @param {string} branch - the name of the branch\n * @param {string} path - the path for the file\n * @param {string} content - the contents of the file\n * @param {string} message - the commit message\n * @param {Object} [options] - commit options\n * @param {Object} [options.author] - the author of the commit\n * @param {Object} [options.commiter] - the committer\n * @param {boolean} [options.encode] - true if the content should be base64 encoded\n * @param {Requestable.callback} cb - will receive the new commit\n * @return {Promise} - the promise for the http request\n */\n writeFile(branch, path, content, message, options, cb) {\n if (typeof options === 'function') {\n cb = options;\n options = {};\n }\n let filePath = path ? encodeURI(path) : '';\n let shouldEncode = options.encode !== false;\n let commit = {\n branch,\n message,\n author: options.author,\n committer: options.committer,\n content: shouldEncode ? Base64.encode(content) : content,\n };\n\n return this.getSha(branch, filePath)\n .then((response) => {\n commit.sha = response.data.sha;\n return this._request('PUT', `/repos/${this.__fullname}/contents/${filePath}`, commit, cb);\n }, () => {\n return this._request('PUT', `/repos/${this.__fullname}/contents/${filePath}`, commit, cb);\n });\n }\n\n /**\n * Check if a repository is starred by you\n * @see https://developer.github.com/v3/activity/starring/#check-if-you-are-starring-a-repository\n * @param {Requestable.callback} cb - will receive true if the repository is starred and false if the repository\n * is not starred\n * @return {Promise} - the promise for the http request {Boolean} [description]\n */\n isStarred(cb) {\n return this._request204or404(`/user/starred/${this.__fullname}`, null, cb);\n }\n\n /**\n * Star a repository\n * @see https://developer.github.com/v3/activity/starring/#star-a-repository\n * @param {Requestable.callback} cb - will receive true if the repository is starred\n * @return {Promise} - the promise for the http request\n */\n star(cb) {\n return this._request('PUT', `/user/starred/${this.__fullname}`, null, cb);\n }\n\n /**\n * Unstar a repository\n * @see https://developer.github.com/v3/activity/starring/#unstar-a-repository\n * @param {Requestable.callback} cb - will receive true if the repository is unstarred\n * @return {Promise} - the promise for the http request\n */\n unstar(cb) {\n return this._request('DELETE', `/user/starred/${this.__fullname}`, null, cb);\n }\n\n /**\n * Create a new release\n * @see https://developer.github.com/v3/repos/releases/#create-a-release\n * @param {Object} options - the description of the release\n * @param {Requestable.callback} cb - will receive the newly created release\n * @return {Promise} - the promise for the http request\n */\n createRelease(options, cb) {\n return this._request('POST', `/repos/${this.__fullname}/releases`, options, cb);\n }\n\n /**\n * Edit a release\n * @see https://developer.github.com/v3/repos/releases/#edit-a-release\n * @param {string} id - the id of the release\n * @param {Object} options - the description of the release\n * @param {Requestable.callback} cb - will receive the modified release\n * @return {Promise} - the promise for the http request\n */\n updateRelease(id, options, cb) {\n return this._request('PATCH', `/repos/${this.__fullname}/releases/${id}`, options, cb);\n }\n\n /**\n * Get information about all releases\n * @see https://developer.github.com/v3/repos/releases/#list-releases-for-a-repository\n * @param {Requestable.callback} cb - will receive the release information\n * @return {Promise} - the promise for the http request\n */\n listReleases(cb) {\n return this._request('GET', `/repos/${this.__fullname}/releases`, null, cb);\n }\n\n /**\n * Get information about a release\n * @see https://developer.github.com/v3/repos/releases/#get-a-single-release\n * @param {string} id - the id of the release\n * @param {Requestable.callback} cb - will receive the release information\n * @return {Promise} - the promise for the http request\n */\n getRelease(id, cb) {\n return this._request('GET', `/repos/${this.__fullname}/releases/${id}`, null, cb);\n }\n\n /**\n * Delete a release\n * @see https://developer.github.com/v3/repos/releases/#delete-a-release\n * @param {string} id - the release to be deleted\n * @param {Requestable.callback} cb - will receive true if the operation is successful\n * @return {Promise} - the promise for the http request\n */\n deleteRelease(id, cb) {\n return this._request('DELETE', `/repos/${this.__fullname}/releases/${id}`, null, cb);\n }\n\n /**\n * Merge a pull request\n * @see https://developer.github.com/v3/pulls/#merge-a-pull-request-merge-button\n * @param {number|string} number - the number of the pull request to merge\n * @param {Object} options - the merge options for the pull request\n * @param {Requestable.callback} [cb] - will receive the merge information if the operation is successful\n * @return {Promise} - the promise for the http request\n */\n mergePullRequest(number, options, cb) {\n return this._request('PUT', `/repos/${this.__fullname}/pulls/${number}/merge`, options, cb);\n }\n\n /**\n * Get information about all projects\n * @see https://developer.github.com/v3/projects/#list-repository-projects\n * @param {Requestable.callback} [cb] - will receive the list of projects\n * @return {Promise} - the promise for the http request\n */\n listProjects(cb) {\n return this._requestAllPages(`/repos/${this.__fullname}/projects`, {AcceptHeader: 'inertia-preview'}, cb);\n }\n\n /**\n * Create a new project\n * @see https://developer.github.com/v3/projects/#create-a-repository-project\n * @param {Object} options - the description of the project\n * @param {Requestable.callback} cb - will receive the newly created project\n * @return {Promise} - the promise for the http request\n */\n createProject(options, cb) {\n options = options || {};\n options.AcceptHeader = 'inertia-preview';\n return this._request('POST', `/repos/${this.__fullname}/projects`, options, cb);\n }\n\n}\n\nmodule.exports = Repository;\n","/**\n * @file\n * @copyright 2016 Yahoo Inc.\n * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n * Github.js is freely distributable.\n */\n\nimport axios from 'axios';\nimport debug from 'debug';\nimport {Base64} from 'js-base64';\n\nconst log = debug('github:request');\n\n/**\n * The error structure returned when a network call fails\n */\nclass ResponseError extends Error {\n /**\n * Construct a new ResponseError\n * @param {string} message - an message to return instead of the the default error message\n * @param {string} path - the requested path\n * @param {Object} response - the object returned by Axios\n */\n constructor(message, path, response) {\n super(message);\n this.path = path;\n this.request = response.config;\n this.response = (response || {}).response || response;\n this.status = response.status;\n }\n}\n\n/**\n * Requestable wraps the logic for making http requests to the API\n */\nclass Requestable {\n /**\n * Either a username and password or an oauth token for Github\n * @typedef {Object} Requestable.auth\n * @prop {string} [username] - the Github username\n * @prop {string} [password] - the user's password\n * @prop {token} [token] - an OAuth token\n */\n /**\n * Initialize the http internals.\n * @param {Requestable.auth} [auth] - the credentials to authenticate to Github. If auth is\n * not provided request will be made unauthenticated\n * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n * @param {string} [AcceptHeader=v3] - the accept header for the requests\n */\n constructor(auth, apiBase, AcceptHeader) {\n this.__apiBase = apiBase || 'https://api.github.com';\n this.__auth = {\n token: auth.token,\n username: auth.username,\n password: auth.password,\n };\n this.__AcceptHeader = AcceptHeader || 'v3';\n\n if (auth.token) {\n this.__authorizationHeader = 'token ' + auth.token;\n } else if (auth.username && auth.password) {\n this.__authorizationHeader = 'Basic ' + Base64.encode(auth.username + ':' + auth.password);\n }\n }\n\n /**\n * Compute the URL to use to make a request.\n * @private\n * @param {string} path - either a URL relative to the API base or an absolute URL\n * @return {string} - the URL to use\n */\n __getURL(path) {\n let url = path;\n\n if (path.indexOf('//') === -1) {\n url = this.__apiBase + path;\n }\n\n let newCacheBuster = 'timestamp=' + new Date().getTime();\n return url.replace(/(timestamp=\\d+)/, newCacheBuster);\n }\n\n /**\n * Compute the headers required for an API request.\n * @private\n * @param {boolean} raw - if the request should be treated as JSON or as a raw request\n * @param {string} AcceptHeader - the accept header for the request\n * @return {Object} - the headers to use in the request\n */\n __getRequestHeaders(raw, AcceptHeader) {\n let headers = {\n 'Content-Type': 'application/json;charset=UTF-8',\n 'Accept': 'application/vnd.github.' + (AcceptHeader || this.__AcceptHeader),\n };\n\n if (raw) {\n headers.Accept += '.raw';\n }\n headers.Accept += '+json';\n\n if (this.__authorizationHeader) {\n headers.Authorization = this.__authorizationHeader;\n }\n\n return headers;\n }\n\n /**\n * Sets the default options for API requests\n * @protected\n * @param {Object} [requestOptions={}] - the current options for the request\n * @return {Object} - the options to pass to the request\n */\n _getOptionsWithDefaults(requestOptions = {}) {\n if (!(requestOptions.visibility || requestOptions.affiliation)) {\n requestOptions.type = requestOptions.type || 'all';\n }\n requestOptions.sort = requestOptions.sort || 'updated';\n requestOptions.per_page = requestOptions.per_page || '100'; // eslint-disable-line\n\n return requestOptions;\n }\n\n /**\n * if a `Date` is passed to this function it will be converted to an ISO string\n * @param {*} date - the object to attempt to cooerce into an ISO date string\n * @return {string} - the ISO representation of `date` or whatever was passed in if it was not a date\n */\n _dateToISO(date) {\n if (date && (date instanceof Date)) {\n date = date.toISOString();\n }\n\n return date;\n }\n\n /**\n * A function that receives the result of the API request.\n * @callback Requestable.callback\n * @param {Requestable.Error} error - the error returned by the API or `null`\n * @param {(Object|true)} result - the data returned by the API or `true` if the API returns `204 No Content`\n * @param {Object} request - the raw {@linkcode https://github.com/mzabriskie/axios#response-schema Response}\n */\n /**\n * Make a request.\n * @param {string} method - the method for the request (GET, PUT, POST, DELETE)\n * @param {string} path - the path for the request\n * @param {*} [data] - the data to send to the server. For HTTP methods that don't have a body the data\n * will be sent as query parameters\n * @param {Requestable.callback} [cb] - the callback for the request\n * @param {boolean} [raw=false] - if the request should be sent as raw. If this is a falsy value then the\n * request will be made as JSON\n * @return {Promise} - the Promise for the http request\n */\n _request(method, path, data, cb, raw) {\n const url = this.__getURL(path);\n\n const AcceptHeader = (data || {}).AcceptHeader;\n if (AcceptHeader) {\n delete data.AcceptHeader;\n }\n const headers = this.__getRequestHeaders(raw, AcceptHeader);\n\n let queryParams = {};\n\n const shouldUseDataAsParams = data && (typeof data === 'object') && methodHasNoBody(method);\n if (shouldUseDataAsParams) {\n queryParams = data;\n data = undefined;\n }\n\n const config = {\n url: url,\n method: method,\n headers: headers,\n params: queryParams,\n data: data,\n responseType: raw ? 'text' : 'json',\n };\n\n log(`${config.method} to ${config.url}`);\n const requestPromise = axios(config).catch(callbackErrorOrThrow(cb, path));\n\n if (cb) {\n requestPromise.then((response) => {\n if (response.data && Object.keys(response.data).length > 0) {\n // When data has results\n cb(null, response.data, response);\n } else if (config.method !== 'GET' && Object.keys(response.data).length < 1) {\n // True when successful submit a request and receive a empty object\n cb(null, (response.status < 300), response);\n } else {\n cb(null, response.data, response);\n }\n });\n }\n\n return requestPromise;\n }\n\n /**\n * Make a request to an endpoint the returns 204 when true and 404 when false\n * @param {string} path - the path to request\n * @param {Object} data - any query parameters for the request\n * @param {Requestable.callback} cb - the callback that will receive `true` or `false`\n * @param {method} [method=GET] - HTTP Method to use\n * @return {Promise} - the promise for the http request\n */\n _request204or404(path, data, cb, method = 'GET') {\n return this._request(method, path, data)\n .then(function success(response) {\n if (cb) {\n cb(null, true, response);\n }\n return true;\n }, function failure(response) {\n if (response.response.status === 404) {\n if (cb) {\n cb(null, false, response);\n }\n return false;\n }\n\n if (cb) {\n cb(response);\n }\n throw response;\n });\n }\n\n /**\n * Make a request and fetch all the available data. Github will paginate responses so for queries\n * that might span multiple pages this method is preferred to {@link Requestable#request}\n * @param {string} path - the path to request\n * @param {Object} options - the query parameters to include\n * @param {Requestable.callback} [cb] - the function to receive the data. The returned data will always be an array.\n * @param {Object[]} results - the partial results. This argument is intended for interal use only.\n * @return {Promise} - a promise which will resolve when all pages have been fetched\n * @deprecated This will be folded into {@link Requestable#_request} in the 2.0 release.\n */\n _requestAllPages(path, options, cb, results) {\n results = results || [];\n\n return this._request('GET', path, options)\n .then((response) => {\n let thisGroup;\n if (response.data instanceof Array) {\n thisGroup = response.data;\n } else if (response.data.items instanceof Array) {\n thisGroup = response.data.items;\n } else {\n let message = `cannot figure out how to append ${response.data} to the result set`;\n throw new ResponseError(message, path, response);\n }\n results.push(...thisGroup);\n\n const nextUrl = getNextPage(response.headers.link);\n if (nextUrl && typeof options.page !== 'number') {\n log(`getting next page: ${nextUrl}`);\n return this._requestAllPages(nextUrl, options, cb, results);\n }\n\n if (cb) {\n cb(null, results, response);\n }\n\n response.data = results;\n return response;\n }).catch(callbackErrorOrThrow(cb, path));\n }\n}\n\nmodule.exports = Requestable;\n\n// ////////////////////////// //\n// Private helper functions //\n// ////////////////////////// //\nconst METHODS_WITH_NO_BODY = ['GET', 'HEAD', 'DELETE'];\nfunction methodHasNoBody(method) {\n return METHODS_WITH_NO_BODY.indexOf(method) !== -1;\n}\n\nfunction getNextPage(linksHeader = '') {\n const links = linksHeader.split(/\\s*,\\s*/); // splits and strips the urls\n return links.reduce(function(nextUrl, link) {\n if (link.search(/rel=\"next\"/) !== -1) {\n return (link.match(/<(.*)>/) || [])[1];\n }\n\n return nextUrl;\n }, undefined);\n}\n\nfunction callbackErrorOrThrow(cb, path) {\n return function handler(object) {\n let error;\n if (object.hasOwnProperty('config')) {\n const {response: {status, statusText}, config: {method, url}} = object;\n let message = (`${status} error making request ${method} ${url}: \"${statusText}\"`);\n error = new ResponseError(message, path, object);\n log(`${message} ${JSON.stringify(object.data)}`);\n } else {\n error = object;\n }\n if (cb) {\n log('going to error callback');\n cb(error);\n } else {\n log('throwing error');\n throw error;\n }\n };\n}\n","/**\n * @file\n * @copyright 2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n * Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\nimport debug from 'debug';\nconst log = debug('github:search');\n\n/**\n * Wrap the Search API\n */\nclass Search extends Requestable {\n /**\n * Create a Search\n * @param {Object} defaults - defaults for the search\n * @param {Requestable.auth} [auth] - information required to authenticate to Github\n * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n */\n constructor(defaults, auth, apiBase) {\n super(auth, apiBase);\n this.__defaults = this._getOptionsWithDefaults(defaults);\n }\n\n /**\n * Available search options\n * @see https://developer.github.com/v3/search/#parameters\n * @typedef {Object} Search.Params\n * @param {string} q - the query to make\n * @param {string} sort - the sort field, one of `stars`, `forks`, or `updated`.\n * Default is [best match](https://developer.github.com/v3/search/#ranking-search-results)\n * @param {string} order - the ordering, either `asc` or `desc`\n */\n /**\n * Perform a search on the GitHub API\n * @private\n * @param {string} path - the scope of the search\n * @param {Search.Params} [withOptions] - additional parameters for the search\n * @param {Requestable.callback} [cb] - will receive the results of the search\n * @return {Promise} - the promise for the http request\n */\n _search(path, withOptions = {}, cb = undefined) {\n let requestOptions = {};\n Object.keys(this.__defaults).forEach((prop) => {\n requestOptions[prop] = this.__defaults[prop];\n });\n Object.keys(withOptions).forEach((prop) => {\n requestOptions[prop] = withOptions[prop];\n });\n\n log(`searching ${path} with options:`, requestOptions);\n return this._requestAllPages(`/search/${path}`, requestOptions, cb);\n }\n\n /**\n * Search for repositories\n * @see https://developer.github.com/v3/search/#search-repositories\n * @param {Search.Params} [options] - additional parameters for the search\n * @param {Requestable.callback} [cb] - will receive the results of the search\n * @return {Promise} - the promise for the http request\n */\n forRepositories(options, cb) {\n return this._search('repositories', options, cb);\n }\n\n /**\n * Search for code\n * @see https://developer.github.com/v3/search/#search-code\n * @param {Search.Params} [options] - additional parameters for the search\n * @param {Requestable.callback} [cb] - will receive the results of the search\n * @return {Promise} - the promise for the http request\n */\n forCode(options, cb) {\n return this._search('code', options, cb);\n }\n\n /**\n * Search for issues\n * @see https://developer.github.com/v3/search/#search-issues\n * @param {Search.Params} [options] - additional parameters for the search\n * @param {Requestable.callback} [cb] - will receive the results of the search\n * @return {Promise} - the promise for the http request\n */\n forIssues(options, cb) {\n return this._search('issues', options, cb);\n }\n\n /**\n * Search for users\n * @see https://developer.github.com/v3/search/#search-users\n * @param {Search.Params} [options] - additional parameters for the search\n * @param {Requestable.callback} [cb] - will receive the results of the search\n * @return {Promise} - the promise for the http request\n */\n forUsers(options, cb) {\n return this._search('users', options, cb);\n }\n}\n\nmodule.exports = Search;\n","/**\n * @file\n * @copyright 2016 Matt Smith (Development Seed)\n * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n * Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\nimport debug from 'debug';\nconst log = debug('github:team');\n\n/**\n * A Team allows scoping of API requests to a particular Github Organization Team.\n */\nclass Team extends Requestable {\n /**\n * Create a Team.\n * @param {string} [teamId] - the id for the team\n * @param {Requestable.auth} [auth] - information required to authenticate to Github\n * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n */\n constructor(teamId, auth, apiBase) {\n super(auth, apiBase);\n this.__teamId = teamId;\n }\n\n /**\n * Get Team information\n * @see https://developer.github.com/v3/orgs/teams/#get-team\n * @param {Requestable.callback} [cb] - will receive the team\n * @return {Promise} - the promise for the http request\n */\n getTeam(cb) {\n log(`Fetching Team ${this.__teamId}`);\n return this._request('Get', `/teams/${this.__teamId}`, undefined, cb);\n }\n\n /**\n * List the Team's repositories\n * @see https://developer.github.com/v3/orgs/teams/#list-team-repos\n * @param {Requestable.callback} [cb] - will receive the list of repositories\n * @return {Promise} - the promise for the http request\n */\n listRepos(cb) {\n log(`Fetching repositories for Team ${this.__teamId}`);\n return this._requestAllPages(`/teams/${this.__teamId}/repos`, undefined, cb);\n }\n\n /**\n * Edit Team information\n * @see https://developer.github.com/v3/orgs/teams/#edit-team\n * @param {object} options - Parameters for team edit\n * @param {string} options.name - The name of the team\n * @param {string} [options.description] - Team description\n * @param {string} [options.repo_names] - Repos to add the team to\n * @param {string} [options.privacy=secret] - The level of privacy the team should have. Can be either one\n * of: `secret`, or `closed`\n * @param {Requestable.callback} [cb] - will receive the updated team\n * @return {Promise} - the promise for the http request\n */\n editTeam(options, cb) {\n log(`Editing Team ${this.__teamId}`);\n return this._request('PATCH', `/teams/${this.__teamId}`, options, cb);\n }\n\n /**\n * List the users who are members of the Team\n * @see https://developer.github.com/v3/orgs/teams/#list-team-members\n * @param {object} options - Parameters for listing team users\n * @param {string} [options.role=all] - can be one of: `all`, `maintainer`, or `member`\n * @param {Requestable.callback} [cb] - will receive the list of users\n * @return {Promise} - the promise for the http request\n */\n listMembers(options, cb) {\n log(`Getting members of Team ${this.__teamId}`);\n return this._requestAllPages(`/teams/${this.__teamId}/members`, options, cb);\n }\n\n /**\n * Get Team membership status for a user\n * @see https://developer.github.com/v3/orgs/teams/#get-team-membership\n * @param {string} username - can be one of: `all`, `maintainer`, or `member`\n * @param {Requestable.callback} [cb] - will receive the membership status of a user\n * @return {Promise} - the promise for the http request\n */\n getMembership(username, cb) {\n log(`Getting membership of user ${username} in Team ${this.__teamId}`);\n return this._request('GET', `/teams/${this.__teamId}/memberships/${username}`, undefined, cb);\n }\n\n /**\n * Add a member to the Team\n * @see https://developer.github.com/v3/orgs/teams/#add-team-membership\n * @param {string} username - can be one of: `all`, `maintainer`, or `member`\n * @param {object} options - Parameters for adding a team member\n * @param {string} [options.role=member] - The role that this user should have in the team. Can be one\n * of: `member`, or `maintainer`\n * @param {Requestable.callback} [cb] - will receive the membership status of added user\n * @return {Promise} - the promise for the http request\n */\n addMembership(username, options, cb) {\n log(`Adding user ${username} to Team ${this.__teamId}`);\n return this._request('PUT', `/teams/${this.__teamId}/memberships/${username}`, options, cb);\n }\n\n /**\n * Get repo management status for team\n * @see https://developer.github.com/v3/orgs/teams/#remove-team-membership\n * @param {string} owner - Organization name\n * @param {string} repo - Repo name\n * @param {Requestable.callback} [cb] - will receive the membership status of added user\n * @return {Promise} - the promise for the http request\n */\n isManagedRepo(owner, repo, cb) {\n log(`Getting repo management by Team ${this.__teamId} for repo ${owner}/${repo}`);\n return this._request204or404(`/teams/${this.__teamId}/repos/${owner}/${repo}`, undefined, cb);\n }\n\n /**\n * Add or Update repo management status for team\n * @see https://developer.github.com/v3/orgs/teams/#add-or-update-team-repository\n * @param {string} owner - Organization name\n * @param {string} repo - Repo name\n * @param {object} options - Parameters for adding or updating repo management for the team\n * @param {string} [options.permission] - The permission to grant the team on this repository. Can be one\n * of: `pull`, `push`, or `admin`\n * @param {Requestable.callback} [cb] - will receive the membership status of added user\n * @return {Promise} - the promise for the http request\n */\n manageRepo(owner, repo, options, cb) {\n log(`Adding or Updating repo management by Team ${this.__teamId} for repo ${owner}/${repo}`);\n return this._request204or404(`/teams/${this.__teamId}/repos/${owner}/${repo}`, options, cb, 'PUT');\n }\n\n /**\n * Remove repo management status for team\n * @see https://developer.github.com/v3/orgs/teams/#remove-team-repository\n * @param {string} owner - Organization name\n * @param {string} repo - Repo name\n * @param {Requestable.callback} [cb] - will receive the membership status of added user\n * @return {Promise} - the promise for the http request\n */\n unmanageRepo(owner, repo, cb) {\n log(`Remove repo management by Team ${this.__teamId} for repo ${owner}/${repo}`);\n return this._request204or404(`/teams/${this.__teamId}/repos/${owner}/${repo}`, undefined, cb, 'DELETE');\n }\n\n /**\n * Delete Team\n * @see https://developer.github.com/v3/orgs/teams/#delete-team\n * @param {Requestable.callback} [cb] - will receive the list of repositories\n * @return {Promise} - the promise for the http request\n */\n deleteTeam(cb) {\n log(`Deleting Team ${this.__teamId}`);\n return this._request204or404(`/teams/${this.__teamId}`, undefined, cb, 'DELETE');\n }\n}\n\nmodule.exports = Team;\n","/**\n * @file\n * @copyright 2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n * Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\nimport debug from 'debug';\nconst log = debug('github:user');\n\n/**\n * A User allows scoping of API requests to a particular Github user.\n */\nclass User extends Requestable {\n /**\n * Create a User.\n * @param {string} [username] - the user to use for user-scoped queries\n * @param {Requestable.auth} [auth] - information required to authenticate to Github\n * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n */\n constructor(username, auth, apiBase) {\n super(auth, apiBase);\n this.__user = username;\n }\n\n /**\n * Get the url for the request. (dependent on if we're requesting for the authenticated user or not)\n * @private\n * @param {string} endpoint - the endpoint being requested\n * @return {string} - the resolved endpoint\n */\n __getScopedUrl(endpoint) {\n if (this.__user) {\n return endpoint ?\n `/users/${this.__user}/${endpoint}` :\n `/users/${this.__user}`\n ;\n\n } else { // eslint-disable-line\n switch (endpoint) {\n case '':\n return '/user';\n\n case 'notifications':\n case 'gists':\n return `/${endpoint}`;\n\n default:\n return `/user/${endpoint}`;\n }\n }\n }\n\n /**\n * List the user's repositories\n * @see https://developer.github.com/v3/repos/#list-user-repositories\n * @param {Object} [options={}] - any options to refine the search\n * @param {Requestable.callback} [cb] - will receive the list of repositories\n * @return {Promise} - the promise for the http request\n */\n listRepos(options, cb) {\n if (typeof options === 'function') {\n cb = options;\n options = {};\n }\n\n options = this._getOptionsWithDefaults(options);\n\n log(`Fetching repositories with options: ${JSON.stringify(options)}`);\n return this._requestAllPages(this.__getScopedUrl('repos'), options, cb);\n }\n\n /**\n * List the orgs that the user belongs to\n * @see https://developer.github.com/v3/orgs/#list-user-organizations\n * @param {Requestable.callback} [cb] - will receive the list of organizations\n * @return {Promise} - the promise for the http request\n */\n listOrgs(cb) {\n return this._request('GET', this.__getScopedUrl('orgs'), null, cb);\n }\n\n /**\n * List the user's gists\n * @see https://developer.github.com/v3/gists/#list-a-users-gists\n * @param {Requestable.callback} [cb] - will receive the list of gists\n * @return {Promise} - the promise for the http request\n */\n listGists(cb) {\n return this._request('GET', this.__getScopedUrl('gists'), null, cb);\n }\n\n /**\n * List the user's starred gists\n * @see https://developer.github.com/v3/gists/#list-starred-gists\n * @param {Requestable.callback} [cb] - will receive the list of gists\n * @return {Promise} - the promise for the http request\n */\n listStarredGists(cb) {\n return this._request('GET', this.__getScopedUrl('gists/starred'), null, cb);\n }\n\n /**\n * List the user's notifications\n * @see https://developer.github.com/v3/activity/notifications/#list-your-notifications\n * @param {Object} [options={}] - any options to refine the search\n * @param {Requestable.callback} [cb] - will receive the list of repositories\n * @return {Promise} - the promise for the http request\n */\n listNotifications(options, cb) {\n options = options || {};\n if (typeof options === 'function') {\n cb = options;\n options = {};\n }\n\n options.since = this._dateToISO(options.since);\n options.before = this._dateToISO(options.before);\n\n return this._request('GET', this.__getScopedUrl('notifications'), options, cb);\n }\n\n /**\n * Show the user's profile\n * @see https://developer.github.com/v3/users/#get-a-single-user\n * @param {Requestable.callback} [cb] - will receive the user's information\n * @return {Promise} - the promise for the http request\n */\n getProfile(cb) {\n return this._request('GET', this.__getScopedUrl(''), null, cb);\n }\n\n /**\n * Gets the list of starred repositories for the user\n * @see https://developer.github.com/v3/activity/starring/#list-repositories-being-starred\n * @param {Requestable.callback} [cb] - will receive the list of starred repositories\n * @return {Promise} - the promise for the http request\n */\n listStarredRepos(cb) {\n let requestOptions = this._getOptionsWithDefaults();\n return this._requestAllPages(this.__getScopedUrl('starred'), requestOptions, cb);\n }\n\n /**\n * List email addresses for a user\n * @see https://developer.github.com/v3/users/emails/#list-email-addresses-for-a-user\n * @param {Requestable.callback} [cb] - will receive the list of emails\n * @return {Promise} - the promise for the http request\n */\n getEmails(cb) {\n return this._request('GET', '/user/emails', null, cb);\n }\n\n /**\n * Have the authenticated user follow this user\n * @see https://developer.github.com/v3/users/followers/#follow-a-user\n * @param {string} username - the user to follow\n * @param {Requestable.callback} [cb] - will receive true if the request succeeds\n * @return {Promise} - the promise for the http request\n */\n follow(username, cb) {\n return this._request('PUT', `/user/following/${this.__user}`, null, cb);\n }\n\n /**\n * Have the currently authenticated user unfollow this user\n * @see https://developer.github.com/v3/users/followers/#follow-a-user\n * @param {string} username - the user to unfollow\n * @param {Requestable.callback} [cb] - receives true if the request succeeds\n * @return {Promise} - the promise for the http request\n */\n unfollow(username, cb) {\n return this._request('DELETE', `/user/following/${this.__user}`, null, cb);\n }\n\n /**\n * Create a new repository for the currently authenticated user\n * @see https://developer.github.com/v3/repos/#create\n * @param {object} options - the repository definition\n * @param {Requestable.callback} [cb] - will receive the API response\n * @return {Promise} - the promise for the http request\n */\n createRepo(options, cb) {\n return this._request('POST', '/user/repos', options, cb);\n }\n}\n\nmodule.exports = User;\n"]} \ No newline at end of file diff --git a/dist/components/User.js b/dist/components/User.js index 323be78c..7aa216eb 100644 --- a/dist/components/User.js +++ b/dist/components/User.js @@ -137,19 +137,6 @@ var User = function (_Requestable) { return this._request('GET', this.__getScopedUrl('gists/starred'), null, cb); } - /** - * List the user's gists - * @see https://developer.github.com/v3/gists/#list-a-users-gists - * @param {Requestable.callback} [cb] - will receive the list of gists - * @return {Promise} - the promise for the http request - */ - - }, { - key: 'listStarredGists', - value: function listStarredGists(cb) { - return this._request('GET', this.__getScopedUrl('gists'), null, cb); - } - /** * List the user's notifications * @see https://developer.github.com/v3/activity/notifications/#list-your-notifications @@ -260,5 +247,5 @@ var User = function (_Requestable) { }(_Requestable3.default); module.exports = User; -//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["User.js"],"names":["log","User","username","auth","apiBase","__user","endpoint","options","cb","_getOptionsWithDefaults","JSON","stringify","_requestAllPages","__getScopedUrl","_request","since","_dateToISO","before","requestOptions","module","exports"],"mappings":"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","file":"User.js","sourcesContent":["/**\n * @file\n * @copyright  2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license    Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n *             Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\nimport debug from 'debug';\nconst log = debug('github:user');\n\n/**\n * A User allows scoping of API requests to a particular Github user.\n */\nclass User extends Requestable {\n   /**\n    * Create a User.\n    * @param {string} [username] - the user to use for user-scoped queries\n    * @param {Requestable.auth} [auth] - information required to authenticate to Github\n    * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n    */\n   constructor(username, auth, apiBase) {\n      super(auth, apiBase);\n      this.__user = username;\n   }\n\n   /**\n    * Get the url for the request. (dependent on if we're requesting for the authenticated user or not)\n    * @private\n    * @param {string} endpoint - the endpoint being requested\n    * @return {string} - the resolved endpoint\n    */\n   __getScopedUrl(endpoint) {\n      if (this.__user) {\n         return endpoint ?\n            `/users/${this.__user}/${endpoint}` :\n            `/users/${this.__user}`\n            ;\n\n      } else { // eslint-disable-line\n         switch (endpoint) {\n            case '':\n               return '/user';\n\n            case 'notifications':\n            case 'gists':\n               return `/${endpoint}`;\n\n            default:\n               return `/user/${endpoint}`;\n         }\n      }\n   }\n\n   /**\n    * List the user's repositories\n    * @see https://developer.github.com/v3/repos/#list-user-repositories\n    * @param {Object} [options={}] - any options to refine the search\n    * @param {Requestable.callback} [cb] - will receive the list of repositories\n    * @return {Promise} - the promise for the http request\n    */\n   listRepos(options, cb) {\n      if (typeof options === 'function') {\n         cb = options;\n         options = {};\n      }\n\n      options = this._getOptionsWithDefaults(options);\n\n      log(`Fetching repositories with options: ${JSON.stringify(options)}`);\n      return this._requestAllPages(this.__getScopedUrl('repos'), options, cb);\n   }\n\n   /**\n    * List the orgs that the user belongs to\n    * @see https://developer.github.com/v3/orgs/#list-user-organizations\n    * @param {Requestable.callback} [cb] - will receive the list of organizations\n    * @return {Promise} - the promise for the http request\n    */\n   listOrgs(cb) {\n      return this._request('GET', this.__getScopedUrl('orgs'), null, cb);\n   }\n\n   /**\n    * List the user's gists\n    * @see https://developer.github.com/v3/gists/#list-a-users-gists\n    * @param {Requestable.callback} [cb] - will receive the list of gists\n    * @return {Promise} - the promise for the http request\n    */\n   listGists(cb) {\n      return this._request('GET', this.__getScopedUrl('gists'), null, cb);\n   }\n\n   /**\n    * List the user's starred gists\n    * @see https://developer.github.com/v3/gists/#list-starred-gists\n    * @param {Requestable.callback} [cb] - will receive the list of gists\n    * @return {Promise} - the promise for the http request\n    */\n   listStarredGists(cb) {\n      return this._request('GET', this.__getScopedUrl('gists/starred'), null, cb);\n   }\n\n   /**\n    * List the user's gists\n    * @see https://developer.github.com/v3/gists/#list-a-users-gists\n    * @param {Requestable.callback} [cb] - will receive the list of gists\n    * @return {Promise} - the promise for the http request\n    */\n   listStarredGists(cb) {\n      return this._request('GET', this.__getScopedUrl('gists'), null, cb);\n   }\n\n   /**\n    * List the user's notifications\n    * @see https://developer.github.com/v3/activity/notifications/#list-your-notifications\n    * @param {Object} [options={}] - any options to refine the search\n    * @param {Requestable.callback} [cb] - will receive the list of repositories\n    * @return {Promise} - the promise for the http request\n    */\n   listNotifications(options, cb) {\n      options = options || {};\n      if (typeof options === 'function') {\n         cb = options;\n         options = {};\n      }\n\n      options.since = this._dateToISO(options.since);\n      options.before = this._dateToISO(options.before);\n\n      return this._request('GET', this.__getScopedUrl('notifications'), options, cb);\n   }\n\n   /**\n    * Show the user's profile\n    * @see https://developer.github.com/v3/users/#get-a-single-user\n    * @param {Requestable.callback} [cb] - will receive the user's information\n    * @return {Promise} - the promise for the http request\n    */\n   getProfile(cb) {\n      return this._request('GET', this.__getScopedUrl(''), null, cb);\n   }\n\n   /**\n    * Gets the list of starred repositories for the user\n    * @see https://developer.github.com/v3/activity/starring/#list-repositories-being-starred\n    * @param {Requestable.callback} [cb] - will receive the list of starred repositories\n    * @return {Promise} - the promise for the http request\n    */\n   listStarredRepos(cb) {\n      let requestOptions = this._getOptionsWithDefaults();\n      return this._requestAllPages(this.__getScopedUrl('starred'), requestOptions, cb);\n   }\n\n   /**\n    * List email addresses for a user\n    * @see https://developer.github.com/v3/users/emails/#list-email-addresses-for-a-user\n    * @param {Requestable.callback} [cb] - will receive the list of emails\n    * @return {Promise} - the promise for the http request\n    */\n   getEmails(cb) {\n      return this._request('GET', '/user/emails', null, cb);\n   }\n\n   /**\n    * Have the authenticated user follow this user\n    * @see https://developer.github.com/v3/users/followers/#follow-a-user\n    * @param {string} username - the user to follow\n    * @param {Requestable.callback} [cb] - will receive true if the request succeeds\n    * @return {Promise} - the promise for the http request\n    */\n   follow(username, cb) {\n      return this._request('PUT', `/user/following/${this.__user}`, null, cb);\n   }\n\n   /**\n    * Have the currently authenticated user unfollow this user\n    * @see https://developer.github.com/v3/users/followers/#follow-a-user\n    * @param {string} username - the user to unfollow\n    * @param {Requestable.callback} [cb] - receives true if the request succeeds\n    * @return {Promise} - the promise for the http request\n    */\n   unfollow(username, cb) {\n      return this._request('DELETE', `/user/following/${this.__user}`, null, cb);\n   }\n\n   /**\n    * Create a new repository for the currently authenticated user\n    * @see https://developer.github.com/v3/repos/#create\n    * @param {object} options - the repository definition\n    * @param {Requestable.callback} [cb] - will receive the API response\n    * @return {Promise} - the promise for the http request\n    */\n   createRepo(options, cb) {\n      return this._request('POST', '/user/repos', options, cb);\n   }\n}\n\nmodule.exports = User;\n"]} +//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["User.js"],"names":["log","User","username","auth","apiBase","__user","endpoint","options","cb","_getOptionsWithDefaults","JSON","stringify","_requestAllPages","__getScopedUrl","_request","since","_dateToISO","before","requestOptions","module","exports"],"mappings":"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","file":"User.js","sourcesContent":["/**\n * @file\n * @copyright  2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license    Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n *             Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\nimport debug from 'debug';\nconst log = debug('github:user');\n\n/**\n * A User allows scoping of API requests to a particular Github user.\n */\nclass User extends Requestable {\n   /**\n    * Create a User.\n    * @param {string} [username] - the user to use for user-scoped queries\n    * @param {Requestable.auth} [auth] - information required to authenticate to Github\n    * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n    */\n   constructor(username, auth, apiBase) {\n      super(auth, apiBase);\n      this.__user = username;\n   }\n\n   /**\n    * Get the url for the request. (dependent on if we're requesting for the authenticated user or not)\n    * @private\n    * @param {string} endpoint - the endpoint being requested\n    * @return {string} - the resolved endpoint\n    */\n   __getScopedUrl(endpoint) {\n      if (this.__user) {\n         return endpoint ?\n            `/users/${this.__user}/${endpoint}` :\n            `/users/${this.__user}`\n            ;\n\n      } else { // eslint-disable-line\n         switch (endpoint) {\n            case '':\n               return '/user';\n\n            case 'notifications':\n            case 'gists':\n               return `/${endpoint}`;\n\n            default:\n               return `/user/${endpoint}`;\n         }\n      }\n   }\n\n   /**\n    * List the user's repositories\n    * @see https://developer.github.com/v3/repos/#list-user-repositories\n    * @param {Object} [options={}] - any options to refine the search\n    * @param {Requestable.callback} [cb] - will receive the list of repositories\n    * @return {Promise} - the promise for the http request\n    */\n   listRepos(options, cb) {\n      if (typeof options === 'function') {\n         cb = options;\n         options = {};\n      }\n\n      options = this._getOptionsWithDefaults(options);\n\n      log(`Fetching repositories with options: ${JSON.stringify(options)}`);\n      return this._requestAllPages(this.__getScopedUrl('repos'), options, cb);\n   }\n\n   /**\n    * List the orgs that the user belongs to\n    * @see https://developer.github.com/v3/orgs/#list-user-organizations\n    * @param {Requestable.callback} [cb] - will receive the list of organizations\n    * @return {Promise} - the promise for the http request\n    */\n   listOrgs(cb) {\n      return this._request('GET', this.__getScopedUrl('orgs'), null, cb);\n   }\n\n   /**\n    * List the user's gists\n    * @see https://developer.github.com/v3/gists/#list-a-users-gists\n    * @param {Requestable.callback} [cb] - will receive the list of gists\n    * @return {Promise} - the promise for the http request\n    */\n   listGists(cb) {\n      return this._request('GET', this.__getScopedUrl('gists'), null, cb);\n   }\n\n   /**\n    * List the user's starred gists\n    * @see https://developer.github.com/v3/gists/#list-starred-gists\n    * @param {Requestable.callback} [cb] - will receive the list of gists\n    * @return {Promise} - the promise for the http request\n    */\n   listStarredGists(cb) {\n      return this._request('GET', this.__getScopedUrl('gists/starred'), null, cb);\n   }\n\n   /**\n    * List the user's notifications\n    * @see https://developer.github.com/v3/activity/notifications/#list-your-notifications\n    * @param {Object} [options={}] - any options to refine the search\n    * @param {Requestable.callback} [cb] - will receive the list of repositories\n    * @return {Promise} - the promise for the http request\n    */\n   listNotifications(options, cb) {\n      options = options || {};\n      if (typeof options === 'function') {\n         cb = options;\n         options = {};\n      }\n\n      options.since = this._dateToISO(options.since);\n      options.before = this._dateToISO(options.before);\n\n      return this._request('GET', this.__getScopedUrl('notifications'), options, cb);\n   }\n\n   /**\n    * Show the user's profile\n    * @see https://developer.github.com/v3/users/#get-a-single-user\n    * @param {Requestable.callback} [cb] - will receive the user's information\n    * @return {Promise} - the promise for the http request\n    */\n   getProfile(cb) {\n      return this._request('GET', this.__getScopedUrl(''), null, cb);\n   }\n\n   /**\n    * Gets the list of starred repositories for the user\n    * @see https://developer.github.com/v3/activity/starring/#list-repositories-being-starred\n    * @param {Requestable.callback} [cb] - will receive the list of starred repositories\n    * @return {Promise} - the promise for the http request\n    */\n   listStarredRepos(cb) {\n      let requestOptions = this._getOptionsWithDefaults();\n      return this._requestAllPages(this.__getScopedUrl('starred'), requestOptions, cb);\n   }\n\n   /**\n    * List email addresses for a user\n    * @see https://developer.github.com/v3/users/emails/#list-email-addresses-for-a-user\n    * @param {Requestable.callback} [cb] - will receive the list of emails\n    * @return {Promise} - the promise for the http request\n    */\n   getEmails(cb) {\n      return this._request('GET', '/user/emails', null, cb);\n   }\n\n   /**\n    * Have the authenticated user follow this user\n    * @see https://developer.github.com/v3/users/followers/#follow-a-user\n    * @param {string} username - the user to follow\n    * @param {Requestable.callback} [cb] - will receive true if the request succeeds\n    * @return {Promise} - the promise for the http request\n    */\n   follow(username, cb) {\n      return this._request('PUT', `/user/following/${this.__user}`, null, cb);\n   }\n\n   /**\n    * Have the currently authenticated user unfollow this user\n    * @see https://developer.github.com/v3/users/followers/#follow-a-user\n    * @param {string} username - the user to unfollow\n    * @param {Requestable.callback} [cb] - receives true if the request succeeds\n    * @return {Promise} - the promise for the http request\n    */\n   unfollow(username, cb) {\n      return this._request('DELETE', `/user/following/${this.__user}`, null, cb);\n   }\n\n   /**\n    * Create a new repository for the currently authenticated user\n    * @see https://developer.github.com/v3/repos/#create\n    * @param {object} options - the repository definition\n    * @param {Requestable.callback} [cb] - will receive the API response\n    * @return {Promise} - the promise for the http request\n    */\n   createRepo(options, cb) {\n      return this._request('POST', '/user/repos', options, cb);\n   }\n}\n\nmodule.exports = User;\n"]} //# sourceMappingURL=User.js.map diff --git a/dist/components/User.js.map b/dist/components/User.js.map index 69accc37..802d0a34 100644 --- a/dist/components/User.js.map +++ b/dist/components/User.js.map @@ -1 +1 @@ -{"version":3,"names":[],"mappings":"","sources":["User.js"],"sourcesContent":["/**\n * @file\n * @copyright 2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n * Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\nimport debug from 'debug';\nconst log = debug('github:user');\n\n/**\n * A User allows scoping of API requests to a particular Github user.\n */\nclass User extends Requestable {\n /**\n * Create a User.\n * @param {string} [username] - the user to use for user-scoped queries\n * @param {Requestable.auth} [auth] - information required to authenticate to Github\n * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n */\n constructor(username, auth, apiBase) {\n super(auth, apiBase);\n this.__user = username;\n }\n\n /**\n * Get the url for the request. (dependent on if we're requesting for the authenticated user or not)\n * @private\n * @param {string} endpoint - the endpoint being requested\n * @return {string} - the resolved endpoint\n */\n __getScopedUrl(endpoint) {\n if (this.__user) {\n return endpoint ?\n `/users/${this.__user}/${endpoint}` :\n `/users/${this.__user}`\n ;\n\n } else { // eslint-disable-line\n switch (endpoint) {\n case '':\n return '/user';\n\n case 'notifications':\n case 'gists':\n return `/${endpoint}`;\n\n default:\n return `/user/${endpoint}`;\n }\n }\n }\n\n /**\n * List the user's repositories\n * @see https://developer.github.com/v3/repos/#list-user-repositories\n * @param {Object} [options={}] - any options to refine the search\n * @param {Requestable.callback} [cb] - will receive the list of repositories\n * @return {Promise} - the promise for the http request\n */\n listRepos(options, cb) {\n if (typeof options === 'function') {\n cb = options;\n options = {};\n }\n\n options = this._getOptionsWithDefaults(options);\n\n log(`Fetching repositories with options: ${JSON.stringify(options)}`);\n return this._requestAllPages(this.__getScopedUrl('repos'), options, cb);\n }\n\n /**\n * List the orgs that the user belongs to\n * @see https://developer.github.com/v3/orgs/#list-user-organizations\n * @param {Requestable.callback} [cb] - will receive the list of organizations\n * @return {Promise} - the promise for the http request\n */\n listOrgs(cb) {\n return this._request('GET', this.__getScopedUrl('orgs'), null, cb);\n }\n\n /**\n * List the user's gists\n * @see https://developer.github.com/v3/gists/#list-a-users-gists\n * @param {Requestable.callback} [cb] - will receive the list of gists\n * @return {Promise} - the promise for the http request\n */\n listGists(cb) {\n return this._request('GET', this.__getScopedUrl('gists'), null, cb);\n }\n\n /**\n * List the user's starred gists\n * @see https://developer.github.com/v3/gists/#list-starred-gists\n * @param {Requestable.callback} [cb] - will receive the list of gists\n * @return {Promise} - the promise for the http request\n */\n listStarredGists(cb) {\n return this._request('GET', this.__getScopedUrl('gists/starred'), null, cb);\n }\n\n /**\n * List the user's gists\n * @see https://developer.github.com/v3/gists/#list-a-users-gists\n * @param {Requestable.callback} [cb] - will receive the list of gists\n * @return {Promise} - the promise for the http request\n */\n listStarredGists(cb) {\n return this._request('GET', this.__getScopedUrl('gists'), null, cb);\n }\n\n /**\n * List the user's notifications\n * @see https://developer.github.com/v3/activity/notifications/#list-your-notifications\n * @param {Object} [options={}] - any options to refine the search\n * @param {Requestable.callback} [cb] - will receive the list of repositories\n * @return {Promise} - the promise for the http request\n */\n listNotifications(options, cb) {\n options = options || {};\n if (typeof options === 'function') {\n cb = options;\n options = {};\n }\n\n options.since = this._dateToISO(options.since);\n options.before = this._dateToISO(options.before);\n\n return this._request('GET', this.__getScopedUrl('notifications'), options, cb);\n }\n\n /**\n * Show the user's profile\n * @see https://developer.github.com/v3/users/#get-a-single-user\n * @param {Requestable.callback} [cb] - will receive the user's information\n * @return {Promise} - the promise for the http request\n */\n getProfile(cb) {\n return this._request('GET', this.__getScopedUrl(''), null, cb);\n }\n\n /**\n * Gets the list of starred repositories for the user\n * @see https://developer.github.com/v3/activity/starring/#list-repositories-being-starred\n * @param {Requestable.callback} [cb] - will receive the list of starred repositories\n * @return {Promise} - the promise for the http request\n */\n listStarredRepos(cb) {\n let requestOptions = this._getOptionsWithDefaults();\n return this._requestAllPages(this.__getScopedUrl('starred'), requestOptions, cb);\n }\n\n /**\n * List email addresses for a user\n * @see https://developer.github.com/v3/users/emails/#list-email-addresses-for-a-user\n * @param {Requestable.callback} [cb] - will receive the list of emails\n * @return {Promise} - the promise for the http request\n */\n getEmails(cb) {\n return this._request('GET', '/user/emails', null, cb);\n }\n\n /**\n * Have the authenticated user follow this user\n * @see https://developer.github.com/v3/users/followers/#follow-a-user\n * @param {string} username - the user to follow\n * @param {Requestable.callback} [cb] - will receive true if the request succeeds\n * @return {Promise} - the promise for the http request\n */\n follow(username, cb) {\n return this._request('PUT', `/user/following/${this.__user}`, null, cb);\n }\n\n /**\n * Have the currently authenticated user unfollow this user\n * @see https://developer.github.com/v3/users/followers/#follow-a-user\n * @param {string} username - the user to unfollow\n * @param {Requestable.callback} [cb] - receives true if the request succeeds\n * @return {Promise} - the promise for the http request\n */\n unfollow(username, cb) {\n return this._request('DELETE', `/user/following/${this.__user}`, null, cb);\n }\n\n /**\n * Create a new repository for the currently authenticated user\n * @see https://developer.github.com/v3/repos/#create\n * @param {object} options - the repository definition\n * @param {Requestable.callback} [cb] - will receive the API response\n * @return {Promise} - the promise for the http request\n */\n createRepo(options, cb) {\n return this._request('POST', '/user/repos', options, cb);\n }\n}\n\nmodule.exports = User;\n"],"file":"User.js"} \ No newline at end of file +{"version":3,"names":[],"mappings":"","sources":["User.js"],"sourcesContent":["/**\n * @file\n * @copyright 2013 Michael Aufreiter (Development Seed) and 2016 Yahoo Inc.\n * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n * Github.js is freely distributable.\n */\n\nimport Requestable from './Requestable';\nimport debug from 'debug';\nconst log = debug('github:user');\n\n/**\n * A User allows scoping of API requests to a particular Github user.\n */\nclass User extends Requestable {\n /**\n * Create a User.\n * @param {string} [username] - the user to use for user-scoped queries\n * @param {Requestable.auth} [auth] - information required to authenticate to Github\n * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n */\n constructor(username, auth, apiBase) {\n super(auth, apiBase);\n this.__user = username;\n }\n\n /**\n * Get the url for the request. (dependent on if we're requesting for the authenticated user or not)\n * @private\n * @param {string} endpoint - the endpoint being requested\n * @return {string} - the resolved endpoint\n */\n __getScopedUrl(endpoint) {\n if (this.__user) {\n return endpoint ?\n `/users/${this.__user}/${endpoint}` :\n `/users/${this.__user}`\n ;\n\n } else { // eslint-disable-line\n switch (endpoint) {\n case '':\n return '/user';\n\n case 'notifications':\n case 'gists':\n return `/${endpoint}`;\n\n default:\n return `/user/${endpoint}`;\n }\n }\n }\n\n /**\n * List the user's repositories\n * @see https://developer.github.com/v3/repos/#list-user-repositories\n * @param {Object} [options={}] - any options to refine the search\n * @param {Requestable.callback} [cb] - will receive the list of repositories\n * @return {Promise} - the promise for the http request\n */\n listRepos(options, cb) {\n if (typeof options === 'function') {\n cb = options;\n options = {};\n }\n\n options = this._getOptionsWithDefaults(options);\n\n log(`Fetching repositories with options: ${JSON.stringify(options)}`);\n return this._requestAllPages(this.__getScopedUrl('repos'), options, cb);\n }\n\n /**\n * List the orgs that the user belongs to\n * @see https://developer.github.com/v3/orgs/#list-user-organizations\n * @param {Requestable.callback} [cb] - will receive the list of organizations\n * @return {Promise} - the promise for the http request\n */\n listOrgs(cb) {\n return this._request('GET', this.__getScopedUrl('orgs'), null, cb);\n }\n\n /**\n * List the user's gists\n * @see https://developer.github.com/v3/gists/#list-a-users-gists\n * @param {Requestable.callback} [cb] - will receive the list of gists\n * @return {Promise} - the promise for the http request\n */\n listGists(cb) {\n return this._request('GET', this.__getScopedUrl('gists'), null, cb);\n }\n\n /**\n * List the user's starred gists\n * @see https://developer.github.com/v3/gists/#list-starred-gists\n * @param {Requestable.callback} [cb] - will receive the list of gists\n * @return {Promise} - the promise for the http request\n */\n listStarredGists(cb) {\n return this._request('GET', this.__getScopedUrl('gists/starred'), null, cb);\n }\n\n /**\n * List the user's notifications\n * @see https://developer.github.com/v3/activity/notifications/#list-your-notifications\n * @param {Object} [options={}] - any options to refine the search\n * @param {Requestable.callback} [cb] - will receive the list of repositories\n * @return {Promise} - the promise for the http request\n */\n listNotifications(options, cb) {\n options = options || {};\n if (typeof options === 'function') {\n cb = options;\n options = {};\n }\n\n options.since = this._dateToISO(options.since);\n options.before = this._dateToISO(options.before);\n\n return this._request('GET', this.__getScopedUrl('notifications'), options, cb);\n }\n\n /**\n * Show the user's profile\n * @see https://developer.github.com/v3/users/#get-a-single-user\n * @param {Requestable.callback} [cb] - will receive the user's information\n * @return {Promise} - the promise for the http request\n */\n getProfile(cb) {\n return this._request('GET', this.__getScopedUrl(''), null, cb);\n }\n\n /**\n * Gets the list of starred repositories for the user\n * @see https://developer.github.com/v3/activity/starring/#list-repositories-being-starred\n * @param {Requestable.callback} [cb] - will receive the list of starred repositories\n * @return {Promise} - the promise for the http request\n */\n listStarredRepos(cb) {\n let requestOptions = this._getOptionsWithDefaults();\n return this._requestAllPages(this.__getScopedUrl('starred'), requestOptions, cb);\n }\n\n /**\n * List email addresses for a user\n * @see https://developer.github.com/v3/users/emails/#list-email-addresses-for-a-user\n * @param {Requestable.callback} [cb] - will receive the list of emails\n * @return {Promise} - the promise for the http request\n */\n getEmails(cb) {\n return this._request('GET', '/user/emails', null, cb);\n }\n\n /**\n * Have the authenticated user follow this user\n * @see https://developer.github.com/v3/users/followers/#follow-a-user\n * @param {string} username - the user to follow\n * @param {Requestable.callback} [cb] - will receive true if the request succeeds\n * @return {Promise} - the promise for the http request\n */\n follow(username, cb) {\n return this._request('PUT', `/user/following/${this.__user}`, null, cb);\n }\n\n /**\n * Have the currently authenticated user unfollow this user\n * @see https://developer.github.com/v3/users/followers/#follow-a-user\n * @param {string} username - the user to unfollow\n * @param {Requestable.callback} [cb] - receives true if the request succeeds\n * @return {Promise} - the promise for the http request\n */\n unfollow(username, cb) {\n return this._request('DELETE', `/user/following/${this.__user}`, null, cb);\n }\n\n /**\n * Create a new repository for the currently authenticated user\n * @see https://developer.github.com/v3/repos/#create\n * @param {object} options - the repository definition\n * @param {Requestable.callback} [cb] - will receive the API response\n * @return {Promise} - the promise for the http request\n */\n createRepo(options, cb) {\n return this._request('POST', '/user/repos', options, cb);\n }\n}\n\nmodule.exports = User;\n"],"file":"User.js"} \ No newline at end of file diff --git a/lib/User.js b/lib/User.js index 9141a0c8..8367af29 100644 --- a/lib/User.js +++ b/lib/User.js @@ -101,16 +101,6 @@ class User extends Requestable { return this._request('GET', this.__getScopedUrl('gists/starred'), null, cb); } - /** - * List the user's gists - * @see https://developer.github.com/v3/gists/#list-a-users-gists - * @param {Requestable.callback} [cb] - will receive the list of gists - * @return {Promise} - the promise for the http request - */ - listStarredGists(cb) { - return this._request('GET', this.__getScopedUrl('gists'), null, cb); - } - /** * List the user's notifications * @see https://developer.github.com/v3/activity/notifications/#list-your-notifications