From a7d75d2b8ba612ddf53e971037a97727f450c2fd Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Tue, 28 Apr 2020 13:08:55 +0000 Subject: [PATCH] Update from CI --- LICENSE.txt | 19 + README.md | 78 + action.yml | 15 + documentation/README.md | 566 + documentation/example-graph.png | Bin 0 -> 29325 bytes documentation/example-numbers.png | Bin 0 -> 23803 bytes documentation/example-strings.png | Bin 0 -> 64910 bytes documentation/example-table.png | Bin 0 -> 84296 bytes documentation/static-graph.png | Bin 0 -> 18367 bytes documentation/static-numbers.png | Bin 0 -> 58376 bytes documentation/static-strings.png | Bin 0 -> 38732 bytes documentation/static-table.png | Bin 0 -> 60331 bytes examples/issue-queries.yml | 83 + examples/javascript-expressions.yml | 103 + examples/static-values.yml | 95 + index.js | 30957 ++++++++++++++++++++++++++ 16 files changed, 31916 insertions(+) create mode 100644 LICENSE.txt create mode 100644 README.md create mode 100644 action.yml create mode 100644 documentation/README.md create mode 100644 documentation/example-graph.png create mode 100644 documentation/example-numbers.png create mode 100644 documentation/example-strings.png create mode 100644 documentation/example-table.png create mode 100644 documentation/static-graph.png create mode 100644 documentation/static-numbers.png create mode 100644 documentation/static-strings.png create mode 100644 documentation/static-table.png create mode 100644 examples/issue-queries.yml create mode 100644 examples/javascript-expressions.yml create mode 100644 examples/static-values.yml create mode 100644 index.js diff --git a/LICENSE.txt b/LICENSE.txt new file mode 100644 index 00000000..1b04b798 --- /dev/null +++ b/LICENSE.txt @@ -0,0 +1,19 @@ +Copyright (c) Edward Thomson. + +Permission is hereby granted, free of charge, to any person obtaining a +copy of this software and associated documentation files (the "Software"), +to deal in the Software without restriction, including without limitation +the rights to use, copy, modify, merge, publish, distribute, sublicense, +and/or sell copies of the Software, and to permit persons to whom the +Software is furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included +in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS +OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL +THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR +OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, +ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR +OTHER DEALINGS IN THE SOFTWARE. diff --git a/README.md b/README.md new file mode 100644 index 00000000..460e6ea6 --- /dev/null +++ b/README.md @@ -0,0 +1,78 @@ +# issue-dashboard + +[![CI](https://github.com/ethomson/issue-dashboard/workflows/CI/badge.svg)](https://github.com/ethomson/issue-dashboard/actions?query=workflow%3ACI) + +**issue-dashboard** is a framework for creating dashboards from user data on GitHub, utilizing [GitHub Actions](https://github.com/features/actions) and [GitHub Pages](https://pages.github.com/). You can collect data out of GitHub using issue queries or arbitrary JavaScript that you define, and this tool will generate dashboards in HTML or Markdown. + +## Overview + +A dashboard contains _widgets_ that contain data about your project: + +**String widgets** display a string. + +![Strings](documentation/example-strings.png) + +**Number widgets** display numeric values in a compact form. + +![Numbers](documentation/example-numbers.png) + +**Graph widgets** display a bar chart. + +![Graph](documentation/example-graph.png) + +**Table widgets** display multiple rows in tabular form. + +![Table](documentation/example-table.png) + +For more information about widgets, see the [documentation](documentation#overview). + +## Installation + +This dashboard tool is an _action_ meant to be used in a [GitHub Actions](https://github.com/features/actions) workflow. You should provide your input in your workflow, and it will produce HTML or Markdown. You can then either upload the result to GitHub Pages, or update an issue or file in the repository. + +For example, a _step_ in a GitHub Actions workflow to run this action: + +```yaml +- name: 'Generate Dashboard' + uses: ethomson/issue-dashboard@v1 + with: + config: | + title: 'Dashboard' + output: + format: html + filename: 'dashboard.html' + sections: + - title: 'Pull Requests' + widgets: + - type: 'table' + title: 'New Pull Requests (This Week)' + issue_query: 'repo:libgit2/libgit2 is:open is:issue created:>{{ date("-7 days") }} sort:created-asc' + token: ${{ github.token }} +``` + +For more information about installation, see the [documentation](documentation#installation). + +## Example Configuration + +* **[Static values](https://github.com/ethomson/issue-dashboard/blob/master/examples/static-values.yml)** ([Rendered output](https://ethomson.github.io/issue-dashboard/examples/static-values.html)) + The simplest way to configure a dashboard is using static values. This may be useful to provide a rendered dashboard to existing data, which can be exported as YAML or JSON configuration. + +* **[GitHub issue and pull request queries](https://github.com/ethomson/issue-dashboard/blob/master/examples/issue-queries.yml)** ([Rendered output](https://ethomson.github.io/issue-dashboard/examples/issue-queries.html)) + Dashboards can query GitHub issue and pull request data easily, by providing the query string. Either the number of matching results will be displayed (for numeric values) or the actual results of the query will be shown (for tables). Helpful date and time manipulation functions are included. + +* **[JavaScript expressions](https://github.com/ethomson/issue-dashboard/blob/master/examples/javascript-expressions.yml)** ([Rendered output](https://ethomson.github.io/issue-dashboard/examples/javascript-expressions.html)) + Dashboards can execute JavaScript expressions to provide the values for widgets. + +For more information about configuration, see the [documentation](documentation#configuration). + +## Documentation + +Documentation is available at [https://ethomson.github.io/issue-dashboard/documentation/](https://ethomson.github.io/issue-dashboard/documentation/). + +## Limitations + +Currently, this tool only supports instantaneous data -- for example: how many issues with a certain label are open _right now_, or how many pull requests are currently open that were created within the last week. It does not support time series, meaning you cannot plot a graph of the number of open issues per day. + +## License + +Available under the MIT license, see the included [`LICENSE.txt`](LICENSE.txt) file for details. diff --git a/action.yml b/action.yml new file mode 100644 index 00000000..1958f0f0 --- /dev/null +++ b/action.yml @@ -0,0 +1,15 @@ +name: 'Issue Dashboard' +description: 'A framework for creating dashboards from user data on GitHub, utilizing GitHub Actions and GitHub Pages.' +author: 'Edward Thomson' +inputs: + config: + description: The configuration for the dashboards. + required: true + token: + description: The Personal Authentication Token to use for authentication. +runs: + using: 'node12' + main: 'index.js' +branding: + icon: 'align-left' + color: blue diff --git a/documentation/README.md b/documentation/README.md new file mode 100644 index 00000000..c7a073c1 --- /dev/null +++ b/documentation/README.md @@ -0,0 +1,566 @@ +# Documentation + +**[issue-dashboard](https://github.com/ethomson/issue-dashboard)** is a framework for creating dashboards from user data on GitHub, utilizing [GitHub Actions](https://github.com/features/actions) and [GitHub Pages](https://pages.github.com/). + +You can define the data to collect out of GitHub -- using issue queries or arbitrary scripts -- and this tool will generate dashboards in HTML, that can be published to GitHub Pages, or Markdown, that can be published as a file in a repository or a comment in an issue. + +Currently, this tool only supports instantaneous data -- for example: how many issues with a certain label are open _right now_, or how many pull requests are currently open that were created within the last week. It does not support time series, meaning you cannot plot a graph of the number of open issues per day. + +## Overview + +A dashboard has one or more _sections_, which are logical divisions and serve as collections of _widgets_ that display data. A widget is one of: + +**String widget** + +A string widget simply displays a string. The data could be static, or the result of a JavaScript execution. A string widget has a text _value_, and an optional _title_, _color_ and _url_. + +**Number widget** + +A number widget simply displays a numeric value. Like string widgets, the data could be static or the result of a JavaScript expression. But since only numbers are supported, instead of free-form strings, number widgets may be rendered smaller to save space in display. + +In addition, the data source could be a GitHub [issue query](https://help.github.com/en/github/searching-for-information-on-github/searching-issues-and-pull-requests), in which case the number of results for the query will be displayed, and the widget will link to the query itself for more information. + +A number widget has an _issue\_query_ or a numeric _value_, and an optional _title_, _color_ and _url_. + +**Graph widget** + +A graph widget displays a bar chart of multiple different numeric values. Like a number widget, the data source for the values could be a static number, the result of executed JavaScript, or the number of matching results of a GitHub issue query. + +A graph widget has _elements_, and an optional _title_. Each element has an _issue\_query_ or a numeric _value_, and an optional _title_, _color_ and _url_. + +**Table widget** + +A table widget displays tabular data containing strings or numbers. A table contains an optional header row and multiple element rows, each row containing cells. Each cell may be a static string or the result of a Javascript expression. + +In addition, the data source could be a GitHub [issue query](https://help.github.com/en/github/searching-for-information-on-github/searching-issues-and-pull-requests), in which case the table will contain the results of the query, and each row will link to the issue itself. + +A table widget has an _issue\_query_ or _elements_, and an optional _title_ and _header_. Each element is an array of rows. Each row has a string _value_ and an optional _align_, _color_ and _url_. + +## Installation + +This dashboard tool is an _action_ meant to be used in a [GitHub Actions](https://github.com/features/actions) workflow. You should provide your input in your workflow, and it will produce HTML or Markdown. You can then either upload the result to GitHub Pages, or update an issue or file in the repository. + +For example, to run this hourly (on the hour) and upload the results to GitHub Pages: + +```yaml +name: Build Dashboard + +on: + schedule: + - cron: 0 * * * * + +jobs: + build: + runs-on: ubuntu-latest + + steps: + - name: Check out repository + uses: actions/checkout@v2 + - name: Check out GitHub Pages branch + uses: actions/checkout@v2 + with: + ref: 'gh-pages' + path: 'out' + + - name: 'Generate Dashboard' + uses: ethomson/issue-dashboard@v1 + with: + config: | + title: 'Dashboard' + output: + format: html + filename: 'out/dashboard.html' + sections: + - title: 'Pull Requests' + widgets: + - type: 'table' + title: 'New Pull Requests (This Week)' + issue_query: 'repo:libgit2/libgit2 is:open is:issue created:>{{ date("-7 days") }} sort:created-asc' + token: ${{ github.token }} + + - name: Publish Documentation + run: | + git add . + git config user.name 'Dashboard User' + git config user.email 'nobody@nowhere' + git commit -m 'Documentation update' --allow-empty + git push origin gh-pages + working-directory: out +``` + +## Configuration + +Configuration is specified by YAML or JSON. At the top-level, the dashboard must have an `output.format` of either `html` or `markdown`, and an `output.filename` that will be written with the dashboard contents. The dashboard should have a `title` and `description` that will be shown on the dashboard. + +One or more `sections` can be defined, each with their own `title` and `description`. A section acts as a container for `widgets` that will display dashboard data. + +### String widgets + +A string widget will simply display a textual value. An example of a dashboard with a single section that contains two string widgets: + +![Static string widgets](static-strings.png) + +This dashboard has a single section ('Memorable quotes') that contains two string widgets. Widgets can have titles, values, colors and URLs. The data is strictly static, it does not use a script to produce the values. + +```yaml +output: + format: html + filename: dashboard.html + +sections: +- title: 'Memorable quotes' + description: 'Some notable quotations' + widgets: + - type: 'string' + title: 'Ernest Hemingway' + value: 'The way to make people trustworthy is to trust them.' + color: 'red' + - type: 'string' + title: 'Joshua from War Games' + value: 'The only way to win is not to play.' + color: 'black' +``` + +### Number widgets + +A number widget will simply display an integer or floating point number. An example of a dashboard with two sections, each with three number widgets: + +![Static number widgets](static-numbers.png) + +This dashboard has a title ('Conversions') and a description. It has two sections ('Metric to US' and 'US to metric'), each with three number widgets. Widgets can have titles, values, colors and URLs. The data is strictly static, it does not use GitHub issue queries or scripts to produce the values. + +```yaml +# The title and description of the overall dashboard; these will be +# displayed at the top of the file. +title: 'Conversions' +description: 'Some handy metric to US conversions.' + +# The name of the file that will be output, and the type of output. +# 'format' may be 'markdown' or 'html' +output: + format: html + filename: dashboard.html + +sections: + +# The first section is metric to US conversions +- title: 'Metric to US' + description: 'Distance, mass and volume; metric to US.' + widgets: + - type: number + value: '1.61' + title: 'Kilometers in a mile' + url: 'https://www.google.com/search?q=km+to+miles' + color: 'blue' + - type: number + value: '0.454' + title: 'Kilographs in a pound' + color: 'red' + - type: number + value: '1.06' + title: 'Liters in a quart' + color: 'green' + +# The section section is US to metric conversions +- title: 'US to metric' + description: 'Distance, mass and volume; US to metric.' + widgets: + - type: number + value: '0.621' + title: 'Miles in a kilometer' + url: 'https://www.google.com/search?q=miles+to+km' + color: 'blue' + - type: number + value: '2.20' + title: 'Pounds in a kilogram' + color: 'red' + - type: number + value: '0.946' + title: 'Quarts in a liter' + color: 'green' +``` + +### Graph widgets + +A graph widget will display a bar chart of multiple numeric values. An example of a dashboard with a single section containing a graph widget with 3 elements: + +![Static graph](static-graph.png) + +This dashboard a single section ('Pizza preferences') with a graph widget. The graph widget has a title 'Pizza variety' and four elements showing that there is broad support for all pizza varieties except New Haven style. + +```yaml +output: + format: html + filename: dashboard.html + +sections: +- title: 'Pizza preferences' + description: 'Type of pizza preferred by respondents.' + widgets: + - type: graph + title: Pizza variety + elements: + - title: New York + value: 18 + color: green + - title: Chicago + value: 16 + - title: Neopolitan + value: 15 + - title: 'New Haven' + value: 1 + color: red +``` + +The `elements` themselves behave as number widgets, and the query, expression and syntax described below applies to the numeric value elements of graph widgets. + +### Table widgets + +A table widget will display a table of multiple string values. An example of a dashboard with a single section containing a table widget with a header and 6 elements: + +![Static table](static-table.png) + +This dashboard a single section ('Important Dates') with a table widget. The table widget has a title 'Historic US dates' and two headers ('Date' and 'Description'). There are 6 elements, each with two cells. The first element uses strings for simplicity. The second element shows static data as a _value_ with additional attributes. + +```yaml +output: + format: html + filename: dashboard.html + +sections: +- title: 'Important Dates' + description: 'Important dates throughout history.' + widgets: + - type: 'table' + title: 'Historic US dates' + headers: + - 'Date' + - 'Description' + elements: + - [ '1775-04-19', 'Battles of Lexington and Concord' ] + - - value: '1776-07-04' + color: 'blue' + url: 'https://en.wikipedia.org/wiki/Independence_Day_(United_States)' + - value: 'Independence Day' + color: 'red' + url: 'https://en.wikipedia.org/wiki/Independence_Day_(United_States)' + - - value: '1929-10-24' + color: 'black' + - value: 'Black Thursday; the stock market crash of {{ 1928 + 1 }}' + color: 'black' + - [ '1933-12-05', 'Repeal of prohibition' ] + - [ '1973-01-22', 'Roe v Wade' ] + - [ '2015-06-26', 'Obergefell v Hodges' ] +``` + +### Querying GitHub issues and pull requests + +Instead of providing a static numeric value for number widgets and graph elements, you can provide an `issue_query` that will be run against GitHub, using [their query syntax](https://help.github.com/en/github/searching-for-information-on-github/searching-issues-and-pull-requests). The number of results will be displayed as the value. If a `url` is not provided, it will be provided as a link to the query on github.com. + +For example, the issue query `repo:libgit2/libgit2 is:pr is:open` will query the number of pull requests in the open state in the `libgit2/libgit2` repository. The dashboard widget will show the number of results, and if no `url` is specified, the widget will link to the corresponding query on github.com for full results. + +```yaml +widgets: +- type: number + issue_query: 'repo:libgit2/libgit2 is:pr is:open' + title: 'Open pull requests' + color: 'blue' +``` + +Similarly, instead of providing a list of values for a table widget, you can provide an `issue_query` that will be run against GitHub, using their query syntax. The results will be displayed as the rows. By default the issue or pull request number and title will be shown. + +For example, the query `repo:libgit2/libgit2 is:pr is:open` will query the pull requests in the open state in the `libgit2/libgit2` repository. The table widget will show each result, one per line. The table cell will link to the corresponding issue on github.com. + +```yaml +widgets: +- type: table + issue_query: 'repo:libgit2/libgit2 is:pr is:open' + title: 'Open pull requests' +``` + +### Using JavaScript expressions + +You can use JavaScript expressions within the fields to compute them by surrounding the script within double curly-braces (`{{` and `}}`). + +For example, this number widget will have a value of the result of the computation of `42 * 2`. + +```yaml +widgets: +- type: number + value: '{{ 42 * 2 }}' + title: 'Simple arithmetic' + color: 'blue' +``` + +The `value` is calculated first, and available to other fields. This number widget will have a color of `red` if the value is below 10, or `green` otherwise. + +```yaml +widgets: +- type: number + value: '12' + title: 'Simple arithmetic' + color: '{{ value < 10 ? "red" : "green" }}' +``` + +Some helper functions are available, including date manipulation functions, since many GitHub issue queries take dates and times. + +```yaml +widgets: +- type: number + issue_query: 'repo:libgit2/libgit2 is:open created:<{{ date("-1 month") }}' + title: 'Issues and PRs older than 1 month' +``` + +For more information, see [Data available to scripts](#data-available-to-scripts). + +### Running function to produce data + +For more complicated computations, you can provide a `script` that will be evaluated in an `async` context. The return value of the function will be used as the numeric value. Some data is provided, including the `github` context, which is an instance of [the Octokit API](https://github.com/octokit/rest.js/). + +This widget will search open pull requests in the `libgit2/libgit2` repo that are older than 1 day. + +```yaml +widgets: +- type: number + script: | + const results = await github.search.issuesAndPullRequests({ + q: `repo:libgit2/libgit2 is:pr is:open created:<${date('-1 day')}` + }) + return results.data.total_count +``` + +You can also return an object, with a `value` property set to the numeric value for the widget. The object may also include the `title`, `url` and `color` properties. These will override the properties set in the YAML configuration. + +```yaml +widgets: +- type: number + script: | + const repo = 'libgit2/libgit2' + const results = await github.search.issuesAndPullRequests({ + q: `repo:${repo} is:pr is:open created:<${date('-1 day')}` + }) + const count = results.data.total_count + const title = 'PRs older than 1 day' + const color = (count > 10) ? 'red' : 'green' + return { value: count, title: title, color: color } +``` + +### Data available to scripts + +Scripts will be run with some additional data available: + +**`github`**: An instance of the [Octokit API](https://github.com/octokit/rest.js/) for interacting with GitHub REST APIs. This will be authenticated with the `GITHUB_TOKEN` from the GitHub Actions instance creating this dashboard. + +**`userdata`**: An object that is initially empty, and that you can use to store data between script invocations. See "[Storing user data for scripts](#storing-user-data-for-scripts)", below. + +**`value`** is available to the _title_, _url_ and _color_ expressions, and will be populated with the value of the widget. + +**`item`** is available to the _value_ expressions of table fields that are generated from queries, and will be populated with the returned item from the query. + +And additional helper functions: + +**`date()`**: A function to produce a date in `YYYY-MM-DD` format. Without arguments, it will return the current date in UTC. You can specify a date or full timestamp as the argument, and include date or time adjustments, specified below. + +**`datetime()`**: A function to produce a date and time in `YYYY-MM-DDThh:mm:ssZ` format. Without arguments, it will return the current date and time in UTC. You can provide a date or full timestamp as the argument, and include date or time adjustments as specified below. + +**`time()`**: A function to produce a time in `hh:mm:ss` format. Without arguments, it will return the current time in UTC. You can provide a time or full timestamp as the argument, and include date or time adjustments as specified below. + +Time and date adjustments: + +Adjustment strings can be provided to the date functions so that you can calculate dates and times in the past or future. Adjustments are given as `+` or `-` an integer number of units (`days`, `hours`, etc.) Additionally, adjustments may be given as `+` or `-` a number of hours, minutes and seconds in `hh:mm:ss` format. + +For example: + +**`date('2018-12-31T11:33:44Z')`**: will return just the date portion of the timestamp given. This will return `2018-12-31`. + +**`date('2018-11-25 + 1 month')`**: will return the date one month after `2018-11-25`. This will return `2018-12-25`. + +**`date('-1 month')`**: will return the date in `YY-MM-DD` as of one month ago. If today's date is `2020-04-15` then this will return `2020-03-15`. + +**`datetime('-1 year-1 month-1 day+1 hour+1 minute+1 second')`**: will return the date and time in `YY-MM-DDThh:mm:ssZ` format as of one year, one month and one day ago. If today's date and time is `2020-04-15T13:46:14` then this will return `2019-03-14T12:45:13`. + +**`time('-01:02:03')`**: will return the time in `hh:mm:ss` format as of one hour, 2 minutes and 3 seconds ago. If the current time is `12:45:13`, then this will return `11:43:10`. + +### Storing user data for scripts + +The `userdata` object is available for scripts to store data between script invocations. For example, the expression `userdata.num = 2` will be executed for the first widget, which will have a value of `2`. The `userdata` object will be available for the subsequent widget's expression, so it will evaluate to a value of `4`. + +```yaml +widgets: +- type: number + value: '{{ userdata.num = 2 }}' +- type: number + value: '{{ userdata.num * 2 }}' +``` + +### Setup and shutdown scripts + +A top-level `setup` script can be defined, which will be executed at the beginning of dashboard execution. This may be useful to set up properties or define functions in the `userdata` object for subsequent scripts. A top-level `shutdown` script can be defined, which will be executed after the dashboard is built. + +```yaml +title: 'Dashboard' +output: + format: html + filename: dashboard.html +setup: | + userdata.color_func = function(num) { + if (num < 10) return 'green' + if (num > 50) return 'blue' + return 'yellow' + } +sections: +- title: 'Pull requests' + widgets: + - type: number + issue_query: 'repo:libgit2/libgit2 is:pr is:open' + color: '{{ userdata.color_func(value) }}' +``` + +### Colors + +Currently supported colors are: + +* `black` +* `red` +* `yellow` +* `green` +* `blue` + +## Configuration reference + +Configuration is specified by YAML or JSON; the general structure is defined below. Syntactically: + +* Dot-notation (`a.b`) is used to denote properties on maps. For example: + + `output.format` refers to a property `format` on the `output` map, which would be specified in YAML as: + + output: + format: 'markdown' + +* Array notation (`a`_[n]_) is used to denote sequences. This may be combined with dot-notation, for a sequence of maps, or array notation, for a sequence of sequences. For example: + + `sections`_[i]_`.title` refers to a property `title` on an element in the `sections` sequence, which would be specified in YAML as: + + sections: + - title: 'The title of the first section' + - title: 'The title of the second sequence' + + A more complex example, `sections`_[i]_`.widgets`_[j]_`.elements`_[k][m]_`.value` refers to the `value` property on an element in the multi-dimensional sequence `elements`, on the `widgets` sequence, itself a part of the `sections` sequence, which would be specified in YAML as: + + sections: + - widgets: + - elements: + - - value: 'First cell in the first row' + - value: 'Second cell in the first row' + - value: 'Third cell in the first row' + - - value: 'First cell in the second row' + - value: 'Second cell in the second row' + - value: 'Third cell in the second row' + +### Global options + +**`title`**: the title for the dashboard; this will generally be displayed at the top of the page. This setting is optional. + +**`description`**: the description for the dashboard; this will generally be displayed at the top of the page; his setting is optional. + +**`output.format`**: the format that the dashboard will be rendered; one of `html` or `markdown`. + +**`output.filename`**: the name of the file that the dashboard will be written to. + +**`setup`**: a script that will be executed before analytics are collected; this can be used to initialize global state for script widgets to use later. This setting is optional. + +**`shutdown`**: a script that will be executed after analytics are collected; this can be used to shut down global state that was set up by prior scripts. This setting is optional. + +### Sections + +**`sections`**: a list of sections that serve as logical containers for widgets. + +**`sections`_[i]_`.title`**: the title for a section; this setting is optional. + +**`sections`_[i]_`.description`**: the description for a section; this setting is optional. + +**`sections`_[i]_`.widgets`**: a list of widget definitions for the current section. + +### Widgets + +**`sections`_[i]_`.widgets`_[j]_`.type`**: the type of widget; one of `string`, which displays textual data, `number`, which displays a single numeric value, `graph`, which displays multiple numeric values in bar chart form, or `table`, which displays multiple strings in tabular form. + +### String widgets + +**`sections`_[i]_`.widgets`_[j]_`.title`**: the name of the widget. Expressions within double curly-braces (`{{` and `}}`) will be expanded. + +**`sections`_[i]_`.widgets`_[j]_`.url`**: the URL of the widget; the widget will have a hyperlink to this URL. Expressions within double curly-braces (`{{` and `}}`) will be expanded. + +**`sections`_[i]_`.widgets`_[j]_`.color`**: the color of the widget. Expressions within double curly-braces (`{{` and `}}`) will be expanded. + +**`sections`_[i]_`.widgets`_[j]_`.value`**: the value of the widget. Expressions within double curly-braces (`{{` and `}}`) will be expanded. This may not be specified with `sections`_[i]_`.widgets`_[j]_`.issue_query` or `sections`_[i]_`.widgets`_[j]_`.script`. + +**`sections`_[i]_`.widgets`_[j]_`.issue_query`**: a GitHub [issue query](https://help.github.com/en/github/searching-for-information-on-github/searching-issues-and-pull-requests) to perform. The total number of results for the query will be used as the value of the widget. Expressions within double curly-braces (`{{` and `}}`) will be expanded. This may not be specified with `sections`_[i]_`.widgets`_[j]_`.value` or `sections`_[i]_`.widgets`_[j]_`.script`. + +**`sections`_[i]_`.widgets`_[j]_`.script`**: a JavaScript function to evaluate. If the return value is numeric, then the return value will be used as the value of the widget. If the return value is an object, then the `value` property on the return value will be used as the value of the widget, and the returned object may have `title`, `color` and `url` properties, which will override values specified in the configuration. This may not be specified with `sections`_[i]_`.widgets`_[j]_`.value` or `sections`_[i]_`.widgets`_[j]_`.issue_query`. + +### Number widgets + +**`sections`_[i]_`.widgets`_[j]_`.title`**: the name of the widget. Expressions within double curly-braces (`{{` and `}}`) will be expanded. + +**`sections`_[i]_`.widgets`_[j]_`.url`**: the URL of the widget; the widget will have a hyperlink to this URL. Expressions within double curly-braces (`{{` and `}}`) will be expanded. + +**`sections`_[i]_`.widgets`_[j]_`.color`**: the color of the widget. Expressions within double curly-braces (`{{` and `}}`) will be expanded. + +**`sections`_[i]_`.widgets`_[j]_`.value`**: the value of the widget. Expressions within double curly-braces (`{{` and `}}`) will be expanded. This may not be specified with `sections`_[i]_`.widgets`_[j]_`.issue_query` or `sections`_[i]_`.widgets`_[j]_`.script`. + +**`sections`_[i]_`.widgets`_[j]_`.issue_query`**: a GitHub [issue query](https://help.github.com/en/github/searching-for-information-on-github/searching-issues-and-pull-requests) to perform. The total number of results for the query will be used as the value of the widget. Expressions within double curly-braces (`{{` and `}}`) will be expanded. This may not be specified with `sections`_[i]_`.widgets`_[j]_`.value` or `sections`_[i]_`.widgets`_[j]_`.script`. + +**`sections`_[i]_`.widgets`_[j]_`.script`**: a JavaScript function to evaluate. If the return value is numeric, then the return value will be used as the value of the widget. If the return value is an object, then the `value` property on the return value will be used as the value of the widget, and the returned object may have `title`, `color` and `url` properties, which will override values specified in the configuration. This may not be specified with `sections`_[i]_`.widgets`_[j]_`.value` or `sections`_[i]_`.widgets`_[j]_`.issue_query`. + +### Graph widgets + +**`sections`_[i]_`.widgets`_[j]_`.elements`**: a list of elements to draw in the graph widget. + +**`sections`_[i]_`.widgets`_[j]_`.elements`_[k]_`.title`**: the name of an item in the bar graph. + +**`sections`_[i]_`.widgets`_[j]_`.elements`_[k]_`.url`**: the URL of the bar graph element; the name and element will have a hyperlink to this URL. Expressions within double curly-braces (`{{` and `}}`) will be expanded. + +**`sections`_[i]_`.widgets`_[j]_`.elements`_[k]_`.color`**: the color of the bar graph element. Expressions within double curly-braces (`{{` and `}}`) will be expanded. + +**`sections`_[i]_`.widgets`_[j]_`.elements`_[k]_`.value`**: the value of the bar graph element. Expressions within double curly-braces (`{{` and `}}`) will be expanded. This may not be specified with `sections`_[i]_`.widgets`_[j]_`.elements`_[k]_`.issue_query` or `sections`_[i]_`.widgets`_[j]_`.elements`_[k]_`.script`. + +**`sections`_[i]_`.widgets`_[j]_`.elements`_[k]_`.issue_query`**: a GitHub [issue query](https://help.github.com/en/github/searching-for-information-on-github/searching-issues-and-pull-requests) to perform. The total number of results for the query will be used as the value of the bar graph element. Expressions within double curly-braces (`{{` and `}}`) will be expanded. This may not be specified with `sections`_[i]_`.widgets`_[j]_`.elements`_[k]_`.value` or `sections`_[i]_`.widgets`_[j]_`.elements`_[k]_`.script`. + +**`sections`_[i]_`.widgets`_[j]_`.elements`_[k]_`.script`**: a JavaScript function to evaluate. If the return value is numeric, then the return value will be used as the value of the bar graph element. If the return value is an object, then the `value` property on the return value will be used as the value of the bar graph element, and the returned object may have `title`, `color` and `url` properties, which will override values specified in the configuration. This may not be specified with `sections`_[i]_`.widgets`_[j]_`.elements`_[k]_`.value` or `sections`_[i]_`.widgets`_[j]_`.elements`_[k]_`.issue_query`. + +### Table widgets + +**`sections`_[i]_`.widgets`_[j]_`.issue_query`**: a GitHub [issue query](https://help.github.com/en/github/searching-for-information-on-github/searching-issues-and-pull-requests) to perform. Each result item will be shown in a cell, using either the fields defined by `sections`_[i]_`.widgets`_[j]_`.fields` or the issue number and title fields. Expressions within double curly-braces (`{{` and `}}`) will be expanded. This may not be specified with `sections`_[i]_`.widgets`_[j]_`.elements`. + +**`sections`_[i]_`.widgets`_[j]_`.fields`**: a list of the fields in the returned issues to display. By default, this is the issue `number` and `title` fields. This may only be specified when using a table configured with a `sections`_[i]_`.widgets`_[j]_`.issue_query`. + +**`sections`_[i]_`.widgets`_[j]_`.fields`_[k]_**: a field to display in the table. If this is an object with `title` and either `property` or `value` properties, then the `title` property will be used as the table header for this column, and the `property` or `value` property will be used for the data. Otherwise, this is a string value which will be used literally for the header, and will be used as the property to return from each item in the query. + +**`sections`_[i]_`.widgets`_[j]_`.fields`_[k]_.title**: the title of the table header for this column. + +**`sections`_[i]_`.widgets`_[j]_`.fields`_[k]_.property**: the property to return from the returned issue item for this column. For example, `created_date` will use the issue's `created_date` as the value for this cell. This may not be specified with `sections`_[i]_`.widgets`_[j]_`.fields`_[k]_`.value`. + +**`sections`_[i]_`.widgets`_[j]_`.fields`_[k]_.value**: the value to use for this cell. Expressions within double curly-braces (`{{` and `}}`) will be expanded. This may not be specified with `sections`_[i]_`.widgets`_[j]_`.fields`_[k]_`.property`. + +**`sections`_[i]_`.widgets`_[j]_`.headers`**: a list of the column headers for the table data. + +**`sections`_[i]_`.widgets`_[j]_`.headers`_[k]_**: a cell in the table header. This can be specified as a string, or an object with additional properties. + +**`sections`_[i]_`.widgets`_[j]_`.headers`_[k]_`.value`**: the text to place in this column's header. Expressions within double curly-braces (`{{` and `}}`) will be expanded. This may not be specified with `sections`_[i]_`.widgets`_[j]_`.headers`_[k]_`.script`. + +**`sections`_[i]_`.widgets`_[j]_`.headers`_[k]_`.script`**: a JavaScript function to evaluate. If the return value is a string, then the return value will be used as the value of this column's header. If the return value is an object, then the `value` property on the return value will be used as the value of this column's header, and the returned object may have `color` and `url` properties, which will override values specified in the configuration. This may not be specified with `sections`_[i]_`.widgets`_[j]_`.headers`_[k]_`.value`. + +**`sections`_[i]_`.widgets`_[j]_`.elements`**: a list of the rows for the table data. Each row is an array of cells. + +**`sections`_[i]_`.widgets`_[j]_`.elements`_[k]_**: a list of the cell data. + +**`sections`_[i]_`.widgets`_[j]_`.elements`_[k][m]_**: a cell in the table. This can be specified as a string, or an object with additional properties. + +**`sections`_[i]_`.widgets`_[j]_`.elements`_[k][m]_`.url`**: the URL of the table cell; the cell's value will have a hyperlink to this URL. Expressions within double curly-braces (`{{` and `}}`) will be expanded. + +**`sections`_[i]_`.widgets`_[j]_`.elements`_[k][m]_`.color`**: the color of the table cell. Expressions within double curly-braces (`{{` and `}}`) will be expanded. + +**`sections`_[i]_`.widgets`_[j]_`.elements`_[k][m]_`.value`**: the value of the table cell. Expressions within double curly-braces (`{{` and `}}`) will be expanded. This may not be specified with `sections`_[i]_`.widgets`_[j]_`.elements`_[k][m]_`.script`. + +**`sections`_[i]_`.widgets`_[j]_`.elements`_[k][m]_`.script`**: a JavaScript function to evaluate. If the return value is numeric, then the return value will be used as the value of the table cell. If the return value is an object, then the `value` property on the return value will be used as the value of the table cell, and the returned object may have `color` and `url` properties, which will override values specified in the configuration. This may not be specified with `sections`_[i]_`.widgets`_[j]_`.elements`_[k][m]_`.value`. diff --git a/documentation/example-graph.png b/documentation/example-graph.png new file mode 100644 index 0000000000000000000000000000000000000000..a1d2dc0f1b40009cd15cbdb52be3f3cebfdf4566 GIT binary patch literal 29325 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�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 Mef@hScOSj_FO&Ulf&c&j literal 0 HcmV?d00001 diff --git a/documentation/example-numbers.png b/documentation/example-numbers.png new file mode 100644 index 0000000000000000000000000000000000000000..b3174c8f4272eff5eae620cc5771d04ff5152218 GIT binary patch literal 23803 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 TlJyao>YVN)Bdw~3j&J@SnZg$V literal 0 HcmV?d00001 diff --git a/documentation/example-strings.png b/documentation/example-strings.png new file mode 100644 index 0000000000000000000000000000000000000000..1ce1c747439a091abc72b00acaea8aae28aebfc0 GIT binary patch literal 64910 zcmZ6ycUV(f&^M|mDk7pFpwuH(nt(Lv7P=GxDN2(jH3X!W5K$57(m|T^PNXG5=u)JH zP9P9^C$vC-)Q|Ii_r2G1|H*!yy|UJxwWh3@-^@h3)YG85&U*dAg$s0AnyQ8uE?gpC zxNyqqegJBEOoEokWngq@iCeciw8KrRUxNd`ZVrvJ|}LU%O&J^8)HNQx#eLxd`K{Qo>`wQTRtegErC=cpP3<$p*2{Zoo~ z!l}UjH-WqQb9|@D|DF7Q*WiohCI7$coxc*X;XTm*`x7)g5#aylbN};raaW7T_}2`x z4$Y;Uze!-|wym7d7A&~W$)*A^tG2~8KiyXKDHczeeraw5&^QDPoCQ2mf3#Um$Du*k zIG~$;C|`_MeXqY+dtVi=J`63!kNV2+Vih@f0@kwP@JOT`woe^DAk4K1&kZzMye5gvng{sUqok9a$;zFRt7TE zB$MYgav-SFd#hJ2EMR@TE5zHatWtBm)XspUE2>ieMW>c+W^RJUaj|zqu!KXt;B=l$Q84GU z$!grKUXI?|T~kSzd?=F)9CDGIpPzeX}9X3^o#!|pWbqPsx(#gH;kxWmDf%(XRW{b*kFzwVS0iDqV=vH`e=0Sh%at z#1p_xTab(kyQ?8QGC0w&{}A)=^#J?{ggxZf1o%0EdI0Y5&)=fh$rrV;elZyym%~!@ zr`d{xDF2USx&^c;93QWr0fM{1TPKA75bT!T20zI^IgT-V*`eaIs#2EupKW5Fh@tf@ z+x%44SuD>GEJVJ)HDZ+~FtnA2%xrP2Kl&d*PKheb*^(u3Py*~#fXDw)ivADEDG*cq zfjfCWQic4bmGi}aP9Y!^crZnKyz57lJ>sWqz%KlkSgQ?lQn5e5R`p2N>M&L8bpSJof3|suwXx4?)T7oZtR7 zfV|uqrFnE9q{09Sw)(Gdt!a3-D+i*%Pia~bK(lIp%LjM$>OX;1)@KB&1k%^pZP82r z-R=z?%VU8hmAKh$0M&m-*dOG?ox%wm;KWG0;fMbaY<}hFVaUq<@_N{Y+y!3Zi2MJK zleBzir`gIYSX%#=y(-+Y7yjN4^1XQ1n9rrRBmCLaUw1G6msE%Qf!18M_vK46E(DrB z`OguGUb=0qq1XE3YF)>8CFMV)%Fyqxf�RiE^z0f6D(W9k0^@U(J7{J&iq$Q?>S^ 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

6Iq^{J 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

wekZ(4=pXsRvGXh@L zbL>H50B8z0ZNA00E7rR8)NL^L1=()7(qo{0CH09{vz7~pY)h#gmEr(1)nb z3(9pcx6q|OGbbV#MAHT}HJaL>Y0!q#)3lt);deNq;8o`ffiQYgzZYPr`sYVckGB0K z4$w8xpA53+I0mx^m<7;^Zvw6Mc-e(2kky7uO!%pt&ZJMEy@>z?{vb!B4yMq9nw+tL z(x(8^`$ny?FM$>(@&Dv`eb7473;4@WFN>^4Zz^B^QZFC3#)ol8!W@q$(d03)D7JXOsLT?dIp%b(h_5kT$srsDlH zSsxj5+kiydq7D=oIDrHlTR+0hj5+~UO#v-P6Aarwp>IJTPJ8(6^>|k#wSRKg%Kc(8 zHP!*c6>0`F{*F-%X;ZNE3fAS2R>2h&_|UZvbzU6ppv`>lQyw_I64CFk>rF%;KtHSl z4H9&*pPxKwS9Fha2Sl_KP$8Ho00}xU9{4~f90dj_Akbl(0eI_E1Z__~E2{PNgXAI0eRQb7&r19N2J7VAEFu1nN zQZjrRoD@H8AR0X4Vai3vz$d*LUv&LY0P|WiTf%P>GYkBoUc3=c!n zM+A+7*%7c;KcHKo_S1~O8a=0*(F}b+d8{UxRoaY)o6$uM{iY&<*B8XRhyS(!ajQ|V z{>arZ@M&CG3f+?#SjAwT_DfF7*h`@0JE2$Eupv@{^@(Wi-D4jVO(Kb@po5jArO$qu z8k^ryLmgc+Xa)8f0I3}Nlfm#UawHgEj-d7n%i5RhFg5ExP7Mb#p{H(J*UuPQSNdfu z;@mTqiHA?MpOq5C0HOu9DusrKS*qjQghGD8HBlMGhzls;Qv;@-n zTn&I!^a8jo&)I*ud5h@jp&Y93UsSTyN{^K)n2w}l^t>MCW%3rOYBx-?c58-O|73u4 zGt+f!^C~kEjy>0Vb^sSXoBf{xC<}xp|AERN;#hYl z^$R1Ccyp{E-SR6SlN`U=^*?eMc%iv;VIf{dX4NqmpzI zsI}Kb2T_f`Ji?{C}Q{b$YpUzvWxOO8h@N+*PQg2&+hc8QMWJ&nrS H51#&SjEL%~ literal 0 HcmV?d00001 diff --git a/documentation/static-numbers.png b/documentation/static-numbers.png new file mode 100644 index 0000000000000000000000000000000000000000..f88af16c2fb27cdc15bbef32d54975f34e7285b2 GIT binary patch literal 58376 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�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 <@YL*0N89ny6He4 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 UKRjLS!~g&Q07*qoM6N<$f|fuoegFUf literal 0 HcmV?d00001 diff --git a/documentation/static-table.png b/documentation/static-table.png new file mode 100644 index 0000000000000000000000000000000000000000..b0fffcd3475114331a1b12d2fe21403bf79667ca GIT binary patch literal 60331 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 TGdYaATNE=B%PVD{{ date("-7 days") }}' + color: 'green' + - title: '30 days' + issue_query: 'repo:libgit2/libgit2 is:open is:issue created:{{ date("-30 days") }}..{{ date("-7 days") }}' + color: 'blue' + - title: '90 days' + issue_query: 'repo:libgit2/libgit2 is:open is:issue created:{{ date("-90 days") }}..{{ date("-30 days") }}' + - title: '1 year' + issue_query: 'repo:libgit2/libgit2 is:open is:issue created:{{ date("-1 year") }}..{{ date("-90 days") }}' + - title: '2 years' + issue_query: 'repo:libgit2/libgit2 is:open is:issue created:{{ date("-2 years") }}..{{ date("-1 year") }}' + color: 'red' + - title: '3 years' + issue_query: 'repo:libgit2/libgit2 is:open is:issue created:{{ date("-3 years") }}..{{ date("-2 years") }}' + color: 'red' + - title: '>3 years' + issue_query: 'repo:libgit2/libgit2 is:open is:issue created:<{{ date("-365 days") }}' + color: 'red' + +- title: 'Pull Requests' + widgets: + - type: 'number' + title: 'Changes Requested' + issue_query: 'repo:libgit2/libgit2 is:open is:pr review:changes_requested' + color: 'green' + - type: 'number' + title: 'Needs Review' + issue_query: 'repo:libgit2/libgit2 is:open is:pr review:none' + color: 'red' + - type: 'table' + title: 'Pull Requests with Changes Requested' + issue_query: 'repo:libgit2/libgit2 is:open is:pr review:changes_requested sort:created-asc' + - type: 'table' + title: 'Oldest Pull Requests without Review' + fields: + - title: 'Issue' + property: 'number' + - title: 'Date' + value: '{{ date(item.created_date) }}' + - title: 'Title' + property: 'title' + issue_query: 'repo:libgit2/libgit2 is:open is:pr review:none sort:created-asc' + limit: 15 diff --git a/examples/javascript-expressions.yml b/examples/javascript-expressions.yml new file mode 100644 index 00000000..70fc4d83 --- /dev/null +++ b/examples/javascript-expressions.yml @@ -0,0 +1,103 @@ +title: JavaScript Expressions +description: | + An example of using JavaScript expressions within widgets. + +output: + format: html + filename: dashboard.html + +setup: | + userdata.fibonacci = function(n) { + if (n == 0) { + return 0 + } + else if (n == 1) { + return 1 + } + else { + return userdata.fibonacci(n - 1) + userdata.fibonacci(n - 2) + } + } + + userdata.fibonacci_color = function(n) { return n <= 1 ? 'blue' : 'black' } + + userdata.fizzbuzz = function(n) { + if ((+n % 15) == 0) + return { value: 'Fizz Buzz', color: 'red' } + else if ((+n % 5) == 0) + return { value: 'Buzz', color: 'green' } + else if ((+n % 3) == 0) + return { value: 'Fizz', color: 'blue' } + else + return { value: n } + } + +sections: +- title: 'Fibonacci' + description: 'Calculate fibonacci numbers' + widgets: + - type: 'string' + title: 'JavaScript code' + value: '{{ userdata.fibonacci }}' + url: 'https://en.wikipedia.org/wiki/Fibonacci_number' + + - type: 'number' + title: 'F0' + value: '{{ userdata.fibonacci(0) }}' + color: '{{ userdata.fibonacci_color(0) }}' + - type: 'number' + title: 'F1' + value: '{{ userdata.fibonacci(1) }}' + color: '{{ userdata.fibonacci_color(1) }}' + - type: 'number' + title: 'F2' + value: '{{ userdata.fibonacci(2) }}' + color: '{{ userdata.fibonacci_color(2) }}' + - type: 'number' + title: 'F3' + value: '{{ userdata.fibonacci(3) }}' + color: '{{ userdata.fibonacci_color(3) }}' + - type: 'number' + title: 'F4' + value: '{{ userdata.fibonacci(4) }}' + color: '{{ userdata.fibonacci_color(4) }}' + - type: 'number' + title: 'F5' + value: '{{ userdata.fibonacci(5) }}' + color: '{{ userdata.fibonacci_color(5) }}' + - type: 'number' + title: 'F6' + value: '{{ userdata.fibonacci(6) }}' + color: '{{ userdata.fibonacci_color(6) }}' + - type: 'number' + title: 'F7' + value: '{{ userdata.fibonacci(7) }}' + color: '{{ userdata.fibonacci_color(7) }}' + +- title: 'FizzBuzz' + description: 'Calculate the "fizz buzz" interview question' + widgets: + - type: 'string' + title: 'JavaScript code' + value: '{{ userdata.fizzbuzz }}' + url: 'https://en.wikipedia.org/wiki/Fizz_buzz' + - type: 'table' + headers: [ 'Number', 'Fizziness' ] + elements: + - - '1' + - script: 'return userdata.fizzbuzz(1)' + - [ '2', { script: 'return userdata.fizzbuzz(2)' } ] + - [ '3', { script: 'return userdata.fizzbuzz(3)' } ] + - [ '4', { script: 'return userdata.fizzbuzz(4)' } ] + - [ '5', { script: 'return userdata.fizzbuzz(5)' } ] + - [ '6', { script: 'return userdata.fizzbuzz(6)' } ] + - [ '7', { script: 'return userdata.fizzbuzz(7)' } ] + - [ '8', { script: 'return userdata.fizzbuzz(8)' } ] + - [ '9', { script: 'return userdata.fizzbuzz(9)' } ] + - [ '10', { script: 'return userdata.fizzbuzz(10)' } ] + - [ '11', { script: 'return userdata.fizzbuzz(11)' } ] + - [ '12', { script: 'return userdata.fizzbuzz(12)' } ] + - [ '13', { script: 'return userdata.fizzbuzz(13)' } ] + - [ '14', { script: 'return userdata.fizzbuzz(14)' } ] + - [ '15', { script: 'return userdata.fizzbuzz(15)' } ] + - [ '16', { script: 'return userdata.fizzbuzz(16)' } ] diff --git a/examples/static-values.yml b/examples/static-values.yml new file mode 100644 index 00000000..4473b7b0 --- /dev/null +++ b/examples/static-values.yml @@ -0,0 +1,95 @@ +title: 'Static Values' +description: 'A simple demonstration of a dashboard with static values. This can be useful to render the results of another application that collects data and emits a dashboard configuration in YAML or JSON.' + +output: + format: html + filename: dashboard.html + +sections: +- title: 'Metric to US conversions' + description: 'Distance, mass and volume; metric to US.' + widgets: + - type: number + value: '1.61' + title: 'Kilometers in a mile' + url: 'https://www.google.com/search?q=km+to+miles' + color: 'blue' + - type: number + value: '0.454' + title: 'Kilographs in a pound' + color: 'red' + - type: number + value: '1.06' + title: 'Liters in a quart' + color: 'green' + +# The section section is US to metric conversions +- title: 'US to metric conversions' + description: 'Distance, mass and volume; US to metric.' + widgets: + - type: number + value: '0.621' + title: 'Miles in a kilometer' + url: 'https://www.google.com/search?q=miles+to+km' + color: 'blue' + - type: number + value: '2.20' + title: 'Pounds in a kilogram' + color: 'red' + - type: number + value: '0.946' + title: 'Quarts in a liter' + color: 'green' + +- title: 'Memorable quotes' + description: 'Some notable quotations' + widgets: + - type: 'string' + title: 'Ernest Hemingway' + value: 'The way to make people trustworthy is to trust them.' + color: 'blue' + - type: 'string' + title: 'Joshua from War Games' + value: 'The only way to win is not to play.' + color: 'black' + +- title: 'Pizza preferences' + description: 'Type of pizza preferred by respondents.' + widgets: + - type: graph + title: Pizza variety + elements: + - title: New York + value: 18 + color: green + - title: Chicago + value: 16 + - title: Neopolitan + value: 15 + - title: 'New Haven' + value: 1 + color: red + +- title: 'Important Dates' + description: 'Important dates throughout history.' + widgets: + - type: 'table' + title: 'Historic US dates' + headers: + - 'Date' + - 'Description' + elements: + - [ '1775-04-19', 'Battles of Lexington and Concord' ] + - - value: '1776-07-04' + color: 'blue' + url: 'https://en.wikipedia.org/wiki/Independence_Day_(United_States)' + - value: 'Independence Day' + color: 'red' + url: 'https://en.wikipedia.org/wiki/Independence_Day_(United_States)' + - - value: '1929-10-24' + color: 'black' + - value: 'Black Thursday; the stock market crash of {{ 1928 + 1 }}' + color: 'black' + - [ '1933-12-05', 'Repeal of prohibition' ] + - [ '1973-01-22', 'Roe v Wade' ] + - [ '2015-06-26', 'Obergefell v Hodges' ] diff --git a/index.js b/index.js new file mode 100644 index 00000000..f7081f37 --- /dev/null +++ b/index.js @@ -0,0 +1,30957 @@ +module.exports = +/******/ (function(modules, runtime) { // webpackBootstrap +/******/ "use strict"; +/******/ // The module cache +/******/ var installedModules = {}; +/******/ +/******/ // The require function +/******/ function __webpack_require__(moduleId) { +/******/ +/******/ // Check if module is in cache +/******/ if(installedModules[moduleId]) { +/******/ return installedModules[moduleId].exports; +/******/ } +/******/ // Create a new module (and put it into the cache) +/******/ var module = installedModules[moduleId] = { +/******/ i: moduleId, +/******/ l: false, +/******/ exports: {} +/******/ }; +/******/ +/******/ // Execute the module function +/******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__); +/******/ +/******/ // Flag the module as loaded +/******/ module.l = true; +/******/ +/******/ // Return the exports of the module +/******/ return module.exports; +/******/ } +/******/ +/******/ +/******/ __webpack_require__.ab = __dirname + "/"; +/******/ +/******/ // the startup function +/******/ function startup() { +/******/ // Load entry module and return exports +/******/ return __webpack_require__(198); +/******/ }; +/******/ +/******/ // run startup +/******/ return startup(); +/******/ }) +/************************************************************************/ +/******/ ({ + +/***/ 0: +/***/ (function(module, __unusedexports, __webpack_require__) { + +const { requestLog } = __webpack_require__(916); +const { + restEndpointMethods +} = __webpack_require__(842); + +const Core = __webpack_require__(529); + +const CORE_PLUGINS = [ + __webpack_require__(190), + __webpack_require__(19), // deprecated: remove in v17 + requestLog, + __webpack_require__(148), + restEndpointMethods, + __webpack_require__(430), + + __webpack_require__(850) // deprecated: remove in v17 +]; + +const OctokitRest = Core.plugin(CORE_PLUGINS); + +function DeprecatedOctokit(options) { + const warn = + options && options.log && options.log.warn + ? options.log.warn + : console.warn; + warn( + '[@octokit/rest] `const Octokit = require("@octokit/rest")` is deprecated. Use `const { Octokit } = require("@octokit/rest")` instead' + ); + return new OctokitRest(options); +} + +const Octokit = Object.assign(DeprecatedOctokit, { + Octokit: OctokitRest +}); + +Object.keys(OctokitRest).forEach(key => { + /* istanbul ignore else */ + if (OctokitRest.hasOwnProperty(key)) { + Octokit[key] = OctokitRest[key]; + } +}); + +module.exports = Octokit; + + +/***/ }), + +/***/ 2: +/***/ (function(module, __unusedexports, __webpack_require__) { + +"use strict"; + +const os = __webpack_require__(87); +const macosRelease = __webpack_require__(118); +const winRelease = __webpack_require__(49); + +const osName = (platform, release) => { + if (!platform && release) { + throw new Error('You can\'t specify a `release` without specifying `platform`'); + } + + platform = platform || os.platform(); + + let id; + + if (platform === 'darwin') { + if (!release && os.platform() === 'darwin') { + release = os.release(); + } + + const prefix = release ? (Number(release.split('.')[0]) > 15 ? 'macOS' : 'OS X') : 'macOS'; + id = release ? macosRelease(release).name : ''; + return prefix + (id ? ' ' + id : ''); + } + + if (platform === 'linux') { + if (!release && os.platform() === 'linux') { + release = os.release(); + } + + id = release ? release.replace(/^(\d+\.\d+).*/, '$1') : ''; + return 'Linux' + (id ? ' ' + id : ''); + } + + if (platform === 'win32') { + if (!release && os.platform() === 'win32') { + release = os.release(); + } + + id = release ? winRelease(release) : ''; + return 'Windows' + (id ? ' ' + id : ''); + } + + return platform; +}; + +module.exports = osName; + + +/***/ }), + +/***/ 9: +/***/ (function(module, __unusedexports, __webpack_require__) { + +var once = __webpack_require__(969); + +var noop = function() {}; + +var isRequest = function(stream) { + return stream.setHeader && typeof stream.abort === 'function'; +}; + +var isChildProcess = function(stream) { + return stream.stdio && Array.isArray(stream.stdio) && stream.stdio.length === 3 +}; + +var eos = function(stream, opts, callback) { + if (typeof opts === 'function') return eos(stream, null, opts); + if (!opts) opts = {}; + + callback = once(callback || noop); + + var ws = stream._writableState; + var rs = stream._readableState; + var readable = opts.readable || (opts.readable !== false && stream.readable); + var writable = opts.writable || (opts.writable !== false && stream.writable); + var cancelled = false; + + var onlegacyfinish = function() { + if (!stream.writable) onfinish(); + }; + + var onfinish = function() { + writable = false; + if (!readable) callback.call(stream); + }; + + var onend = function() { + readable = false; + if (!writable) callback.call(stream); + }; + + var onexit = function(exitCode) { + callback.call(stream, exitCode ? new Error('exited with error code: ' + exitCode) : null); + }; + + var onerror = function(err) { + callback.call(stream, err); + }; + + var onclose = function() { + process.nextTick(onclosenexttick); + }; + + var onclosenexttick = function() { + if (cancelled) return; + if (readable && !(rs && (rs.ended && !rs.destroyed))) return callback.call(stream, new Error('premature close')); + if (writable && !(ws && (ws.ended && !ws.destroyed))) return callback.call(stream, new Error('premature close')); + }; + + var onrequest = function() { + stream.req.on('finish', onfinish); + }; + + if (isRequest(stream)) { + stream.on('complete', onfinish); + stream.on('abort', onclose); + if (stream.req) onrequest(); + else stream.on('request', onrequest); + } else if (writable && !ws) { // legacy streams + stream.on('end', onlegacyfinish); + stream.on('close', onlegacyfinish); + } + + if (isChildProcess(stream)) stream.on('exit', onexit); + + stream.on('end', onend); + stream.on('finish', onfinish); + if (opts.error !== false) stream.on('error', onerror); + stream.on('close', onclose); + + return function() { + cancelled = true; + stream.removeListener('complete', onfinish); + stream.removeListener('abort', onclose); + stream.removeListener('request', onrequest); + if (stream.req) stream.req.removeListener('finish', onfinish); + stream.removeListener('end', onlegacyfinish); + stream.removeListener('close', onlegacyfinish); + stream.removeListener('finish', onfinish); + stream.removeListener('exit', onexit); + stream.removeListener('end', onend); + stream.removeListener('error', onerror); + stream.removeListener('close', onclose); + }; +}; + +module.exports = eos; + + +/***/ }), + +/***/ 11: +/***/ (function(module) { + +// Returns a wrapper function that returns a wrapped callback +// The wrapper function should do some stuff, and return a +// presumably different callback function. +// This makes sure that own properties are retained, so that +// decorations and such are not lost along the way. +module.exports = wrappy +function wrappy (fn, cb) { + if (fn && cb) return wrappy(fn)(cb) + + if (typeof fn !== 'function') + throw new TypeError('need wrapper function') + + Object.keys(fn).forEach(function (k) { + wrapper[k] = fn[k] + }) + + return wrapper + + function wrapper() { + var args = new Array(arguments.length) + for (var i = 0; i < args.length; i++) { + args[i] = arguments[i] + } + var ret = fn.apply(this, args) + var cb = args[args.length-1] + if (typeof ret === 'function' && ret !== cb) { + Object.keys(cb).forEach(function (k) { + ret[k] = cb[k] + }) + } + return ret + } +} + + +/***/ }), + +/***/ 16: +/***/ (function(module) { + +module.exports = require("tls"); + +/***/ }), + +/***/ 18: +/***/ (function() { + +eval("require")("encoding"); + + +/***/ }), + +/***/ 19: +/***/ (function(module, __unusedexports, __webpack_require__) { + +module.exports = authenticationPlugin; + +const { Deprecation } = __webpack_require__(692); +const once = __webpack_require__(969); + +const deprecateAuthenticate = once((log, deprecation) => log.warn(deprecation)); + +const authenticate = __webpack_require__(674); +const beforeRequest = __webpack_require__(471); +const requestError = __webpack_require__(349); + +function authenticationPlugin(octokit, options) { + if (options.auth) { + octokit.authenticate = () => { + deprecateAuthenticate( + octokit.log, + new Deprecation( + '[@octokit/rest] octokit.authenticate() is deprecated and has no effect when "auth" option is set on Octokit constructor' + ) + ); + }; + return; + } + const state = { + octokit, + auth: false + }; + octokit.authenticate = authenticate.bind(null, state); + octokit.hook.before("request", beforeRequest.bind(null, state)); + octokit.hook.error("request", requestError.bind(null, state)); +} + + +/***/ }), + +/***/ 20: +/***/ (function(module, __unusedexports, __webpack_require__) { + +"use strict"; + + +const cp = __webpack_require__(129); +const parse = __webpack_require__(568); +const enoent = __webpack_require__(881); + +function spawn(command, args, options) { + // Parse the arguments + const parsed = parse(command, args, options); + + // Spawn the child process + const spawned = cp.spawn(parsed.command, parsed.args, parsed.options); + + // Hook into child process "exit" event to emit an error if the command + // does not exists, see: https://github.com/IndigoUnited/node-cross-spawn/issues/16 + enoent.hookChildProcess(spawned, parsed); + + return spawned; +} + +function spawnSync(command, args, options) { + // Parse the arguments + const parsed = parse(command, args, options); + + // Spawn the child process + const result = cp.spawnSync(parsed.command, parsed.args, parsed.options); + + // Analyze if the command does not exist, see: https://github.com/IndigoUnited/node-cross-spawn/issues/16 + result.error = result.error || enoent.verifyENOENTSync(result.status, parsed); + + return result; +} + +module.exports = spawn; +module.exports.spawn = spawn; +module.exports.sync = spawnSync; + +module.exports._parse = parse; +module.exports._enoent = enoent; + + +/***/ }), + +/***/ 23: +/***/ (function(module, __unusedexports, __webpack_require__) { + +"use strict"; +// Standard YAML's JSON schema. +// http://www.yaml.org/spec/1.2/spec.html#id2803231 +// +// NOTE: JS-YAML does not support schema-specific tag resolution restrictions. +// So, this schema is not such strict as defined in the YAML specification. +// It allows numbers in binary notaion, use `Null` and `NULL` as `null`, etc. + + + + + +var Schema = __webpack_require__(43); + + +module.exports = new Schema({ + include: [ + __webpack_require__(581) + ], + implicit: [ + __webpack_require__(809), + __webpack_require__(228), + __webpack_require__(44), + __webpack_require__(417) + ] +}); + + +/***/ }), + +/***/ 34: +/***/ (function(module) { + +module.exports = require("https"); + +/***/ }), + +/***/ 39: +/***/ (function(module) { + +"use strict"; + +module.exports = opts => { + opts = opts || {}; + + const env = opts.env || process.env; + const platform = opts.platform || process.platform; + + if (platform !== 'win32') { + return 'PATH'; + } + + return Object.keys(env).find(x => x.toUpperCase() === 'PATH') || 'Path'; +}; + + +/***/ }), + +/***/ 43: +/***/ (function(module, __unusedexports, __webpack_require__) { + +"use strict"; + + +/*eslint-disable max-len*/ + +var common = __webpack_require__(740); +var YAMLException = __webpack_require__(556); +var Type = __webpack_require__(945); + + +function compileList(schema, name, result) { + var exclude = []; + + schema.include.forEach(function (includedSchema) { + result = compileList(includedSchema, name, result); + }); + + schema[name].forEach(function (currentType) { + result.forEach(function (previousType, previousIndex) { + if (previousType.tag === currentType.tag && previousType.kind === currentType.kind) { + exclude.push(previousIndex); + } + }); + + result.push(currentType); + }); + + return result.filter(function (type, index) { + return exclude.indexOf(index) === -1; + }); +} + + +function compileMap(/* lists... */) { + var result = { + scalar: {}, + sequence: {}, + mapping: {}, + fallback: {} + }, index, length; + + function collectType(type) { + result[type.kind][type.tag] = result['fallback'][type.tag] = type; + } + + for (index = 0, length = arguments.length; index < length; index += 1) { + arguments[index].forEach(collectType); + } + return result; +} + + +function Schema(definition) { + this.include = definition.include || []; + this.implicit = definition.implicit || []; + this.explicit = definition.explicit || []; + + this.implicit.forEach(function (type) { + if (type.loadKind && type.loadKind !== 'scalar') { + throw new YAMLException('There is a non-scalar type in the implicit list of a schema. Implicit resolving of such types is not supported.'); + } + }); + + this.compiledImplicit = compileList(this, 'implicit', []); + this.compiledExplicit = compileList(this, 'explicit', []); + this.compiledTypeMap = compileMap(this.compiledImplicit, this.compiledExplicit); +} + + +Schema.DEFAULT = null; + + +Schema.create = function createSchema() { + var schemas, types; + + switch (arguments.length) { + case 1: + schemas = Schema.DEFAULT; + types = arguments[0]; + break; + + case 2: + schemas = arguments[0]; + types = arguments[1]; + break; + + default: + throw new YAMLException('Wrong number of arguments for Schema.create function'); + } + + schemas = common.toArray(schemas); + types = common.toArray(types); + + if (!schemas.every(function (schema) { return schema instanceof Schema; })) { + throw new YAMLException('Specified list of super schemas (or a single Schema object) contains a non-Schema object.'); + } + + if (!types.every(function (type) { return type instanceof Type; })) { + throw new YAMLException('Specified list of YAML types (or a single Type object) contains a non-Type object.'); + } + + return new Schema({ + include: schemas, + explicit: types + }); +}; + + +module.exports = Schema; + + +/***/ }), + +/***/ 44: +/***/ (function(module, __unusedexports, __webpack_require__) { + +"use strict"; + + +var common = __webpack_require__(740); +var Type = __webpack_require__(945); + +function isHexCode(c) { + return ((0x30/* 0 */ <= c) && (c <= 0x39/* 9 */)) || + ((0x41/* A */ <= c) && (c <= 0x46/* F */)) || + ((0x61/* a */ <= c) && (c <= 0x66/* f */)); +} + +function isOctCode(c) { + return ((0x30/* 0 */ <= c) && (c <= 0x37/* 7 */)); +} + +function isDecCode(c) { + return ((0x30/* 0 */ <= c) && (c <= 0x39/* 9 */)); +} + +function resolveYamlInteger(data) { + if (data === null) return false; + + var max = data.length, + index = 0, + hasDigits = false, + ch; + + if (!max) return false; + + ch = data[index]; + + // sign + if (ch === '-' || ch === '+') { + ch = data[++index]; + } + + if (ch === '0') { + // 0 + if (index + 1 === max) return true; + ch = data[++index]; + + // base 2, base 8, base 16 + + if (ch === 'b') { + // base 2 + index++; + + for (; index < max; index++) { + ch = data[index]; + if (ch === '_') continue; + if (ch !== '0' && ch !== '1') return false; + hasDigits = true; + } + return hasDigits && ch !== '_'; + } + + + if (ch === 'x') { + // base 16 + index++; + + for (; index < max; index++) { + ch = data[index]; + if (ch === '_') continue; + if (!isHexCode(data.charCodeAt(index))) return false; + hasDigits = true; + } + return hasDigits && ch !== '_'; + } + + // base 8 + for (; index < max; index++) { + ch = data[index]; + if (ch === '_') continue; + if (!isOctCode(data.charCodeAt(index))) return false; + hasDigits = true; + } + return hasDigits && ch !== '_'; + } + + // base 10 (except 0) or base 60 + + // value should not start with `_`; + if (ch === '_') return false; + + for (; index < max; index++) { + ch = data[index]; + if (ch === '_') continue; + if (ch === ':') break; + if (!isDecCode(data.charCodeAt(index))) { + return false; + } + hasDigits = true; + } + + // Should have digits and should not end with `_` + if (!hasDigits || ch === '_') return false; + + // if !base60 - done; + if (ch !== ':') return true; + + // base60 almost not used, no needs to optimize + return /^(:[0-5]?[0-9])+$/.test(data.slice(index)); +} + +function constructYamlInteger(data) { + var value = data, sign = 1, ch, base, digits = []; + + if (value.indexOf('_') !== -1) { + value = value.replace(/_/g, ''); + } + + ch = value[0]; + + if (ch === '-' || ch === '+') { + if (ch === '-') sign = -1; + value = value.slice(1); + ch = value[0]; + } + + if (value === '0') return 0; + + if (ch === '0') { + if (value[1] === 'b') return sign * parseInt(value.slice(2), 2); + if (value[1] === 'x') return sign * parseInt(value, 16); + return sign * parseInt(value, 8); + } + + if (value.indexOf(':') !== -1) { + value.split(':').forEach(function (v) { + digits.unshift(parseInt(v, 10)); + }); + + value = 0; + base = 1; + + digits.forEach(function (d) { + value += (d * base); + base *= 60; + }); + + return sign * value; + + } + + return sign * parseInt(value, 10); +} + +function isInteger(object) { + return (Object.prototype.toString.call(object)) === '[object Number]' && + (object % 1 === 0 && !common.isNegativeZero(object)); +} + +module.exports = new Type('tag:yaml.org,2002:int', { + kind: 'scalar', + resolve: resolveYamlInteger, + construct: constructYamlInteger, + predicate: isInteger, + represent: { + binary: function (obj) { return obj >= 0 ? '0b' + obj.toString(2) : '-0b' + obj.toString(2).slice(1); }, + octal: function (obj) { return obj >= 0 ? '0' + obj.toString(8) : '-0' + obj.toString(8).slice(1); }, + decimal: function (obj) { return obj.toString(10); }, + /* eslint-disable max-len */ + hexadecimal: function (obj) { return obj >= 0 ? '0x' + obj.toString(16).toUpperCase() : '-0x' + obj.toString(16).toUpperCase().slice(1); } + }, + defaultStyle: 'decimal', + styleAliases: { + binary: [ 2, 'bin' ], + octal: [ 8, 'oct' ], + decimal: [ 10, 'dec' ], + hexadecimal: [ 16, 'hex' ] + } +}); + + +/***/ }), + +/***/ 47: +/***/ (function(module, __unusedexports, __webpack_require__) { + +module.exports = factory; + +const Octokit = __webpack_require__(402); +const registerPlugin = __webpack_require__(855); + +function factory(plugins) { + const Api = Octokit.bind(null, plugins || []); + Api.plugin = registerPlugin.bind(null, plugins || []); + return Api; +} + + +/***/ }), + +/***/ 49: +/***/ (function(module, __unusedexports, __webpack_require__) { + +"use strict"; + +const os = __webpack_require__(87); +const execa = __webpack_require__(955); + +// Reference: https://www.gaijin.at/en/lstwinver.php +const names = new Map([ + ['10.0', '10'], + ['6.3', '8.1'], + ['6.2', '8'], + ['6.1', '7'], + ['6.0', 'Vista'], + ['5.2', 'Server 2003'], + ['5.1', 'XP'], + ['5.0', '2000'], + ['4.9', 'ME'], + ['4.1', '98'], + ['4.0', '95'] +]); + +const windowsRelease = release => { + const version = /\d+\.\d/.exec(release || os.release()); + + if (release && !version) { + throw new Error('`release` argument doesn\'t match `n.n`'); + } + + const ver = (version || [])[0]; + + // Server 2008, 2012, 2016, and 2019 versions are ambiguous with desktop versions and must be detected at runtime. + // If `release` is omitted or we're on a Windows system, and the version number is an ambiguous version + // then use `wmic` to get the OS caption: https://msdn.microsoft.com/en-us/library/aa394531(v=vs.85).aspx + // If `wmic` is obsoloete (later versions of Windows 10), use PowerShell instead. + // If the resulting caption contains the year 2008, 2012, 2016 or 2019, it is a server version, so return a server OS name. + if ((!release || release === os.release()) && ['6.1', '6.2', '6.3', '10.0'].includes(ver)) { + let stdout; + try { + stdout = execa.sync('powershell', ['(Get-CimInstance -ClassName Win32_OperatingSystem).caption']).stdout || ''; + } catch (_) { + stdout = execa.sync('wmic', ['os', 'get', 'Caption']).stdout || ''; + } + + const year = (stdout.match(/2008|2012|2016|2019/) || [])[0]; + + if (year) { + return `Server ${year}`; + } + } + + return names.get(ver); +}; + +module.exports = windowsRelease; + + +/***/ }), + +/***/ 82: +/***/ (function(module, __unusedexports, __webpack_require__) { + +"use strict"; + + +var Type = __webpack_require__(945); + +var YAML_DATE_REGEXP = new RegExp( + '^([0-9][0-9][0-9][0-9])' + // [1] year + '-([0-9][0-9])' + // [2] month + '-([0-9][0-9])$'); // [3] day + +var YAML_TIMESTAMP_REGEXP = new RegExp( + '^([0-9][0-9][0-9][0-9])' + // [1] year + '-([0-9][0-9]?)' + // [2] month + '-([0-9][0-9]?)' + // [3] day + '(?:[Tt]|[ \\t]+)' + // ... + '([0-9][0-9]?)' + // [4] hour + ':([0-9][0-9])' + // [5] minute + ':([0-9][0-9])' + // [6] second + '(?:\\.([0-9]*))?' + // [7] fraction + '(?:[ \\t]*(Z|([-+])([0-9][0-9]?)' + // [8] tz [9] tz_sign [10] tz_hour + '(?::([0-9][0-9]))?))?$'); // [11] tz_minute + +function resolveYamlTimestamp(data) { + if (data === null) return false; + if (YAML_DATE_REGEXP.exec(data) !== null) return true; + if (YAML_TIMESTAMP_REGEXP.exec(data) !== null) return true; + return false; +} + +function constructYamlTimestamp(data) { + var match, year, month, day, hour, minute, second, fraction = 0, + delta = null, tz_hour, tz_minute, date; + + match = YAML_DATE_REGEXP.exec(data); + if (match === null) match = YAML_TIMESTAMP_REGEXP.exec(data); + + if (match === null) throw new Error('Date resolve error'); + + // match: [1] year [2] month [3] day + + year = +(match[1]); + month = +(match[2]) - 1; // JS month starts with 0 + day = +(match[3]); + + if (!match[4]) { // no hour + return new Date(Date.UTC(year, month, day)); + } + + // match: [4] hour [5] minute [6] second [7] fraction + + hour = +(match[4]); + minute = +(match[5]); + second = +(match[6]); + + if (match[7]) { + fraction = match[7].slice(0, 3); + while (fraction.length < 3) { // milli-seconds + fraction += '0'; + } + fraction = +fraction; + } + + // match: [8] tz [9] tz_sign [10] tz_hour [11] tz_minute + + if (match[9]) { + tz_hour = +(match[10]); + tz_minute = +(match[11] || 0); + delta = (tz_hour * 60 + tz_minute) * 60000; // delta in mili-seconds + if (match[9] === '-') delta = -delta; + } + + date = new Date(Date.UTC(year, month, day, hour, minute, second, fraction)); + + if (delta) date.setTime(date.getTime() - delta); + + return date; +} + +function representYamlTimestamp(object /*, style*/) { + return object.toISOString(); +} + +module.exports = new Type('tag:yaml.org,2002:timestamp', { + kind: 'scalar', + resolve: resolveYamlTimestamp, + construct: constructYamlTimestamp, + instanceOf: Date, + represent: representYamlTimestamp +}); + + +/***/ }), + +/***/ 87: +/***/ (function(module) { + +module.exports = require("os"); + +/***/ }), + +/***/ 93: +/***/ (function(module, __unusedexports, __webpack_require__) { + +"use strict"; + + + +var common = __webpack_require__(740); + + +function Mark(name, buffer, position, line, column) { + this.name = name; + this.buffer = buffer; + this.position = position; + this.line = line; + this.column = column; +} + + +Mark.prototype.getSnippet = function getSnippet(indent, maxLength) { + var head, start, tail, end, snippet; + + if (!this.buffer) return null; + + indent = indent || 4; + maxLength = maxLength || 75; + + head = ''; + start = this.position; + + while (start > 0 && '\x00\r\n\x85\u2028\u2029'.indexOf(this.buffer.charAt(start - 1)) === -1) { + start -= 1; + if (this.position - start > (maxLength / 2 - 1)) { + head = ' ... '; + start += 5; + break; + } + } + + tail = ''; + end = this.position; + + while (end < this.buffer.length && '\x00\r\n\x85\u2028\u2029'.indexOf(this.buffer.charAt(end)) === -1) { + end += 1; + if (end - this.position > (maxLength / 2 - 1)) { + tail = ' ... '; + end -= 5; + break; + } + } + + snippet = this.buffer.slice(start, end); + + return common.repeat(' ', indent) + head + snippet + tail + '\n' + + common.repeat(' ', indent + this.position - start + head.length) + '^'; +}; + + +Mark.prototype.toString = function toString(compact) { + var snippet, where = ''; + + if (this.name) { + where += 'in "' + this.name + '" '; + } + + where += 'at line ' + (this.line + 1) + ', column ' + (this.column + 1); + + if (!compact) { + snippet = this.getSnippet(); + + if (snippet) { + where += ':\n' + snippet; + } + } + + return where; +}; + + +module.exports = Mark; + + +/***/ }), + +/***/ 100: +/***/ (function(module, __unusedexports, __webpack_require__) { + +"use strict"; + + +var Type = __webpack_require__(945); + +var _hasOwnProperty = Object.prototype.hasOwnProperty; + +function resolveYamlSet(data) { + if (data === null) return true; + + var key, object = data; + + for (key in object) { + if (_hasOwnProperty.call(object, key)) { + if (object[key] !== null) return false; + } + } + + return true; +} + +function constructYamlSet(data) { + return data !== null ? data : {}; +} + +module.exports = new Type('tag:yaml.org,2002:set', { + kind: 'mapping', + resolve: resolveYamlSet, + construct: constructYamlSet +}); + + +/***/ }), + +/***/ 104: +/***/ (function(__unusedmodule, exports, __webpack_require__) { + +"use strict"; + +// A markdown renderer takes an `Analytics` structure and emits the +// data as markdown. +var __importStar = (this && this.__importStar) || function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k]; + result["default"] = mod; + return result; +}; +Object.defineProperty(exports, "__esModule", { value: true }); +const analytics_1 = __webpack_require__(847); +const fs = __importStar(__webpack_require__(747)); +class MarkdownRenderer { + constructor(config) { + if (config == null || config.output == null) { + throw new Error('invalid configuration for markdown renderer'); + } + let mdconfig = config.output; + if (mdconfig.format == null || mdconfig.format != 'markdown') { + throw new Error(`config: 'output.format' expected as 'markdown'`); + } + if (mdconfig.filename == null) { + throw new Error(`config: 'output.filename' is not defined`); + } + this.config = mdconfig; + } + static renderColor(color) { + if (color == 'red') { + return '🔴'; + } + else if (color == 'yellow') { + return '💛'; + } + else if (color == 'green') { + return '✅'; + } + else if (color == 'blue') { + return '🔷'; + } + else if (color == 'black') { + return '⬛️'; + } + throw new Error(`invalid color: ${color}`); + } + static renderNumberWidget(widget) { + let value = widget.value; + let color = widget.color; + let out = value.toString(); + if (color != null) { + out = `${MarkdownRenderer.renderColor(color)} ${out}`; + } + if (widget.url != null) { + out = `[${out}](${widget.url})`; + } + return out; + } + static renderStringWidget(widget) { + let value = widget.value; + let color = widget.color; + let md = new Array; + if (widget.title != null) { + md.push(`#### ${widget.title}\n`); + md.push('\n'); + } + if (widget.url != null) { + md.push('['); + } + if (color != null) { + md.push(`${MarkdownRenderer.renderColor(color)} `); + } + md.push(value); + if (widget.url != null) { + md.push(`](${widget.url})`); + } + md.push('\n'); + return md.join(''); + } + static renderGraphWidget(widget) { + // length of the bar (on-screen) at the largest value + // TODO: account for the length of titles and values + const BAR_LENGTH = 35; + let md = new Array(); + let min = 0; + let max = 0; + for (let element of widget.elements) { + if (!(element instanceof analytics_1.NumberWidget)) { + throw new Error(`GraphWidget element did not evaluate to a NumberWidget (is a ${widget.constructor.name})`); + } + let num = element; + if (typeof num.value != 'number') { + throw new Error(`GraphWidget element did not evaluate to a static number (is a ${typeof num.value})`); + } + let value = num.value; + if (value > max) { + max = value; + } + } + // TODO: scale this by accounting for the minimum value, to avoid + // large numbers with little variance blowing out the graph + let scale = (BAR_LENGTH / max); + // To get the numbers left and right-aligned, add non-breaking space + // between them. A number is roughly the size of the block unicode + // glyph, a non-breaking space is roughly n times those glyphs + let spacerlen = Math.floor((BAR_LENGTH - (min.toString().length - max.toString().length)) * 3.75); + let spacer = ' '.repeat(spacerlen); + if (widget.title) { + md.push(`#### ${widget.title}`); + md.push(''); + } + md.push(`| ${widget.title ? widget.title : ''} | | ${min}${spacer}${max} |`); + md.push(`|:------------------------------------|-:|:-------|`); + for (let element of widget.elements) { + let num = element; + let value = num.value; + let bar = '█'.repeat(value * scale); + md.push(`| ${num.title ? num.title : ''} | ${MarkdownRenderer.renderNumberWidget(num)} | ${bar} |`); + } + md.push(''); + return md.join('\n'); + } + static renderTableCell(widget) { + if (!(widget instanceof analytics_1.NumberWidget) && !(widget instanceof analytics_1.StringWidget)) { + throw new Error(`TableWidget header cell did not evaluate to a static value (is a ${typeof widget})`); + } + let value = widget.value; + let color = widget.color; + let out = value.toString(); + if (color != null) { + out = `${MarkdownRenderer.renderColor(color)} ${out}`; + } + if (widget.url != null) { + out = `[${out}](${widget.url})`; + } + return out; + } + static renderTableWidget(widget) { + let md = new Array(); + let line; + let columns = (widget.headers != null) ? widget.headers.length : 0; + // Find the maximum number of columns + for (let row of widget.elements) { + if (row.length > columns) { + columns = row.length; + } + } + if (columns == 0) { + return ''; + } + if (widget.title) { + md.push(`#### ${widget.title}`); + md.push(''); + } + // Draw header + line = new Array(); + line.push('|'); + for (let i = 0; i < columns; i++) { + line.push(' '); + if (widget.headers != null && i < widget.headers.length) { + line.push(MarkdownRenderer.renderTableCell(widget.headers[i])); + } + line.push(' |'); + } + md.push(line.join('')); + // Draw header/element separator lines + line = new Array(); + line.push('|'); + for (let i = 0; i < columns; i++) { + let align = (widget.headers != null && i < widget.headers.length && widget.headers[i] instanceof analytics_1.StringWidget) ? widget.headers[i].align : null; + if (align == 'left') { + line.push(':--'); + } + else if (align == 'center') { + line.push(':-:'); + } + else if (align == 'right') { + line.push('--:'); + } + else { + line.push('---'); + } + line.push('|'); + } + md.push(line.join('')); + // Draw elements + for (let row of widget.elements) { + line = new Array(); + line.push('|'); + for (let i = 0; i < columns; i++) { + line.push(' '); + line.push(MarkdownRenderer.renderTableCell(row[i])); + line.push(' |'); + } + md.push(line.join('')); + } + return md.join('\n'); + } + static renderAnalytics(analytics) { + let md = new Array(); + if (analytics.title != null) { + md.push(`# ${analytics.title}`); + md.push(''); + } + if (analytics.description != null) { + md.push(analytics.description); + md.push(''); + } + for (let section of analytics.sections) { + if (section.title != null) { + md.push(`## ${section.title}`); + md.push(''); + } + if (section.description != null) { + md.push(section.description); + md.push(''); + } + let showingNumberWidgets = false; + for (let widget of section.widgets) { + if (widget instanceof analytics_1.NumberWidget) { + // Group the number widgets together + if (!showingNumberWidgets) { + md.push('| Query | |'); + md.push('|:------|-:|'); + showingNumberWidgets = true; + } + md.push(`| ${widget.title ? widget.title : ''} | ${MarkdownRenderer.renderNumberWidget(widget)} |`); + continue; + } + if (showingNumberWidgets) { + md.push(''); + showingNumberWidgets = false; + } + if (widget instanceof analytics_1.StringWidget) { + md.push(MarkdownRenderer.renderStringWidget(widget)); + } + else if (widget instanceof analytics_1.GraphWidget) { + md.push(MarkdownRenderer.renderGraphWidget(widget)); + } + else if (widget instanceof analytics_1.TableWidget) { + md.push(MarkdownRenderer.renderTableWidget(widget)); + } + else { + throw new Error(`cannot render unknown widget type: ${widget.constructor.name}`); + } + } + } + md.push(''); + return md.join('\n'); + } + render(analytics) { + fs.writeFileSync(this.config.filename, MarkdownRenderer.renderAnalytics(analytics), 'utf8'); + } +} +exports.MarkdownRenderer = MarkdownRenderer; + + +/***/ }), + +/***/ 118: +/***/ (function(module, __unusedexports, __webpack_require__) { + +"use strict"; + +const os = __webpack_require__(87); + +const nameMap = new Map([ + [19, 'Catalina'], + [18, 'Mojave'], + [17, 'High Sierra'], + [16, 'Sierra'], + [15, 'El Capitan'], + [14, 'Yosemite'], + [13, 'Mavericks'], + [12, 'Mountain Lion'], + [11, 'Lion'], + [10, 'Snow Leopard'], + [9, 'Leopard'], + [8, 'Tiger'], + [7, 'Panther'], + [6, 'Jaguar'], + [5, 'Puma'] +]); + +const macosRelease = release => { + release = Number((release || os.release()).split('.')[0]); + return { + name: nameMap.get(release), + version: '10.' + (release - 4) + }; +}; + +module.exports = macosRelease; +// TODO: remove this in the next major version +module.exports.default = macosRelease; + + +/***/ }), + +/***/ 126: +/***/ (function(module) { + +/** + * lodash (Custom Build) + * Build: `lodash modularize exports="npm" -o ./` + * Copyright jQuery Foundation and other contributors + * Released under MIT license + * Based on Underscore.js 1.8.3 + * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors + */ + +/** Used as the size to enable large array optimizations. */ +var LARGE_ARRAY_SIZE = 200; + +/** Used to stand-in for `undefined` hash values. */ +var HASH_UNDEFINED = '__lodash_hash_undefined__'; + +/** Used as references for various `Number` constants. */ +var INFINITY = 1 / 0; + +/** `Object#toString` result references. */ +var funcTag = '[object Function]', + genTag = '[object GeneratorFunction]'; + +/** + * Used to match `RegExp` + * [syntax characters](http://ecma-international.org/ecma-262/7.0/#sec-patterns). + */ +var reRegExpChar = /[\\^$.*+?()[\]{}|]/g; + +/** Used to detect host constructors (Safari). */ +var reIsHostCtor = /^\[object .+?Constructor\]$/; + +/** Detect free variable `global` from Node.js. */ +var freeGlobal = typeof global == 'object' && global && global.Object === Object && global; + +/** Detect free variable `self`. */ +var freeSelf = typeof self == 'object' && self && self.Object === Object && self; + +/** Used as a reference to the global object. */ +var root = freeGlobal || freeSelf || Function('return this')(); + +/** + * A specialized version of `_.includes` for arrays without support for + * specifying an index to search from. + * + * @private + * @param {Array} [array] The array to inspect. + * @param {*} target The value to search for. + * @returns {boolean} Returns `true` if `target` is found, else `false`. + */ +function arrayIncludes(array, value) { + var length = array ? array.length : 0; + return !!length && baseIndexOf(array, value, 0) > -1; +} + +/** + * This function is like `arrayIncludes` except that it accepts a comparator. + * + * @private + * @param {Array} [array] The array to inspect. + * @param {*} target The value to search for. + * @param {Function} comparator The comparator invoked per element. + * @returns {boolean} Returns `true` if `target` is found, else `false`. + */ +function arrayIncludesWith(array, value, comparator) { + var index = -1, + length = array ? array.length : 0; + + while (++index < length) { + if (comparator(value, array[index])) { + return true; + } + } + return false; +} + +/** + * The base implementation of `_.findIndex` and `_.findLastIndex` without + * support for iteratee shorthands. + * + * @private + * @param {Array} array The array to inspect. + * @param {Function} predicate The function invoked per iteration. + * @param {number} fromIndex The index to search from. + * @param {boolean} [fromRight] Specify iterating from right to left. + * @returns {number} Returns the index of the matched value, else `-1`. + */ +function baseFindIndex(array, predicate, fromIndex, fromRight) { + var length = array.length, + index = fromIndex + (fromRight ? 1 : -1); + + while ((fromRight ? index-- : ++index < length)) { + if (predicate(array[index], index, array)) { + return index; + } + } + return -1; +} + +/** + * The base implementation of `_.indexOf` without `fromIndex` bounds checks. + * + * @private + * @param {Array} array The array to inspect. + * @param {*} value The value to search for. + * @param {number} fromIndex The index to search from. + * @returns {number} Returns the index of the matched value, else `-1`. + */ +function baseIndexOf(array, value, fromIndex) { + if (value !== value) { + return baseFindIndex(array, baseIsNaN, fromIndex); + } + var index = fromIndex - 1, + length = array.length; + + while (++index < length) { + if (array[index] === value) { + return index; + } + } + return -1; +} + +/** + * The base implementation of `_.isNaN` without support for number objects. + * + * @private + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is `NaN`, else `false`. + */ +function baseIsNaN(value) { + return value !== value; +} + +/** + * Checks if a cache value for `key` exists. + * + * @private + * @param {Object} cache The cache to query. + * @param {string} key The key of the entry to check. + * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`. + */ +function cacheHas(cache, key) { + return cache.has(key); +} + +/** + * Gets the value at `key` of `object`. + * + * @private + * @param {Object} [object] The object to query. + * @param {string} key The key of the property to get. + * @returns {*} Returns the property value. + */ +function getValue(object, key) { + return object == null ? undefined : object[key]; +} + +/** + * Checks if `value` is a host object in IE < 9. + * + * @private + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a host object, else `false`. + */ +function isHostObject(value) { + // Many host objects are `Object` objects that can coerce to strings + // despite having improperly defined `toString` methods. + var result = false; + if (value != null && typeof value.toString != 'function') { + try { + result = !!(value + ''); + } catch (e) {} + } + return result; +} + +/** + * Converts `set` to an array of its values. + * + * @private + * @param {Object} set The set to convert. + * @returns {Array} Returns the values. + */ +function setToArray(set) { + var index = -1, + result = Array(set.size); + + set.forEach(function(value) { + result[++index] = value; + }); + return result; +} + +/** Used for built-in method references. */ +var arrayProto = Array.prototype, + funcProto = Function.prototype, + objectProto = Object.prototype; + +/** Used to detect overreaching core-js shims. */ +var coreJsData = root['__core-js_shared__']; + +/** Used to detect methods masquerading as native. */ +var maskSrcKey = (function() { + var uid = /[^.]+$/.exec(coreJsData && coreJsData.keys && coreJsData.keys.IE_PROTO || ''); + return uid ? ('Symbol(src)_1.' + uid) : ''; +}()); + +/** Used to resolve the decompiled source of functions. */ +var funcToString = funcProto.toString; + +/** Used to check objects for own properties. */ +var hasOwnProperty = objectProto.hasOwnProperty; + +/** + * Used to resolve the + * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring) + * of values. + */ +var objectToString = objectProto.toString; + +/** Used to detect if a method is native. */ +var reIsNative = RegExp('^' + + funcToString.call(hasOwnProperty).replace(reRegExpChar, '\\$&') + .replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, '$1.*?') + '$' +); + +/** Built-in value references. */ +var splice = arrayProto.splice; + +/* Built-in method references that are verified to be native. */ +var Map = getNative(root, 'Map'), + Set = getNative(root, 'Set'), + nativeCreate = getNative(Object, 'create'); + +/** + * Creates a hash object. + * + * @private + * @constructor + * @param {Array} [entries] The key-value pairs to cache. + */ +function Hash(entries) { + var index = -1, + length = entries ? entries.length : 0; + + this.clear(); + while (++index < length) { + var entry = entries[index]; + this.set(entry[0], entry[1]); + } +} + +/** + * Removes all key-value entries from the hash. + * + * @private + * @name clear + * @memberOf Hash + */ +function hashClear() { + this.__data__ = nativeCreate ? nativeCreate(null) : {}; +} + +/** + * Removes `key` and its value from the hash. + * + * @private + * @name delete + * @memberOf Hash + * @param {Object} hash The hash to modify. + * @param {string} key The key of the value to remove. + * @returns {boolean} Returns `true` if the entry was removed, else `false`. + */ +function hashDelete(key) { + return this.has(key) && delete this.__data__[key]; +} + +/** + * Gets the hash value for `key`. + * + * @private + * @name get + * @memberOf Hash + * @param {string} key The key of the value to get. + * @returns {*} Returns the entry value. + */ +function hashGet(key) { + var data = this.__data__; + if (nativeCreate) { + var result = data[key]; + return result === HASH_UNDEFINED ? undefined : result; + } + return hasOwnProperty.call(data, key) ? data[key] : undefined; +} + +/** + * Checks if a hash value for `key` exists. + * + * @private + * @name has + * @memberOf Hash + * @param {string} key The key of the entry to check. + * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`. + */ +function hashHas(key) { + var data = this.__data__; + return nativeCreate ? data[key] !== undefined : hasOwnProperty.call(data, key); +} + +/** + * Sets the hash `key` to `value`. + * + * @private + * @name set + * @memberOf Hash + * @param {string} key The key of the value to set. + * @param {*} value The value to set. + * @returns {Object} Returns the hash instance. + */ +function hashSet(key, value) { + var data = this.__data__; + data[key] = (nativeCreate && value === undefined) ? HASH_UNDEFINED : value; + return this; +} + +// Add methods to `Hash`. +Hash.prototype.clear = hashClear; +Hash.prototype['delete'] = hashDelete; +Hash.prototype.get = hashGet; +Hash.prototype.has = hashHas; +Hash.prototype.set = hashSet; + +/** + * Creates an list cache object. + * + * @private + * @constructor + * @param {Array} [entries] The key-value pairs to cache. + */ +function ListCache(entries) { + var index = -1, + length = entries ? entries.length : 0; + + this.clear(); + while (++index < length) { + var entry = entries[index]; + this.set(entry[0], entry[1]); + } +} + +/** + * Removes all key-value entries from the list cache. + * + * @private + * @name clear + * @memberOf ListCache + */ +function listCacheClear() { + this.__data__ = []; +} + +/** + * Removes `key` and its value from the list cache. + * + * @private + * @name delete + * @memberOf ListCache + * @param {string} key The key of the value to remove. + * @returns {boolean} Returns `true` if the entry was removed, else `false`. + */ +function listCacheDelete(key) { + var data = this.__data__, + index = assocIndexOf(data, key); + + if (index < 0) { + return false; + } + var lastIndex = data.length - 1; + if (index == lastIndex) { + data.pop(); + } else { + splice.call(data, index, 1); + } + return true; +} + +/** + * Gets the list cache value for `key`. + * + * @private + * @name get + * @memberOf ListCache + * @param {string} key The key of the value to get. + * @returns {*} Returns the entry value. + */ +function listCacheGet(key) { + var data = this.__data__, + index = assocIndexOf(data, key); + + return index < 0 ? undefined : data[index][1]; +} + +/** + * Checks if a list cache value for `key` exists. + * + * @private + * @name has + * @memberOf ListCache + * @param {string} key The key of the entry to check. + * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`. + */ +function listCacheHas(key) { + return assocIndexOf(this.__data__, key) > -1; +} + +/** + * Sets the list cache `key` to `value`. + * + * @private + * @name set + * @memberOf ListCache + * @param {string} key The key of the value to set. + * @param {*} value The value to set. + * @returns {Object} Returns the list cache instance. + */ +function listCacheSet(key, value) { + var data = this.__data__, + index = assocIndexOf(data, key); + + if (index < 0) { + data.push([key, value]); + } else { + data[index][1] = value; + } + return this; +} + +// Add methods to `ListCache`. +ListCache.prototype.clear = listCacheClear; +ListCache.prototype['delete'] = listCacheDelete; +ListCache.prototype.get = listCacheGet; +ListCache.prototype.has = listCacheHas; +ListCache.prototype.set = listCacheSet; + +/** + * Creates a map cache object to store key-value pairs. + * + * @private + * @constructor + * @param {Array} [entries] The key-value pairs to cache. + */ +function MapCache(entries) { + var index = -1, + length = entries ? entries.length : 0; + + this.clear(); + while (++index < length) { + var entry = entries[index]; + this.set(entry[0], entry[1]); + } +} + +/** + * Removes all key-value entries from the map. + * + * @private + * @name clear + * @memberOf MapCache + */ +function mapCacheClear() { + this.__data__ = { + 'hash': new Hash, + 'map': new (Map || ListCache), + 'string': new Hash + }; +} + +/** + * Removes `key` and its value from the map. + * + * @private + * @name delete + * @memberOf MapCache + * @param {string} key The key of the value to remove. + * @returns {boolean} Returns `true` if the entry was removed, else `false`. + */ +function mapCacheDelete(key) { + return getMapData(this, key)['delete'](key); +} + +/** + * Gets the map value for `key`. + * + * @private + * @name get + * @memberOf MapCache + * @param {string} key The key of the value to get. + * @returns {*} Returns the entry value. + */ +function mapCacheGet(key) { + return getMapData(this, key).get(key); +} + +/** + * Checks if a map value for `key` exists. + * + * @private + * @name has + * @memberOf MapCache + * @param {string} key The key of the entry to check. + * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`. + */ +function mapCacheHas(key) { + return getMapData(this, key).has(key); +} + +/** + * Sets the map `key` to `value`. + * + * @private + * @name set + * @memberOf MapCache + * @param {string} key The key of the value to set. + * @param {*} value The value to set. + * @returns {Object} Returns the map cache instance. + */ +function mapCacheSet(key, value) { + getMapData(this, key).set(key, value); + return this; +} + +// Add methods to `MapCache`. +MapCache.prototype.clear = mapCacheClear; +MapCache.prototype['delete'] = mapCacheDelete; +MapCache.prototype.get = mapCacheGet; +MapCache.prototype.has = mapCacheHas; +MapCache.prototype.set = mapCacheSet; + +/** + * + * Creates an array cache object to store unique values. + * + * @private + * @constructor + * @param {Array} [values] The values to cache. + */ +function SetCache(values) { + var index = -1, + length = values ? values.length : 0; + + this.__data__ = new MapCache; + while (++index < length) { + this.add(values[index]); + } +} + +/** + * Adds `value` to the array cache. + * + * @private + * @name add + * @memberOf SetCache + * @alias push + * @param {*} value The value to cache. + * @returns {Object} Returns the cache instance. + */ +function setCacheAdd(value) { + this.__data__.set(value, HASH_UNDEFINED); + return this; +} + +/** + * Checks if `value` is in the array cache. + * + * @private + * @name has + * @memberOf SetCache + * @param {*} value The value to search for. + * @returns {number} Returns `true` if `value` is found, else `false`. + */ +function setCacheHas(value) { + return this.__data__.has(value); +} + +// Add methods to `SetCache`. +SetCache.prototype.add = SetCache.prototype.push = setCacheAdd; +SetCache.prototype.has = setCacheHas; + +/** + * Gets the index at which the `key` is found in `array` of key-value pairs. + * + * @private + * @param {Array} array The array to inspect. + * @param {*} key The key to search for. + * @returns {number} Returns the index of the matched value, else `-1`. + */ +function assocIndexOf(array, key) { + var length = array.length; + while (length--) { + if (eq(array[length][0], key)) { + return length; + } + } + return -1; +} + +/** + * The base implementation of `_.isNative` without bad shim checks. + * + * @private + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a native function, + * else `false`. + */ +function baseIsNative(value) { + if (!isObject(value) || isMasked(value)) { + return false; + } + var pattern = (isFunction(value) || isHostObject(value)) ? reIsNative : reIsHostCtor; + return pattern.test(toSource(value)); +} + +/** + * The base implementation of `_.uniqBy` without support for iteratee shorthands. + * + * @private + * @param {Array} array The array to inspect. + * @param {Function} [iteratee] The iteratee invoked per element. + * @param {Function} [comparator] The comparator invoked per element. + * @returns {Array} Returns the new duplicate free array. + */ +function baseUniq(array, iteratee, comparator) { + var index = -1, + includes = arrayIncludes, + length = array.length, + isCommon = true, + result = [], + seen = result; + + if (comparator) { + isCommon = false; + includes = arrayIncludesWith; + } + else if (length >= LARGE_ARRAY_SIZE) { + var set = iteratee ? null : createSet(array); + if (set) { + return setToArray(set); + } + isCommon = false; + includes = cacheHas; + seen = new SetCache; + } + else { + seen = iteratee ? [] : result; + } + outer: + while (++index < length) { + var value = array[index], + computed = iteratee ? iteratee(value) : value; + + value = (comparator || value !== 0) ? value : 0; + if (isCommon && computed === computed) { + var seenIndex = seen.length; + while (seenIndex--) { + if (seen[seenIndex] === computed) { + continue outer; + } + } + if (iteratee) { + seen.push(computed); + } + result.push(value); + } + else if (!includes(seen, computed, comparator)) { + if (seen !== result) { + seen.push(computed); + } + result.push(value); + } + } + return result; +} + +/** + * Creates a set object of `values`. + * + * @private + * @param {Array} values The values to add to the set. + * @returns {Object} Returns the new set. + */ +var createSet = !(Set && (1 / setToArray(new Set([,-0]))[1]) == INFINITY) ? noop : function(values) { + return new Set(values); +}; + +/** + * Gets the data for `map`. + * + * @private + * @param {Object} map The map to query. + * @param {string} key The reference key. + * @returns {*} Returns the map data. + */ +function getMapData(map, key) { + var data = map.__data__; + return isKeyable(key) + ? data[typeof key == 'string' ? 'string' : 'hash'] + : data.map; +} + +/** + * Gets the native function at `key` of `object`. + * + * @private + * @param {Object} object The object to query. + * @param {string} key The key of the method to get. + * @returns {*} Returns the function if it's native, else `undefined`. + */ +function getNative(object, key) { + var value = getValue(object, key); + return baseIsNative(value) ? value : undefined; +} + +/** + * Checks if `value` is suitable for use as unique object key. + * + * @private + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is suitable, else `false`. + */ +function isKeyable(value) { + var type = typeof value; + return (type == 'string' || type == 'number' || type == 'symbol' || type == 'boolean') + ? (value !== '__proto__') + : (value === null); +} + +/** + * Checks if `func` has its source masked. + * + * @private + * @param {Function} func The function to check. + * @returns {boolean} Returns `true` if `func` is masked, else `false`. + */ +function isMasked(func) { + return !!maskSrcKey && (maskSrcKey in func); +} + +/** + * Converts `func` to its source code. + * + * @private + * @param {Function} func The function to process. + * @returns {string} Returns the source code. + */ +function toSource(func) { + if (func != null) { + try { + return funcToString.call(func); + } catch (e) {} + try { + return (func + ''); + } catch (e) {} + } + return ''; +} + +/** + * Creates a duplicate-free version of an array, using + * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero) + * for equality comparisons, in which only the first occurrence of each + * element is kept. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Array + * @param {Array} array The array to inspect. + * @returns {Array} Returns the new duplicate free array. + * @example + * + * _.uniq([2, 1, 2]); + * // => [2, 1] + */ +function uniq(array) { + return (array && array.length) + ? baseUniq(array) + : []; +} + +/** + * Performs a + * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero) + * comparison between two values to determine if they are equivalent. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Lang + * @param {*} value The value to compare. + * @param {*} other The other value to compare. + * @returns {boolean} Returns `true` if the values are equivalent, else `false`. + * @example + * + * var object = { 'a': 1 }; + * var other = { 'a': 1 }; + * + * _.eq(object, object); + * // => true + * + * _.eq(object, other); + * // => false + * + * _.eq('a', 'a'); + * // => true + * + * _.eq('a', Object('a')); + * // => false + * + * _.eq(NaN, NaN); + * // => true + */ +function eq(value, other) { + return value === other || (value !== value && other !== other); +} + +/** + * Checks if `value` is classified as a `Function` object. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a function, else `false`. + * @example + * + * _.isFunction(_); + * // => true + * + * _.isFunction(/abc/); + * // => false + */ +function isFunction(value) { + // The use of `Object#toString` avoids issues with the `typeof` operator + // in Safari 8-9 which returns 'object' for typed array and other constructors. + var tag = isObject(value) ? objectToString.call(value) : ''; + return tag == funcTag || tag == genTag; +} + +/** + * Checks if `value` is the + * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types) + * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`) + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is an object, else `false`. + * @example + * + * _.isObject({}); + * // => true + * + * _.isObject([1, 2, 3]); + * // => true + * + * _.isObject(_.noop); + * // => true + * + * _.isObject(null); + * // => false + */ +function isObject(value) { + var type = typeof value; + return !!value && (type == 'object' || type == 'function'); +} + +/** + * This method returns `undefined`. + * + * @static + * @memberOf _ + * @since 2.3.0 + * @category Util + * @example + * + * _.times(2, _.noop); + * // => [undefined, undefined] + */ +function noop() { + // No operation performed. +} + +module.exports = uniq; + + +/***/ }), + +/***/ 129: +/***/ (function(module) { + +module.exports = require("child_process"); + +/***/ }), + +/***/ 130: +/***/ (function(module) { + +!function(t,i){ true?module.exports=i():undefined}(this,function(){"use strict";return function(t,i,e){var s=(new Date).getTimezoneOffset(),n=i.prototype;e.utc=function(t,e){return new i({date:t,utc:!0,format:e})},n.utc=function(){return e(this.toDate(),{locale:this.$L,utc:!0})},n.local=function(){return e(this.toDate(),{locale:this.$L,utc:!1})};var u=n.parse;n.parse=function(t){t.utc&&(this.$u=!0),this.$utils().u(t.$offset)||(this.$offset=t.$offset),u.call(this,t)};var o=n.init;n.init=function(){if(this.$u){var t=this.$d;this.$y=t.getUTCFullYear(),this.$M=t.getUTCMonth(),this.$D=t.getUTCDate(),this.$W=t.getUTCDay(),this.$H=t.getUTCHours(),this.$m=t.getUTCMinutes(),this.$s=t.getUTCSeconds(),this.$ms=t.getUTCMilliseconds()}else o.call(this)};var f=n.utcOffset;n.utcOffset=function(t){var i=this.$utils().u;if(i(t))return this.$u?0:i(this.$offset)?f.call(this):this.$offset;var e,n=Math.abs(t)<=16?60*t:t;return 0!==t?(e=this.local().add(n+s,"minute")).$offset=n:e=this.utc(),e};var r=n.format;n.format=function(t){var i=t||(this.$u?"YYYY-MM-DDTHH:mm:ss[Z]":"");return r.call(this,i)},n.valueOf=function(){var t=this.$utils().u(this.$offset)?0:this.$offset+s;return this.$d.valueOf()-6e4*t},n.isUTC=function(){return!!this.$u},n.toISOString=function(){return this.toDate().toISOString()},n.toString=function(){return this.toDate().toUTCString()};var a=n.toDate;n.toDate=function(t){return"s"===t&&this.$offset?e(this.format("YYYY-MM-DD HH:mm:ss:SSS")).toDate():a.call(this)}}}); + + +/***/ }), + +/***/ 141: +/***/ (function(__unusedmodule, exports, __webpack_require__) { + +"use strict"; + + +var net = __webpack_require__(631); +var tls = __webpack_require__(16); +var http = __webpack_require__(605); +var https = __webpack_require__(34); +var events = __webpack_require__(614); +var assert = __webpack_require__(357); +var util = __webpack_require__(669); + + +exports.httpOverHttp = httpOverHttp; +exports.httpsOverHttp = httpsOverHttp; +exports.httpOverHttps = httpOverHttps; +exports.httpsOverHttps = httpsOverHttps; + + +function httpOverHttp(options) { + var agent = new TunnelingAgent(options); + agent.request = http.request; + return agent; +} + +function httpsOverHttp(options) { + var agent = new TunnelingAgent(options); + agent.request = http.request; + agent.createSocket = createSecureSocket; + agent.defaultPort = 443; + return agent; +} + +function httpOverHttps(options) { + var agent = new TunnelingAgent(options); + agent.request = https.request; + return agent; +} + +function httpsOverHttps(options) { + var agent = new TunnelingAgent(options); + agent.request = https.request; + agent.createSocket = createSecureSocket; + agent.defaultPort = 443; + return agent; +} + + +function TunnelingAgent(options) { + var self = this; + self.options = options || {}; + self.proxyOptions = self.options.proxy || {}; + self.maxSockets = self.options.maxSockets || http.Agent.defaultMaxSockets; + self.requests = []; + self.sockets = []; + + self.on('free', function onFree(socket, host, port, localAddress) { + var options = toOptions(host, port, localAddress); + for (var i = 0, len = self.requests.length; i < len; ++i) { + var pending = self.requests[i]; + if (pending.host === options.host && pending.port === options.port) { + // Detect the request to connect same origin server, + // reuse the connection. + self.requests.splice(i, 1); + pending.request.onSocket(socket); + return; + } + } + socket.destroy(); + self.removeSocket(socket); + }); +} +util.inherits(TunnelingAgent, events.EventEmitter); + +TunnelingAgent.prototype.addRequest = function addRequest(req, host, port, localAddress) { + var self = this; + var options = mergeOptions({request: req}, self.options, toOptions(host, port, localAddress)); + + if (self.sockets.length >= this.maxSockets) { + // We are over limit so we'll add it to the queue. + self.requests.push(options); + return; + } + + // If we are under maxSockets create a new one. + self.createSocket(options, function(socket) { + socket.on('free', onFree); + socket.on('close', onCloseOrRemove); + socket.on('agentRemove', onCloseOrRemove); + req.onSocket(socket); + + function onFree() { + self.emit('free', socket, options); + } + + function onCloseOrRemove(err) { + self.removeSocket(socket); + socket.removeListener('free', onFree); + socket.removeListener('close', onCloseOrRemove); + socket.removeListener('agentRemove', onCloseOrRemove); + } + }); +}; + +TunnelingAgent.prototype.createSocket = function createSocket(options, cb) { + var self = this; + var placeholder = {}; + self.sockets.push(placeholder); + + var connectOptions = mergeOptions({}, self.proxyOptions, { + method: 'CONNECT', + path: options.host + ':' + options.port, + agent: false, + headers: { + host: options.host + ':' + options.port + } + }); + if (options.localAddress) { + connectOptions.localAddress = options.localAddress; + } + if (connectOptions.proxyAuth) { + connectOptions.headers = connectOptions.headers || {}; + connectOptions.headers['Proxy-Authorization'] = 'Basic ' + + new Buffer(connectOptions.proxyAuth).toString('base64'); + } + + debug('making CONNECT request'); + var connectReq = self.request(connectOptions); + connectReq.useChunkedEncodingByDefault = false; // for v0.6 + connectReq.once('response', onResponse); // for v0.6 + connectReq.once('upgrade', onUpgrade); // for v0.6 + connectReq.once('connect', onConnect); // for v0.7 or later + connectReq.once('error', onError); + connectReq.end(); + + function onResponse(res) { + // Very hacky. This is necessary to avoid http-parser leaks. + res.upgrade = true; + } + + function onUpgrade(res, socket, head) { + // Hacky. + process.nextTick(function() { + onConnect(res, socket, head); + }); + } + + function onConnect(res, socket, head) { + connectReq.removeAllListeners(); + socket.removeAllListeners(); + + if (res.statusCode !== 200) { + debug('tunneling socket could not be established, statusCode=%d', + res.statusCode); + socket.destroy(); + var error = new Error('tunneling socket could not be established, ' + + 'statusCode=' + res.statusCode); + error.code = 'ECONNRESET'; + options.request.emit('error', error); + self.removeSocket(placeholder); + return; + } + if (head.length > 0) { + debug('got illegal response body from proxy'); + socket.destroy(); + var error = new Error('got illegal response body from proxy'); + error.code = 'ECONNRESET'; + options.request.emit('error', error); + self.removeSocket(placeholder); + return; + } + debug('tunneling connection has established'); + self.sockets[self.sockets.indexOf(placeholder)] = socket; + return cb(socket); + } + + function onError(cause) { + connectReq.removeAllListeners(); + + debug('tunneling socket could not be established, cause=%s\n', + cause.message, cause.stack); + var error = new Error('tunneling socket could not be established, ' + + 'cause=' + cause.message); + error.code = 'ECONNRESET'; + options.request.emit('error', error); + self.removeSocket(placeholder); + } +}; + +TunnelingAgent.prototype.removeSocket = function removeSocket(socket) { + var pos = this.sockets.indexOf(socket) + if (pos === -1) { + return; + } + this.sockets.splice(pos, 1); + + var pending = this.requests.shift(); + if (pending) { + // If we have pending requests and a socket gets closed a new one + // needs to be created to take over in the pool for the one that closed. + this.createSocket(pending, function(socket) { + pending.request.onSocket(socket); + }); + } +}; + +function createSecureSocket(options, cb) { + var self = this; + TunnelingAgent.prototype.createSocket.call(self, options, function(socket) { + var hostHeader = options.request.getHeader('host'); + var tlsOptions = mergeOptions({}, self.options, { + socket: socket, + servername: hostHeader ? hostHeader.replace(/:.*$/, '') : options.host + }); + + // 0 is dummy port for v0.6 + var secureSocket = tls.connect(0, tlsOptions); + self.sockets[self.sockets.indexOf(socket)] = secureSocket; + cb(secureSocket); + }); +} + + +function toOptions(host, port, localAddress) { + if (typeof host === 'string') { // since v0.10 + return { + host: host, + port: port, + localAddress: localAddress + }; + } + return host; // for v0.11 or later +} + +function mergeOptions(target) { + for (var i = 1, len = arguments.length; i < len; ++i) { + var overrides = arguments[i]; + if (typeof overrides === 'object') { + var keys = Object.keys(overrides); + for (var j = 0, keyLen = keys.length; j < keyLen; ++j) { + var k = keys[j]; + if (overrides[k] !== undefined) { + target[k] = overrides[k]; + } + } + } + } + return target; +} + + +var debug; +if (process.env.NODE_DEBUG && /\btunnel\b/.test(process.env.NODE_DEBUG)) { + debug = function() { + var args = Array.prototype.slice.call(arguments); + if (typeof args[0] === 'string') { + args[0] = 'TUNNEL: ' + args[0]; + } else { + args.unshift('TUNNEL:'); + } + console.error.apply(console, args); + } +} else { + debug = function() {}; +} +exports.debug = debug; // for test + + +/***/ }), + +/***/ 143: +/***/ (function(module, __unusedexports, __webpack_require__) { + +module.exports = withAuthorizationPrefix; + +const atob = __webpack_require__(368); + +const REGEX_IS_BASIC_AUTH = /^[\w-]+:/; + +function withAuthorizationPrefix(authorization) { + if (/^(basic|bearer|token) /i.test(authorization)) { + return authorization; + } + + try { + if (REGEX_IS_BASIC_AUTH.test(atob(authorization))) { + return `basic ${authorization}`; + } + } catch (error) {} + + if (authorization.split(/\./).length === 3) { + return `bearer ${authorization}`; + } + + return `token ${authorization}`; +} + + +/***/ }), + +/***/ 144: +/***/ (function(__unusedmodule, exports, __webpack_require__) { + +"use strict"; + +// An HTML renderer takes an `Analytics` structure and emits the output +// as HTML. +var __importStar = (this && this.__importStar) || function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k]; + result["default"] = mod; + return result; +}; +Object.defineProperty(exports, "__esModule", { value: true }); +const analytics_1 = __webpack_require__(847); +const fs = __importStar(__webpack_require__(747)); +function createAnchor(title) { + return title.replace(/ /g, '-').replace(/[^A-Za-z0-9_\-]/g, '').toLowerCase(); +} +class HtmlRenderer { + constructor(config) { + if (config == null || config.output == null) { + throw new Error('invalid configuration for html renderer'); + } + let htmlconfig = config.output; + if (htmlconfig.format == null || htmlconfig.format != 'html') { + throw new Error(`config: 'output.format' expected as 'html'`); + } + if (htmlconfig.filename == null) { + throw new Error(`config: 'output.filename' is not defined`); + } + this.config = htmlconfig; + } + static renderStartNumberWidgets() { + return `

`; + } + static renderFinishNumberWidgets() { + return `
`; + } + static renderNumberWidget(widget) { + let out = new Array(); + if (widget.title != null) { + out.push(``); + } + if (widget.url != null) { + out.push(``); + } + out.push(`
`); + if (widget.title != null) { + out.push(`${widget.title}`); + } + if (widget.value != null) { + out.push(`${widget.value}`); + } + out.push(`
`); + if (widget.url != null) { + out.push(``); + } + return out.join('\n'); + } + static renderStringWidget(widget) { + let out = new Array(); + if (widget.title != null) { + out.push(``); + } + if (widget.url != null) { + out.push(``); + } + out.push(`
`); + if (widget.title != null) { + out.push(`

${widget.title}

`); + } + if (widget.value != null) { + out.push(`${widget.value}`); + } + out.push(`
`); + if (widget.url != null) { + out.push(``); + } + return out.join('\n'); + } + static renderGraphWidget(widget) { + let html = new Array(); + let min = 0; + let max = 0; + for (let element of widget.elements) { + if (!(element instanceof analytics_1.NumberWidget)) { + throw new Error(`GraphWidget element did not evaluate to a NumberWidget (is a ${widget.constructor.name})`); + } + let num = element; + if (typeof num.value != 'number') { + throw new Error(`GraphWidget element did not evaluate to a static number (is a ${typeof num.value})`); + } + let value = num.value; + if (value > max) { + max = num.value; + } + } + html.push(`
`); + if (widget.title != null) { + const linkedTitle = widget.url ? `${widget.title}` : widget.title; + html.push(``); + html.push(`

${linkedTitle}

`); + } + html.push(`
`); + for (let element of widget.elements) { + let num = element; + let value = num.value; + let scaled = Math.floor((value / max) * 100); + html.push(`
`); + html.push(``); + if (num.title != null) { + if (num.url != null) { + html.push(``); + } + html.push(`${num.title}`); + if (num.url != null) { + html.push(``); + } + } + html.push(``); + html.push(``); + if (num.url != null) { + html.push(``); + } + let value_class = (scaled > 0) ? 'value' : 'value empty_value'; + let value_display = (scaled >= 5) ? value : ''; + html.push(`${value_display}`); + if (num.url != null) { + html.push(``); + } + html.push(``); + html.push(`
`); + } + html.push(`
`); + html.push(`
`); + return html.join('\n'); + } + static renderTableCell(type, cell) { + let html = new Array(); + if (!(cell instanceof analytics_1.NumberWidget) && !(cell instanceof analytics_1.StringWidget)) { + throw new Error(`TableWidget header cell did not evaluate to a static value (is a ${typeof cell})`); + } + let value = cell.value; + let color = cell.color; + let url = cell.url; + let align = null; + if (cell instanceof analytics_1.StringWidget) { + align = cell.align; + } + align = align != null ? ` style="text-align: ${align}"` : ''; + color = color != null ? ` class="${color}"` : ''; + html.push(`<${type}${color}${align}>`); + if (url != null) { + html.push(``); + } + html.push(`${value}`); + if (url != null) { + html.push(``); + } + html.push(``); + return html.join(''); + } + static renderTableWidget(widget) { + let html = new Array(); + html.push(`
`); + if (widget.title != null) { + const linkedTitle = widget.url ? `${widget.title}` : widget.title; + html.push(``); + html.push(`

${linkedTitle}

`); + } + html.push(``); + if (widget.headers != null && widget.headers.length > 0) { + html.push(``); + for (let cell of widget.headers) { + html.push(HtmlRenderer.renderTableCell('th', cell)); + } + html.push(``); + } + for (let row of widget.elements) { + html.push(``); + for (let cell of row) { + html.push(HtmlRenderer.renderTableCell('td', cell)); + } + html.push(``); + } + html.push(`
`); + html.push(`
`); + return html.join('\n'); + } + static renderAnalytics(analytics) { + let html = new Array(); + html.push(` + + +${analytics.title ? analytics.title : 'Dashboard'} + + + + +
+`); + if (analytics.title != null) { + html.push(`

${analytics.title}

`); + html.push(''); + } + if (analytics.description != null) { + html.push(`
`); + html.push(analytics.description); + html.push(`
`); + html.push(''); + } + html.push(`
`); + for (let section of analytics.sections) { + html.push(`
`); + html.push(`
`); + if (section.title != null) { + html.push(``); + html.push(`

${section.title}

`); + html.push(''); + } + if (section.description != null) { + html.push(`
`); + html.push(section.description); + html.push(`
`); + html.push(''); + } + html.push(`
`); + html.push(`
`); + let showingNumberWidgets = false; + for (let widget of section.widgets) { + if (widget instanceof analytics_1.NumberWidget) { + // Group the number widgets together + if (!showingNumberWidgets) { + html.push(HtmlRenderer.renderStartNumberWidgets()); + showingNumberWidgets = true; + } + html.push(HtmlRenderer.renderNumberWidget(widget)); + continue; + } + if (showingNumberWidgets) { + html.push(HtmlRenderer.renderFinishNumberWidgets()); + showingNumberWidgets = false; + } + if (widget instanceof analytics_1.StringWidget) { + html.push(HtmlRenderer.renderStringWidget(widget)); + } + else if (widget instanceof analytics_1.GraphWidget) { + html.push(HtmlRenderer.renderGraphWidget(widget)); + } + else if (widget instanceof analytics_1.TableWidget) { + html.push(HtmlRenderer.renderTableWidget(widget)); + } + else { + throw new Error(`cannot render unknown widget type: ${widget.constructor.name}`); + } + } + if (showingNumberWidgets) { + html.push(HtmlRenderer.renderFinishNumberWidgets()); + showingNumberWidgets = false; + } + html.push(`
`); + html.push(`
`); + } + html.push(` +
+ +
+ + +`); + return html.join('\n'); + } + render(analytics) { + fs.writeFileSync(this.config.filename, HtmlRenderer.renderAnalytics(analytics), 'utf8'); + } +} +exports.HtmlRenderer = HtmlRenderer; + + +/***/ }), + +/***/ 145: +/***/ (function(module, __unusedexports, __webpack_require__) { + +"use strict"; + +const pump = __webpack_require__(453); +const bufferStream = __webpack_require__(966); + +class MaxBufferError extends Error { + constructor() { + super('maxBuffer exceeded'); + this.name = 'MaxBufferError'; + } +} + +function getStream(inputStream, options) { + if (!inputStream) { + return Promise.reject(new Error('Expected a stream')); + } + + options = Object.assign({maxBuffer: Infinity}, options); + + const {maxBuffer} = options; + + let stream; + return new Promise((resolve, reject) => { + const rejectPromise = error => { + if (error) { // A null check + error.bufferedData = stream.getBufferedValue(); + } + reject(error); + }; + + stream = pump(inputStream, bufferStream(options), error => { + if (error) { + rejectPromise(error); + return; + } + + resolve(); + }); + + stream.on('data', () => { + if (stream.getBufferedLength() > maxBuffer) { + rejectPromise(new MaxBufferError()); + } + }); + }).then(() => stream.getBufferedValue()); +} + +module.exports = getStream; +module.exports.buffer = (stream, options) => getStream(stream, Object.assign({}, options, {encoding: 'buffer'})); +module.exports.array = (stream, options) => getStream(stream, Object.assign({}, options, {array: true})); +module.exports.MaxBufferError = MaxBufferError; + + +/***/ }), + +/***/ 148: +/***/ (function(module, __unusedexports, __webpack_require__) { + +module.exports = paginatePlugin; + +const { paginateRest } = __webpack_require__(299); + +function paginatePlugin(octokit) { + Object.assign(octokit, paginateRest(octokit)); +} + + +/***/ }), + +/***/ 168: +/***/ (function(module) { + +"use strict"; + +const alias = ['stdin', 'stdout', 'stderr']; + +const hasAlias = opts => alias.some(x => Boolean(opts[x])); + +module.exports = opts => { + if (!opts) { + return null; + } + + if (opts.stdio && hasAlias(opts)) { + throw new Error(`It's not possible to provide \`stdio\` in combination with one of ${alias.map(x => `\`${x}\``).join(', ')}`); + } + + if (typeof opts.stdio === 'string') { + return opts.stdio; + } + + const stdio = opts.stdio || []; + + if (!Array.isArray(stdio)) { + throw new TypeError(`Expected \`stdio\` to be of type \`string\` or \`Array\`, got \`${typeof stdio}\``); + } + + const result = []; + const len = Math.max(stdio.length, alias.length); + + for (let i = 0; i < len; i++) { + let value = null; + + if (stdio[i] !== undefined) { + value = stdio[i]; + } else if (opts[alias[i]] !== undefined) { + value = opts[alias[i]]; + } + + result[i] = value; + } + + return result; +}; + + +/***/ }), + +/***/ 181: +/***/ (function(module, __unusedexports, __webpack_require__) { + +"use strict"; + + +var Type = __webpack_require__(945); + +var _hasOwnProperty = Object.prototype.hasOwnProperty; +var _toString = Object.prototype.toString; + +function resolveYamlOmap(data) { + if (data === null) return true; + + var objectKeys = [], index, length, pair, pairKey, pairHasKey, + object = data; + + for (index = 0, length = object.length; index < length; index += 1) { + pair = object[index]; + pairHasKey = false; + + if (_toString.call(pair) !== '[object Object]') return false; + + for (pairKey in pair) { + if (_hasOwnProperty.call(pair, pairKey)) { + if (!pairHasKey) pairHasKey = true; + else return false; + } + } + + if (!pairHasKey) return false; + + if (objectKeys.indexOf(pairKey) === -1) objectKeys.push(pairKey); + else return false; + } + + return true; +} + +function constructYamlOmap(data) { + return data !== null ? data : []; +} + +module.exports = new Type('tag:yaml.org,2002:omap', { + kind: 'sequence', + resolve: resolveYamlOmap, + construct: constructYamlOmap +}); + + +/***/ }), + +/***/ 190: +/***/ (function(module, __unusedexports, __webpack_require__) { + +module.exports = authenticationPlugin; + +const { createTokenAuth } = __webpack_require__(813); +const { Deprecation } = __webpack_require__(692); +const once = __webpack_require__(969); + +const beforeRequest = __webpack_require__(863); +const requestError = __webpack_require__(293); +const validate = __webpack_require__(954); +const withAuthorizationPrefix = __webpack_require__(143); + +const deprecateAuthBasic = once((log, deprecation) => log.warn(deprecation)); +const deprecateAuthObject = once((log, deprecation) => log.warn(deprecation)); + +function authenticationPlugin(octokit, options) { + // If `options.authStrategy` is set then use it and pass in `options.auth` + if (options.authStrategy) { + const auth = options.authStrategy(options.auth); + octokit.hook.wrap("request", auth.hook); + octokit.auth = auth; + return; + } + + // If neither `options.authStrategy` nor `options.auth` are set, the `octokit` instance + // is unauthenticated. The `octokit.auth()` method is a no-op and no request hook is registred. + if (!options.auth) { + octokit.auth = () => + Promise.resolve({ + type: "unauthenticated" + }); + return; + } + + const isBasicAuthString = + typeof options.auth === "string" && + /^basic/.test(withAuthorizationPrefix(options.auth)); + + // If only `options.auth` is set to a string, use the default token authentication strategy. + if (typeof options.auth === "string" && !isBasicAuthString) { + const auth = createTokenAuth(options.auth); + octokit.hook.wrap("request", auth.hook); + octokit.auth = auth; + return; + } + + // Otherwise log a deprecation message + const [deprecationMethod, deprecationMessapge] = isBasicAuthString + ? [ + deprecateAuthBasic, + 'Setting the "new Octokit({ auth })" option to a Basic Auth string is deprecated. Use https://github.com/octokit/auth-basic.js instead. See (https://octokit.github.io/rest.js/#authentication)' + ] + : [ + deprecateAuthObject, + 'Setting the "new Octokit({ auth })" option to an object without also setting the "authStrategy" option is deprecated and will be removed in v17. See (https://octokit.github.io/rest.js/#authentication)' + ]; + deprecationMethod( + octokit.log, + new Deprecation("[@octokit/rest] " + deprecationMessapge) + ); + + octokit.auth = () => + Promise.resolve({ + type: "deprecated", + message: deprecationMessapge + }); + + validate(options.auth); + + const state = { + octokit, + auth: options.auth + }; + + octokit.hook.before("request", beforeRequest.bind(null, state)); + octokit.hook.error("request", requestError.bind(null, state)); +} + + +/***/ }), + +/***/ 197: +/***/ (function(module, __unusedexports, __webpack_require__) { + +module.exports = isexe +isexe.sync = sync + +var fs = __webpack_require__(747) + +function isexe (path, options, cb) { + fs.stat(path, function (er, stat) { + cb(er, er ? false : checkStat(stat, options)) + }) +} + +function sync (path, options) { + return checkStat(fs.statSync(path), options) +} + +function checkStat (stat, options) { + return stat.isFile() && checkMode(stat, options) +} + +function checkMode (stat, options) { + var mod = stat.mode + var uid = stat.uid + var gid = stat.gid + + var myUid = options.uid !== undefined ? + options.uid : process.getuid && process.getuid() + var myGid = options.gid !== undefined ? + options.gid : process.getgid && process.getgid() + + var u = parseInt('100', 8) + var g = parseInt('010', 8) + var o = parseInt('001', 8) + var ug = u | g + + var ret = (mod & o) || + (mod & g) && gid === myGid || + (mod & u) && uid === myUid || + (mod & ug) && myUid === 0 + + return ret +} + + +/***/ }), + +/***/ 198: +/***/ (function(__unusedmodule, exports, __webpack_require__) { + +"use strict"; + +var __importStar = (this && this.__importStar) || function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k]; + result["default"] = mod; + return result; +}; +Object.defineProperty(exports, "__esModule", { value: true }); +const core = __importStar(__webpack_require__(470)); +const github_1 = __webpack_require__(469); +const config_1 = __webpack_require__(478); +const analytics_1 = __webpack_require__(847); +const render_1 = __webpack_require__(897); +async function run() { + try { + const token = core.getInput('token') || process.env.GITHUB_TOKEN || ''; + const github = new github_1.GitHub(token); + const config = config_1.AnalyticsConfig.from(core.getInput('config', { required: true })); + const renderer = render_1.Renderer.fromConfig(config); + const result = await analytics_1.Analytics.evaluate(config, github); + renderer.render(result); + } + catch (err) { + core.setFailed(err.message); + } +} +run(); + + +/***/ }), + +/***/ 211: +/***/ (function(__unusedmodule, exports, __webpack_require__) { + +"use strict"; + + +Object.defineProperty(exports, '__esModule', { value: true }); + +function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; } + +var osName = _interopDefault(__webpack_require__(2)); + +function getUserAgent() { + try { + return `Node.js/${process.version.substr(1)} (${osName()}; ${process.arch})`; + } catch (error) { + if (/wmic os get Caption/.test(error.message)) { + return "Windows "; + } + + return ""; + } +} + +exports.getUserAgent = getUserAgent; +//# sourceMappingURL=index.js.map + + +/***/ }), + +/***/ 215: +/***/ (function(module) { + +module.exports = {"_args":[["@octokit/rest@16.43.1","/home/runner/work/issue-dashboard/issue-dashboard"]],"_from":"@octokit/rest@16.43.1","_id":"@octokit/rest@16.43.1","_inBundle":false,"_integrity":"sha512-gfFKwRT/wFxq5qlNjnW2dh+qh74XgTQ2B179UX5K1HYCluioWj8Ndbgqw2PVqa1NnVJkGHp2ovMpVn/DImlmkw==","_location":"/@octokit/rest","_phantomChildren":{"@octokit/types":"2.7.1","deprecation":"2.3.1","once":"1.4.0"},"_requested":{"type":"version","registry":true,"raw":"@octokit/rest@16.43.1","name":"@octokit/rest","escapedName":"@octokit%2frest","scope":"@octokit","rawSpec":"16.43.1","saveSpec":null,"fetchSpec":"16.43.1"},"_requiredBy":["/@actions/github"],"_resolved":"https://registry.npmjs.org/@octokit/rest/-/rest-16.43.1.tgz","_spec":"16.43.1","_where":"/home/runner/work/issue-dashboard/issue-dashboard","author":{"name":"Gregor Martynus","url":"https://github.com/gr2m"},"bugs":{"url":"https://github.com/octokit/rest.js/issues"},"bundlesize":[{"path":"./dist/octokit-rest.min.js.gz","maxSize":"33 kB"}],"contributors":[{"name":"Mike de Boer","email":"info@mikedeboer.nl"},{"name":"Fabian Jakobs","email":"fabian@c9.io"},{"name":"Joe Gallo","email":"joe@brassafrax.com"},{"name":"Gregor Martynus","url":"https://github.com/gr2m"}],"dependencies":{"@octokit/auth-token":"^2.4.0","@octokit/plugin-paginate-rest":"^1.1.1","@octokit/plugin-request-log":"^1.0.0","@octokit/plugin-rest-endpoint-methods":"2.4.0","@octokit/request":"^5.2.0","@octokit/request-error":"^1.0.2","atob-lite":"^2.0.0","before-after-hook":"^2.0.0","btoa-lite":"^1.0.0","deprecation":"^2.0.0","lodash.get":"^4.4.2","lodash.set":"^4.3.2","lodash.uniq":"^4.5.0","octokit-pagination-methods":"^1.1.0","once":"^1.4.0","universal-user-agent":"^4.0.0"},"description":"GitHub REST API client for Node.js","devDependencies":{"@gimenete/type-writer":"^0.1.3","@octokit/auth":"^1.1.1","@octokit/fixtures-server":"^5.0.6","@octokit/graphql":"^4.2.0","@types/node":"^13.1.0","bundlesize":"^0.18.0","chai":"^4.1.2","compression-webpack-plugin":"^3.1.0","cypress":"^3.0.0","glob":"^7.1.2","http-proxy-agent":"^4.0.0","lodash.camelcase":"^4.3.0","lodash.merge":"^4.6.1","lodash.upperfirst":"^4.3.1","lolex":"^5.1.2","mkdirp":"^1.0.0","mocha":"^7.0.1","mustache":"^4.0.0","nock":"^11.3.3","npm-run-all":"^4.1.2","nyc":"^15.0.0","prettier":"^1.14.2","proxy":"^1.0.0","semantic-release":"^17.0.0","sinon":"^8.0.0","sinon-chai":"^3.0.0","sort-keys":"^4.0.0","string-to-arraybuffer":"^1.0.0","string-to-jsdoc-comment":"^1.0.0","typescript":"^3.3.1","webpack":"^4.0.0","webpack-bundle-analyzer":"^3.0.0","webpack-cli":"^3.0.0"},"files":["index.js","index.d.ts","lib","plugins"],"homepage":"https://github.com/octokit/rest.js#readme","keywords":["octokit","github","rest","api-client"],"license":"MIT","name":"@octokit/rest","nyc":{"ignore":["test"]},"publishConfig":{"access":"public"},"release":{"publish":["@semantic-release/npm",{"path":"@semantic-release/github","assets":["dist/*","!dist/*.map.gz"]}]},"repository":{"type":"git","url":"git+https://github.com/octokit/rest.js.git"},"scripts":{"build":"npm-run-all build:*","build:browser":"npm-run-all build:browser:*","build:browser:development":"webpack --mode development --entry . --output-library=Octokit --output=./dist/octokit-rest.js --profile --json > dist/bundle-stats.json","build:browser:production":"webpack --mode production --entry . --plugin=compression-webpack-plugin --output-library=Octokit --output-path=./dist --output-filename=octokit-rest.min.js --devtool source-map","build:ts":"npm run -s update-endpoints:typescript","coverage":"nyc report --reporter=html && open coverage/index.html","generate-bundle-report":"webpack-bundle-analyzer dist/bundle-stats.json --mode=static --no-open --report dist/bundle-report.html","lint":"prettier --check '{lib,plugins,scripts,test}/**/*.{js,json,ts}' 'docs/*.{js,json}' 'docs/src/**/*' index.js README.md package.json","lint:fix":"prettier --write '{lib,plugins,scripts,test}/**/*.{js,json,ts}' 'docs/*.{js,json}' 'docs/src/**/*' index.js README.md package.json","postvalidate:ts":"tsc --noEmit --target es6 test/typescript-validate.ts","prebuild:browser":"mkdirp dist/","pretest":"npm run -s lint","prevalidate:ts":"npm run -s build:ts","start-fixtures-server":"octokit-fixtures-server","test":"nyc mocha test/mocha-node-setup.js \"test/*/**/*-test.js\"","test:browser":"cypress run --browser chrome","update-endpoints":"npm-run-all update-endpoints:*","update-endpoints:fetch-json":"node scripts/update-endpoints/fetch-json","update-endpoints:typescript":"node scripts/update-endpoints/typescript","validate:ts":"tsc --target es6 --noImplicitAny index.d.ts"},"types":"index.d.ts","version":"16.43.1"}; + +/***/ }), + +/***/ 228: +/***/ (function(module, __unusedexports, __webpack_require__) { + +"use strict"; + + +var Type = __webpack_require__(945); + +function resolveYamlBoolean(data) { + if (data === null) return false; + + var max = data.length; + + return (max === 4 && (data === 'true' || data === 'True' || data === 'TRUE')) || + (max === 5 && (data === 'false' || data === 'False' || data === 'FALSE')); +} + +function constructYamlBoolean(data) { + return data === 'true' || + data === 'True' || + data === 'TRUE'; +} + +function isBoolean(object) { + return Object.prototype.toString.call(object) === '[object Boolean]'; +} + +module.exports = new Type('tag:yaml.org,2002:bool', { + kind: 'scalar', + resolve: resolveYamlBoolean, + construct: constructYamlBoolean, + predicate: isBoolean, + represent: { + lowercase: function (object) { return object ? 'true' : 'false'; }, + uppercase: function (object) { return object ? 'TRUE' : 'FALSE'; }, + camelcase: function (object) { return object ? 'True' : 'False'; } + }, + defaultStyle: 'lowercase' +}); + + +/***/ }), + +/***/ 237: +/***/ (function(module, __unusedexports, __webpack_require__) { + +"use strict"; + + +var Type = __webpack_require__(945); + +function resolveJavascriptRegExp(data) { + if (data === null) return false; + if (data.length === 0) return false; + + var regexp = data, + tail = /\/([gim]*)$/.exec(data), + modifiers = ''; + + // if regexp starts with '/' it can have modifiers and must be properly closed + // `/foo/gim` - modifiers tail can be maximum 3 chars + if (regexp[0] === '/') { + if (tail) modifiers = tail[1]; + + if (modifiers.length > 3) return false; + // if expression starts with /, is should be properly terminated + if (regexp[regexp.length - modifiers.length - 1] !== '/') return false; + } + + return true; +} + +function constructJavascriptRegExp(data) { + var regexp = data, + tail = /\/([gim]*)$/.exec(data), + modifiers = ''; + + // `/foo/gim` - tail can be maximum 4 chars + if (regexp[0] === '/') { + if (tail) modifiers = tail[1]; + regexp = regexp.slice(1, regexp.length - modifiers.length - 1); + } + + return new RegExp(regexp, modifiers); +} + +function representJavascriptRegExp(object /*, style*/) { + var result = '/' + object.source + '/'; + + if (object.global) result += 'g'; + if (object.multiline) result += 'm'; + if (object.ignoreCase) result += 'i'; + + return result; +} + +function isRegExp(object) { + return Object.prototype.toString.call(object) === '[object RegExp]'; +} + +module.exports = new Type('tag:yaml.org,2002:js/regexp', { + kind: 'scalar', + resolve: resolveJavascriptRegExp, + construct: constructJavascriptRegExp, + predicate: isRegExp, + represent: representJavascriptRegExp +}); + + +/***/ }), + +/***/ 260: +/***/ (function(module, __unusedexports, __webpack_require__) { + +// Note: since nyc uses this module to output coverage, any lines +// that are in the direct sync flow of nyc's outputCoverage are +// ignored, since we can never get coverage for them. +var assert = __webpack_require__(357) +var signals = __webpack_require__(654) +var isWin = /^win/i.test(process.platform) + +var EE = __webpack_require__(614) +/* istanbul ignore if */ +if (typeof EE !== 'function') { + EE = EE.EventEmitter +} + +var emitter +if (process.__signal_exit_emitter__) { + emitter = process.__signal_exit_emitter__ +} else { + emitter = process.__signal_exit_emitter__ = new EE() + emitter.count = 0 + emitter.emitted = {} +} + +// Because this emitter is a global, we have to check to see if a +// previous version of this library failed to enable infinite listeners. +// I know what you're about to say. But literally everything about +// signal-exit is a compromise with evil. Get used to it. +if (!emitter.infinite) { + emitter.setMaxListeners(Infinity) + emitter.infinite = true +} + +module.exports = function (cb, opts) { + assert.equal(typeof cb, 'function', 'a callback must be provided for exit handler') + + if (loaded === false) { + load() + } + + var ev = 'exit' + if (opts && opts.alwaysLast) { + ev = 'afterexit' + } + + var remove = function () { + emitter.removeListener(ev, cb) + if (emitter.listeners('exit').length === 0 && + emitter.listeners('afterexit').length === 0) { + unload() + } + } + emitter.on(ev, cb) + + return remove +} + +module.exports.unload = unload +function unload () { + if (!loaded) { + return + } + loaded = false + + signals.forEach(function (sig) { + try { + process.removeListener(sig, sigListeners[sig]) + } catch (er) {} + }) + process.emit = originalProcessEmit + process.reallyExit = originalProcessReallyExit + emitter.count -= 1 +} + +function emit (event, code, signal) { + if (emitter.emitted[event]) { + return + } + emitter.emitted[event] = true + emitter.emit(event, code, signal) +} + +// { : , ... } +var sigListeners = {} +signals.forEach(function (sig) { + sigListeners[sig] = function listener () { + // If there are no other listeners, an exit is coming! + // Simplest way: remove us and then re-send the signal. + // We know that this will kill the process, so we can + // safely emit now. + var listeners = process.listeners(sig) + if (listeners.length === emitter.count) { + unload() + emit('exit', null, sig) + /* istanbul ignore next */ + emit('afterexit', null, sig) + /* istanbul ignore next */ + if (isWin && sig === 'SIGHUP') { + // "SIGHUP" throws an `ENOSYS` error on Windows, + // so use a supported signal instead + sig = 'SIGINT' + } + process.kill(process.pid, sig) + } + } +}) + +module.exports.signals = function () { + return signals +} + +module.exports.load = load + +var loaded = false + +function load () { + if (loaded) { + return + } + loaded = true + + // This is the number of onSignalExit's that are in play. + // It's important so that we can count the correct number of + // listeners on signals, and don't wait for the other one to + // handle it instead of us. + emitter.count += 1 + + signals = signals.filter(function (sig) { + try { + process.on(sig, sigListeners[sig]) + return true + } catch (er) { + return false + } + }) + + process.emit = processEmit + process.reallyExit = processReallyExit +} + +var originalProcessReallyExit = process.reallyExit +function processReallyExit (code) { + process.exitCode = code || 0 + emit('exit', process.exitCode, null) + /* istanbul ignore next */ + emit('afterexit', process.exitCode, null) + /* istanbul ignore next */ + originalProcessReallyExit.call(process, process.exitCode) +} + +var originalProcessEmit = process.emit +function processEmit (ev, arg) { + if (ev === 'exit') { + if (arg !== undefined) { + process.exitCode = arg + } + var ret = originalProcessEmit.apply(this, arguments) + emit('exit', process.exitCode, null) + /* istanbul ignore next */ + emit('afterexit', process.exitCode, null) + return ret + } else { + return originalProcessEmit.apply(this, arguments) + } +} + + +/***/ }), + +/***/ 262: +/***/ (function(__unusedmodule, exports, __webpack_require__) { + +"use strict"; + +Object.defineProperty(exports, "__esModule", { value: true }); +const fs_1 = __webpack_require__(747); +const os_1 = __webpack_require__(87); +class Context { + /** + * Hydrate the context from the environment + */ + constructor() { + this.payload = {}; + if (process.env.GITHUB_EVENT_PATH) { + if (fs_1.existsSync(process.env.GITHUB_EVENT_PATH)) { + this.payload = JSON.parse(fs_1.readFileSync(process.env.GITHUB_EVENT_PATH, { encoding: 'utf8' })); + } + else { + const path = process.env.GITHUB_EVENT_PATH; + process.stdout.write(`GITHUB_EVENT_PATH ${path} does not exist${os_1.EOL}`); + } + } + this.eventName = process.env.GITHUB_EVENT_NAME; + this.sha = process.env.GITHUB_SHA; + this.ref = process.env.GITHUB_REF; + this.workflow = process.env.GITHUB_WORKFLOW; + this.action = process.env.GITHUB_ACTION; + this.actor = process.env.GITHUB_ACTOR; + } + get issue() { + const payload = this.payload; + return Object.assign(Object.assign({}, this.repo), { number: (payload.issue || payload.pull_request || payload).number }); + } + get repo() { + if (process.env.GITHUB_REPOSITORY) { + const [owner, repo] = process.env.GITHUB_REPOSITORY.split('/'); + return { owner, repo }; + } + if (this.payload.repository) { + return { + owner: this.payload.repository.owner.login, + repo: this.payload.repository.name + }; + } + throw new Error("context.repo requires a GITHUB_REPOSITORY environment variable like 'owner/repo'"); + } +} +exports.Context = Context; +//# sourceMappingURL=context.js.map + +/***/ }), + +/***/ 265: +/***/ (function(module, __unusedexports, __webpack_require__) { + +module.exports = getPage + +const deprecate = __webpack_require__(370) +const getPageLinks = __webpack_require__(577) +const HttpError = __webpack_require__(297) + +function getPage (octokit, link, which, headers) { + deprecate(`octokit.get${which.charAt(0).toUpperCase() + which.slice(1)}Page() – You can use octokit.paginate or async iterators instead: https://github.com/octokit/rest.js#pagination.`) + const url = getPageLinks(link)[which] + + if (!url) { + const urlError = new HttpError(`No ${which} page found`, 404) + return Promise.reject(urlError) + } + + const requestOptions = { + url, + headers: applyAcceptHeader(link, headers) + } + + const promise = octokit.request(requestOptions) + + return promise +} + +function applyAcceptHeader (res, headers) { + const previous = res.headers && res.headers['x-github-media-type'] + + if (!previous || (headers && headers.accept)) { + return headers + } + headers = headers || {} + headers.accept = 'application/vnd.' + previous + .replace('; param=', '.') + .replace('; format=', '+') + + return headers +} + + +/***/ }), + +/***/ 280: +/***/ (function(module, exports) { + +exports = module.exports = SemVer + +var debug +/* istanbul ignore next */ +if (typeof process === 'object' && + process.env && + process.env.NODE_DEBUG && + /\bsemver\b/i.test(process.env.NODE_DEBUG)) { + debug = function () { + var args = Array.prototype.slice.call(arguments, 0) + args.unshift('SEMVER') + console.log.apply(console, args) + } +} else { + debug = function () {} +} + +// Note: this is the semver.org version of the spec that it implements +// Not necessarily the package version of this code. +exports.SEMVER_SPEC_VERSION = '2.0.0' + +var MAX_LENGTH = 256 +var MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER || + /* istanbul ignore next */ 9007199254740991 + +// Max safe segment length for coercion. +var MAX_SAFE_COMPONENT_LENGTH = 16 + +// The actual regexps go on exports.re +var re = exports.re = [] +var src = exports.src = [] +var R = 0 + +// The following Regular Expressions can be used for tokenizing, +// validating, and parsing SemVer version strings. + +// ## Numeric Identifier +// A single `0`, or a non-zero digit followed by zero or more digits. + +var NUMERICIDENTIFIER = R++ +src[NUMERICIDENTIFIER] = '0|[1-9]\\d*' +var NUMERICIDENTIFIERLOOSE = R++ +src[NUMERICIDENTIFIERLOOSE] = '[0-9]+' + +// ## Non-numeric Identifier +// Zero or more digits, followed by a letter or hyphen, and then zero or +// more letters, digits, or hyphens. + +var NONNUMERICIDENTIFIER = R++ +src[NONNUMERICIDENTIFIER] = '\\d*[a-zA-Z-][a-zA-Z0-9-]*' + +// ## Main Version +// Three dot-separated numeric identifiers. + +var MAINVERSION = R++ +src[MAINVERSION] = '(' + src[NUMERICIDENTIFIER] + ')\\.' + + '(' + src[NUMERICIDENTIFIER] + ')\\.' + + '(' + src[NUMERICIDENTIFIER] + ')' + +var MAINVERSIONLOOSE = R++ +src[MAINVERSIONLOOSE] = '(' + src[NUMERICIDENTIFIERLOOSE] + ')\\.' + + '(' + src[NUMERICIDENTIFIERLOOSE] + ')\\.' + + '(' + src[NUMERICIDENTIFIERLOOSE] + ')' + +// ## Pre-release Version Identifier +// A numeric identifier, or a non-numeric identifier. + +var PRERELEASEIDENTIFIER = R++ +src[PRERELEASEIDENTIFIER] = '(?:' + src[NUMERICIDENTIFIER] + + '|' + src[NONNUMERICIDENTIFIER] + ')' + +var PRERELEASEIDENTIFIERLOOSE = R++ +src[PRERELEASEIDENTIFIERLOOSE] = '(?:' + src[NUMERICIDENTIFIERLOOSE] + + '|' + src[NONNUMERICIDENTIFIER] + ')' + +// ## Pre-release Version +// Hyphen, followed by one or more dot-separated pre-release version +// identifiers. + +var PRERELEASE = R++ +src[PRERELEASE] = '(?:-(' + src[PRERELEASEIDENTIFIER] + + '(?:\\.' + src[PRERELEASEIDENTIFIER] + ')*))' + +var PRERELEASELOOSE = R++ +src[PRERELEASELOOSE] = '(?:-?(' + src[PRERELEASEIDENTIFIERLOOSE] + + '(?:\\.' + src[PRERELEASEIDENTIFIERLOOSE] + ')*))' + +// ## Build Metadata Identifier +// Any combination of digits, letters, or hyphens. + +var BUILDIDENTIFIER = R++ +src[BUILDIDENTIFIER] = '[0-9A-Za-z-]+' + +// ## Build Metadata +// Plus sign, followed by one or more period-separated build metadata +// identifiers. + +var BUILD = R++ +src[BUILD] = '(?:\\+(' + src[BUILDIDENTIFIER] + + '(?:\\.' + src[BUILDIDENTIFIER] + ')*))' + +// ## Full Version String +// A main version, followed optionally by a pre-release version and +// build metadata. + +// Note that the only major, minor, patch, and pre-release sections of +// the version string are capturing groups. The build metadata is not a +// capturing group, because it should not ever be used in version +// comparison. + +var FULL = R++ +var FULLPLAIN = 'v?' + src[MAINVERSION] + + src[PRERELEASE] + '?' + + src[BUILD] + '?' + +src[FULL] = '^' + FULLPLAIN + '$' + +// like full, but allows v1.2.3 and =1.2.3, which people do sometimes. +// also, 1.0.0alpha1 (prerelease without the hyphen) which is pretty +// common in the npm registry. +var LOOSEPLAIN = '[v=\\s]*' + src[MAINVERSIONLOOSE] + + src[PRERELEASELOOSE] + '?' + + src[BUILD] + '?' + +var LOOSE = R++ +src[LOOSE] = '^' + LOOSEPLAIN + '$' + +var GTLT = R++ +src[GTLT] = '((?:<|>)?=?)' + +// Something like "2.*" or "1.2.x". +// Note that "x.x" is a valid xRange identifer, meaning "any version" +// Only the first item is strictly required. +var XRANGEIDENTIFIERLOOSE = R++ +src[XRANGEIDENTIFIERLOOSE] = src[NUMERICIDENTIFIERLOOSE] + '|x|X|\\*' +var XRANGEIDENTIFIER = R++ +src[XRANGEIDENTIFIER] = src[NUMERICIDENTIFIER] + '|x|X|\\*' + +var XRANGEPLAIN = R++ +src[XRANGEPLAIN] = '[v=\\s]*(' + src[XRANGEIDENTIFIER] + ')' + + '(?:\\.(' + src[XRANGEIDENTIFIER] + ')' + + '(?:\\.(' + src[XRANGEIDENTIFIER] + ')' + + '(?:' + src[PRERELEASE] + ')?' + + src[BUILD] + '?' + + ')?)?' + +var XRANGEPLAINLOOSE = R++ +src[XRANGEPLAINLOOSE] = '[v=\\s]*(' + src[XRANGEIDENTIFIERLOOSE] + ')' + + '(?:\\.(' + src[XRANGEIDENTIFIERLOOSE] + ')' + + '(?:\\.(' + src[XRANGEIDENTIFIERLOOSE] + ')' + + '(?:' + src[PRERELEASELOOSE] + ')?' + + src[BUILD] + '?' + + ')?)?' + +var XRANGE = R++ +src[XRANGE] = '^' + src[GTLT] + '\\s*' + src[XRANGEPLAIN] + '$' +var XRANGELOOSE = R++ +src[XRANGELOOSE] = '^' + src[GTLT] + '\\s*' + src[XRANGEPLAINLOOSE] + '$' + +// Coercion. +// Extract anything that could conceivably be a part of a valid semver +var COERCE = R++ +src[COERCE] = '(?:^|[^\\d])' + + '(\\d{1,' + MAX_SAFE_COMPONENT_LENGTH + '})' + + '(?:\\.(\\d{1,' + MAX_SAFE_COMPONENT_LENGTH + '}))?' + + '(?:\\.(\\d{1,' + MAX_SAFE_COMPONENT_LENGTH + '}))?' + + '(?:$|[^\\d])' + +// Tilde ranges. +// Meaning is "reasonably at or greater than" +var LONETILDE = R++ +src[LONETILDE] = '(?:~>?)' + +var TILDETRIM = R++ +src[TILDETRIM] = '(\\s*)' + src[LONETILDE] + '\\s+' +re[TILDETRIM] = new RegExp(src[TILDETRIM], 'g') +var tildeTrimReplace = '$1~' + +var TILDE = R++ +src[TILDE] = '^' + src[LONETILDE] + src[XRANGEPLAIN] + '$' +var TILDELOOSE = R++ +src[TILDELOOSE] = '^' + src[LONETILDE] + src[XRANGEPLAINLOOSE] + '$' + +// Caret ranges. +// Meaning is "at least and backwards compatible with" +var LONECARET = R++ +src[LONECARET] = '(?:\\^)' + +var CARETTRIM = R++ +src[CARETTRIM] = '(\\s*)' + src[LONECARET] + '\\s+' +re[CARETTRIM] = new RegExp(src[CARETTRIM], 'g') +var caretTrimReplace = '$1^' + +var CARET = R++ +src[CARET] = '^' + src[LONECARET] + src[XRANGEPLAIN] + '$' +var CARETLOOSE = R++ +src[CARETLOOSE] = '^' + src[LONECARET] + src[XRANGEPLAINLOOSE] + '$' + +// A simple gt/lt/eq thing, or just "" to indicate "any version" +var COMPARATORLOOSE = R++ +src[COMPARATORLOOSE] = '^' + src[GTLT] + '\\s*(' + LOOSEPLAIN + ')$|^$' +var COMPARATOR = R++ +src[COMPARATOR] = '^' + src[GTLT] + '\\s*(' + FULLPLAIN + ')$|^$' + +// An expression to strip any whitespace between the gtlt and the thing +// it modifies, so that `> 1.2.3` ==> `>1.2.3` +var COMPARATORTRIM = R++ +src[COMPARATORTRIM] = '(\\s*)' + src[GTLT] + + '\\s*(' + LOOSEPLAIN + '|' + src[XRANGEPLAIN] + ')' + +// this one has to use the /g flag +re[COMPARATORTRIM] = new RegExp(src[COMPARATORTRIM], 'g') +var comparatorTrimReplace = '$1$2$3' + +// Something like `1.2.3 - 1.2.4` +// Note that these all use the loose form, because they'll be +// checked against either the strict or loose comparator form +// later. +var HYPHENRANGE = R++ +src[HYPHENRANGE] = '^\\s*(' + src[XRANGEPLAIN] + ')' + + '\\s+-\\s+' + + '(' + src[XRANGEPLAIN] + ')' + + '\\s*$' + +var HYPHENRANGELOOSE = R++ +src[HYPHENRANGELOOSE] = '^\\s*(' + src[XRANGEPLAINLOOSE] + ')' + + '\\s+-\\s+' + + '(' + src[XRANGEPLAINLOOSE] + ')' + + '\\s*$' + +// Star ranges basically just allow anything at all. +var STAR = R++ +src[STAR] = '(<|>)?=?\\s*\\*' + +// Compile to actual regexp objects. +// All are flag-free, unless they were created above with a flag. +for (var i = 0; i < R; i++) { + debug(i, src[i]) + if (!re[i]) { + re[i] = new RegExp(src[i]) + } +} + +exports.parse = parse +function parse (version, options) { + if (!options || typeof options !== 'object') { + options = { + loose: !!options, + includePrerelease: false + } + } + + if (version instanceof SemVer) { + return version + } + + if (typeof version !== 'string') { + return null + } + + if (version.length > MAX_LENGTH) { + return null + } + + var r = options.loose ? re[LOOSE] : re[FULL] + if (!r.test(version)) { + return null + } + + try { + return new SemVer(version, options) + } catch (er) { + return null + } +} + +exports.valid = valid +function valid (version, options) { + var v = parse(version, options) + return v ? v.version : null +} + +exports.clean = clean +function clean (version, options) { + var s = parse(version.trim().replace(/^[=v]+/, ''), options) + return s ? s.version : null +} + +exports.SemVer = SemVer + +function SemVer (version, options) { + if (!options || typeof options !== 'object') { + options = { + loose: !!options, + includePrerelease: false + } + } + if (version instanceof SemVer) { + if (version.loose === options.loose) { + return version + } else { + version = version.version + } + } else if (typeof version !== 'string') { + throw new TypeError('Invalid Version: ' + version) + } + + if (version.length > MAX_LENGTH) { + throw new TypeError('version is longer than ' + MAX_LENGTH + ' characters') + } + + if (!(this instanceof SemVer)) { + return new SemVer(version, options) + } + + debug('SemVer', version, options) + this.options = options + this.loose = !!options.loose + + var m = version.trim().match(options.loose ? re[LOOSE] : re[FULL]) + + if (!m) { + throw new TypeError('Invalid Version: ' + version) + } + + this.raw = version + + // these are actually numbers + this.major = +m[1] + this.minor = +m[2] + this.patch = +m[3] + + if (this.major > MAX_SAFE_INTEGER || this.major < 0) { + throw new TypeError('Invalid major version') + } + + if (this.minor > MAX_SAFE_INTEGER || this.minor < 0) { + throw new TypeError('Invalid minor version') + } + + if (this.patch > MAX_SAFE_INTEGER || this.patch < 0) { + throw new TypeError('Invalid patch version') + } + + // numberify any prerelease numeric ids + if (!m[4]) { + this.prerelease = [] + } else { + this.prerelease = m[4].split('.').map(function (id) { + if (/^[0-9]+$/.test(id)) { + var num = +id + if (num >= 0 && num < MAX_SAFE_INTEGER) { + return num + } + } + return id + }) + } + + this.build = m[5] ? m[5].split('.') : [] + this.format() +} + +SemVer.prototype.format = function () { + this.version = this.major + '.' + this.minor + '.' + this.patch + if (this.prerelease.length) { + this.version += '-' + this.prerelease.join('.') + } + return this.version +} + +SemVer.prototype.toString = function () { + return this.version +} + +SemVer.prototype.compare = function (other) { + debug('SemVer.compare', this.version, this.options, other) + if (!(other instanceof SemVer)) { + other = new SemVer(other, this.options) + } + + return this.compareMain(other) || this.comparePre(other) +} + +SemVer.prototype.compareMain = function (other) { + if (!(other instanceof SemVer)) { + other = new SemVer(other, this.options) + } + + return compareIdentifiers(this.major, other.major) || + compareIdentifiers(this.minor, other.minor) || + compareIdentifiers(this.patch, other.patch) +} + +SemVer.prototype.comparePre = function (other) { + if (!(other instanceof SemVer)) { + other = new SemVer(other, this.options) + } + + // NOT having a prerelease is > having one + if (this.prerelease.length && !other.prerelease.length) { + return -1 + } else if (!this.prerelease.length && other.prerelease.length) { + return 1 + } else if (!this.prerelease.length && !other.prerelease.length) { + return 0 + } + + var i = 0 + do { + var a = this.prerelease[i] + var b = other.prerelease[i] + debug('prerelease compare', i, a, b) + if (a === undefined && b === undefined) { + return 0 + } else if (b === undefined) { + return 1 + } else if (a === undefined) { + return -1 + } else if (a === b) { + continue + } else { + return compareIdentifiers(a, b) + } + } while (++i) +} + +// preminor will bump the version up to the next minor release, and immediately +// down to pre-release. premajor and prepatch work the same way. +SemVer.prototype.inc = function (release, identifier) { + switch (release) { + case 'premajor': + this.prerelease.length = 0 + this.patch = 0 + this.minor = 0 + this.major++ + this.inc('pre', identifier) + break + case 'preminor': + this.prerelease.length = 0 + this.patch = 0 + this.minor++ + this.inc('pre', identifier) + break + case 'prepatch': + // If this is already a prerelease, it will bump to the next version + // drop any prereleases that might already exist, since they are not + // relevant at this point. + this.prerelease.length = 0 + this.inc('patch', identifier) + this.inc('pre', identifier) + break + // If the input is a non-prerelease version, this acts the same as + // prepatch. + case 'prerelease': + if (this.prerelease.length === 0) { + this.inc('patch', identifier) + } + this.inc('pre', identifier) + break + + case 'major': + // If this is a pre-major version, bump up to the same major version. + // Otherwise increment major. + // 1.0.0-5 bumps to 1.0.0 + // 1.1.0 bumps to 2.0.0 + if (this.minor !== 0 || + this.patch !== 0 || + this.prerelease.length === 0) { + this.major++ + } + this.minor = 0 + this.patch = 0 + this.prerelease = [] + break + case 'minor': + // If this is a pre-minor version, bump up to the same minor version. + // Otherwise increment minor. + // 1.2.0-5 bumps to 1.2.0 + // 1.2.1 bumps to 1.3.0 + if (this.patch !== 0 || this.prerelease.length === 0) { + this.minor++ + } + this.patch = 0 + this.prerelease = [] + break + case 'patch': + // If this is not a pre-release version, it will increment the patch. + // If it is a pre-release it will bump up to the same patch version. + // 1.2.0-5 patches to 1.2.0 + // 1.2.0 patches to 1.2.1 + if (this.prerelease.length === 0) { + this.patch++ + } + this.prerelease = [] + break + // This probably shouldn't be used publicly. + // 1.0.0 "pre" would become 1.0.0-0 which is the wrong direction. + case 'pre': + if (this.prerelease.length === 0) { + this.prerelease = [0] + } else { + var i = this.prerelease.length + while (--i >= 0) { + if (typeof this.prerelease[i] === 'number') { + this.prerelease[i]++ + i = -2 + } + } + if (i === -1) { + // didn't increment anything + this.prerelease.push(0) + } + } + if (identifier) { + // 1.2.0-beta.1 bumps to 1.2.0-beta.2, + // 1.2.0-beta.fooblz or 1.2.0-beta bumps to 1.2.0-beta.0 + if (this.prerelease[0] === identifier) { + if (isNaN(this.prerelease[1])) { + this.prerelease = [identifier, 0] + } + } else { + this.prerelease = [identifier, 0] + } + } + break + + default: + throw new Error('invalid increment argument: ' + release) + } + this.format() + this.raw = this.version + return this +} + +exports.inc = inc +function inc (version, release, loose, identifier) { + if (typeof (loose) === 'string') { + identifier = loose + loose = undefined + } + + try { + return new SemVer(version, loose).inc(release, identifier).version + } catch (er) { + return null + } +} + +exports.diff = diff +function diff (version1, version2) { + if (eq(version1, version2)) { + return null + } else { + var v1 = parse(version1) + var v2 = parse(version2) + var prefix = '' + if (v1.prerelease.length || v2.prerelease.length) { + prefix = 'pre' + var defaultResult = 'prerelease' + } + for (var key in v1) { + if (key === 'major' || key === 'minor' || key === 'patch') { + if (v1[key] !== v2[key]) { + return prefix + key + } + } + } + return defaultResult // may be undefined + } +} + +exports.compareIdentifiers = compareIdentifiers + +var numeric = /^[0-9]+$/ +function compareIdentifiers (a, b) { + var anum = numeric.test(a) + var bnum = numeric.test(b) + + if (anum && bnum) { + a = +a + b = +b + } + + return a === b ? 0 + : (anum && !bnum) ? -1 + : (bnum && !anum) ? 1 + : a < b ? -1 + : 1 +} + +exports.rcompareIdentifiers = rcompareIdentifiers +function rcompareIdentifiers (a, b) { + return compareIdentifiers(b, a) +} + +exports.major = major +function major (a, loose) { + return new SemVer(a, loose).major +} + +exports.minor = minor +function minor (a, loose) { + return new SemVer(a, loose).minor +} + +exports.patch = patch +function patch (a, loose) { + return new SemVer(a, loose).patch +} + +exports.compare = compare +function compare (a, b, loose) { + return new SemVer(a, loose).compare(new SemVer(b, loose)) +} + +exports.compareLoose = compareLoose +function compareLoose (a, b) { + return compare(a, b, true) +} + +exports.rcompare = rcompare +function rcompare (a, b, loose) { + return compare(b, a, loose) +} + +exports.sort = sort +function sort (list, loose) { + return list.sort(function (a, b) { + return exports.compare(a, b, loose) + }) +} + +exports.rsort = rsort +function rsort (list, loose) { + return list.sort(function (a, b) { + return exports.rcompare(a, b, loose) + }) +} + +exports.gt = gt +function gt (a, b, loose) { + return compare(a, b, loose) > 0 +} + +exports.lt = lt +function lt (a, b, loose) { + return compare(a, b, loose) < 0 +} + +exports.eq = eq +function eq (a, b, loose) { + return compare(a, b, loose) === 0 +} + +exports.neq = neq +function neq (a, b, loose) { + return compare(a, b, loose) !== 0 +} + +exports.gte = gte +function gte (a, b, loose) { + return compare(a, b, loose) >= 0 +} + +exports.lte = lte +function lte (a, b, loose) { + return compare(a, b, loose) <= 0 +} + +exports.cmp = cmp +function cmp (a, op, b, loose) { + switch (op) { + case '===': + if (typeof a === 'object') + a = a.version + if (typeof b === 'object') + b = b.version + return a === b + + case '!==': + if (typeof a === 'object') + a = a.version + if (typeof b === 'object') + b = b.version + return a !== b + + case '': + case '=': + case '==': + return eq(a, b, loose) + + case '!=': + return neq(a, b, loose) + + case '>': + return gt(a, b, loose) + + case '>=': + return gte(a, b, loose) + + case '<': + return lt(a, b, loose) + + case '<=': + return lte(a, b, loose) + + default: + throw new TypeError('Invalid operator: ' + op) + } +} + +exports.Comparator = Comparator +function Comparator (comp, options) { + if (!options || typeof options !== 'object') { + options = { + loose: !!options, + includePrerelease: false + } + } + + if (comp instanceof Comparator) { + if (comp.loose === !!options.loose) { + return comp + } else { + comp = comp.value + } + } + + if (!(this instanceof Comparator)) { + return new Comparator(comp, options) + } + + debug('comparator', comp, options) + this.options = options + this.loose = !!options.loose + this.parse(comp) + + if (this.semver === ANY) { + this.value = '' + } else { + this.value = this.operator + this.semver.version + } + + debug('comp', this) +} + +var ANY = {} +Comparator.prototype.parse = function (comp) { + var r = this.options.loose ? re[COMPARATORLOOSE] : re[COMPARATOR] + var m = comp.match(r) + + if (!m) { + throw new TypeError('Invalid comparator: ' + comp) + } + + this.operator = m[1] + if (this.operator === '=') { + this.operator = '' + } + + // if it literally is just '>' or '' then allow anything. + if (!m[2]) { + this.semver = ANY + } else { + this.semver = new SemVer(m[2], this.options.loose) + } +} + +Comparator.prototype.toString = function () { + return this.value +} + +Comparator.prototype.test = function (version) { + debug('Comparator.test', version, this.options.loose) + + if (this.semver === ANY) { + return true + } + + if (typeof version === 'string') { + version = new SemVer(version, this.options) + } + + return cmp(version, this.operator, this.semver, this.options) +} + +Comparator.prototype.intersects = function (comp, options) { + if (!(comp instanceof Comparator)) { + throw new TypeError('a Comparator is required') + } + + if (!options || typeof options !== 'object') { + options = { + loose: !!options, + includePrerelease: false + } + } + + var rangeTmp + + if (this.operator === '') { + rangeTmp = new Range(comp.value, options) + return satisfies(this.value, rangeTmp, options) + } else if (comp.operator === '') { + rangeTmp = new Range(this.value, options) + return satisfies(comp.semver, rangeTmp, options) + } + + var sameDirectionIncreasing = + (this.operator === '>=' || this.operator === '>') && + (comp.operator === '>=' || comp.operator === '>') + var sameDirectionDecreasing = + (this.operator === '<=' || this.operator === '<') && + (comp.operator === '<=' || comp.operator === '<') + var sameSemVer = this.semver.version === comp.semver.version + var differentDirectionsInclusive = + (this.operator === '>=' || this.operator === '<=') && + (comp.operator === '>=' || comp.operator === '<=') + var oppositeDirectionsLessThan = + cmp(this.semver, '<', comp.semver, options) && + ((this.operator === '>=' || this.operator === '>') && + (comp.operator === '<=' || comp.operator === '<')) + var oppositeDirectionsGreaterThan = + cmp(this.semver, '>', comp.semver, options) && + ((this.operator === '<=' || this.operator === '<') && + (comp.operator === '>=' || comp.operator === '>')) + + return sameDirectionIncreasing || sameDirectionDecreasing || + (sameSemVer && differentDirectionsInclusive) || + oppositeDirectionsLessThan || oppositeDirectionsGreaterThan +} + +exports.Range = Range +function Range (range, options) { + if (!options || typeof options !== 'object') { + options = { + loose: !!options, + includePrerelease: false + } + } + + if (range instanceof Range) { + if (range.loose === !!options.loose && + range.includePrerelease === !!options.includePrerelease) { + return range + } else { + return new Range(range.raw, options) + } + } + + if (range instanceof Comparator) { + return new Range(range.value, options) + } + + if (!(this instanceof Range)) { + return new Range(range, options) + } + + this.options = options + this.loose = !!options.loose + this.includePrerelease = !!options.includePrerelease + + // First, split based on boolean or || + this.raw = range + this.set = range.split(/\s*\|\|\s*/).map(function (range) { + return this.parseRange(range.trim()) + }, this).filter(function (c) { + // throw out any that are not relevant for whatever reason + return c.length + }) + + if (!this.set.length) { + throw new TypeError('Invalid SemVer Range: ' + range) + } + + this.format() +} + +Range.prototype.format = function () { + this.range = this.set.map(function (comps) { + return comps.join(' ').trim() + }).join('||').trim() + return this.range +} + +Range.prototype.toString = function () { + return this.range +} + +Range.prototype.parseRange = function (range) { + var loose = this.options.loose + range = range.trim() + // `1.2.3 - 1.2.4` => `>=1.2.3 <=1.2.4` + var hr = loose ? re[HYPHENRANGELOOSE] : re[HYPHENRANGE] + range = range.replace(hr, hyphenReplace) + debug('hyphen replace', range) + // `> 1.2.3 < 1.2.5` => `>1.2.3 <1.2.5` + range = range.replace(re[COMPARATORTRIM], comparatorTrimReplace) + debug('comparator trim', range, re[COMPARATORTRIM]) + + // `~ 1.2.3` => `~1.2.3` + range = range.replace(re[TILDETRIM], tildeTrimReplace) + + // `^ 1.2.3` => `^1.2.3` + range = range.replace(re[CARETTRIM], caretTrimReplace) + + // normalize spaces + range = range.split(/\s+/).join(' ') + + // At this point, the range is completely trimmed and + // ready to be split into comparators. + + var compRe = loose ? re[COMPARATORLOOSE] : re[COMPARATOR] + var set = range.split(' ').map(function (comp) { + return parseComparator(comp, this.options) + }, this).join(' ').split(/\s+/) + if (this.options.loose) { + // in loose mode, throw out any that are not valid comparators + set = set.filter(function (comp) { + return !!comp.match(compRe) + }) + } + set = set.map(function (comp) { + return new Comparator(comp, this.options) + }, this) + + return set +} + +Range.prototype.intersects = function (range, options) { + if (!(range instanceof Range)) { + throw new TypeError('a Range is required') + } + + return this.set.some(function (thisComparators) { + return thisComparators.every(function (thisComparator) { + return range.set.some(function (rangeComparators) { + return rangeComparators.every(function (rangeComparator) { + return thisComparator.intersects(rangeComparator, options) + }) + }) + }) + }) +} + +// Mostly just for testing and legacy API reasons +exports.toComparators = toComparators +function toComparators (range, options) { + return new Range(range, options).set.map(function (comp) { + return comp.map(function (c) { + return c.value + }).join(' ').trim().split(' ') + }) +} + +// comprised of xranges, tildes, stars, and gtlt's at this point. +// already replaced the hyphen ranges +// turn into a set of JUST comparators. +function parseComparator (comp, options) { + debug('comp', comp, options) + comp = replaceCarets(comp, options) + debug('caret', comp) + comp = replaceTildes(comp, options) + debug('tildes', comp) + comp = replaceXRanges(comp, options) + debug('xrange', comp) + comp = replaceStars(comp, options) + debug('stars', comp) + return comp +} + +function isX (id) { + return !id || id.toLowerCase() === 'x' || id === '*' +} + +// ~, ~> --> * (any, kinda silly) +// ~2, ~2.x, ~2.x.x, ~>2, ~>2.x ~>2.x.x --> >=2.0.0 <3.0.0 +// ~2.0, ~2.0.x, ~>2.0, ~>2.0.x --> >=2.0.0 <2.1.0 +// ~1.2, ~1.2.x, ~>1.2, ~>1.2.x --> >=1.2.0 <1.3.0 +// ~1.2.3, ~>1.2.3 --> >=1.2.3 <1.3.0 +// ~1.2.0, ~>1.2.0 --> >=1.2.0 <1.3.0 +function replaceTildes (comp, options) { + return comp.trim().split(/\s+/).map(function (comp) { + return replaceTilde(comp, options) + }).join(' ') +} + +function replaceTilde (comp, options) { + var r = options.loose ? re[TILDELOOSE] : re[TILDE] + return comp.replace(r, function (_, M, m, p, pr) { + debug('tilde', comp, _, M, m, p, pr) + var ret + + if (isX(M)) { + ret = '' + } else if (isX(m)) { + ret = '>=' + M + '.0.0 <' + (+M + 1) + '.0.0' + } else if (isX(p)) { + // ~1.2 == >=1.2.0 <1.3.0 + ret = '>=' + M + '.' + m + '.0 <' + M + '.' + (+m + 1) + '.0' + } else if (pr) { + debug('replaceTilde pr', pr) + ret = '>=' + M + '.' + m + '.' + p + '-' + pr + + ' <' + M + '.' + (+m + 1) + '.0' + } else { + // ~1.2.3 == >=1.2.3 <1.3.0 + ret = '>=' + M + '.' + m + '.' + p + + ' <' + M + '.' + (+m + 1) + '.0' + } + + debug('tilde return', ret) + return ret + }) +} + +// ^ --> * (any, kinda silly) +// ^2, ^2.x, ^2.x.x --> >=2.0.0 <3.0.0 +// ^2.0, ^2.0.x --> >=2.0.0 <3.0.0 +// ^1.2, ^1.2.x --> >=1.2.0 <2.0.0 +// ^1.2.3 --> >=1.2.3 <2.0.0 +// ^1.2.0 --> >=1.2.0 <2.0.0 +function replaceCarets (comp, options) { + return comp.trim().split(/\s+/).map(function (comp) { + return replaceCaret(comp, options) + }).join(' ') +} + +function replaceCaret (comp, options) { + debug('caret', comp, options) + var r = options.loose ? re[CARETLOOSE] : re[CARET] + return comp.replace(r, function (_, M, m, p, pr) { + debug('caret', comp, _, M, m, p, pr) + var ret + + if (isX(M)) { + ret = '' + } else if (isX(m)) { + ret = '>=' + M + '.0.0 <' + (+M + 1) + '.0.0' + } else if (isX(p)) { + if (M === '0') { + ret = '>=' + M + '.' + m + '.0 <' + M + '.' + (+m + 1) + '.0' + } else { + ret = '>=' + M + '.' + m + '.0 <' + (+M + 1) + '.0.0' + } + } else if (pr) { + debug('replaceCaret pr', pr) + if (M === '0') { + if (m === '0') { + ret = '>=' + M + '.' + m + '.' + p + '-' + pr + + ' <' + M + '.' + m + '.' + (+p + 1) + } else { + ret = '>=' + M + '.' + m + '.' + p + '-' + pr + + ' <' + M + '.' + (+m + 1) + '.0' + } + } else { + ret = '>=' + M + '.' + m + '.' + p + '-' + pr + + ' <' + (+M + 1) + '.0.0' + } + } else { + debug('no pr') + if (M === '0') { + if (m === '0') { + ret = '>=' + M + '.' + m + '.' + p + + ' <' + M + '.' + m + '.' + (+p + 1) + } else { + ret = '>=' + M + '.' + m + '.' + p + + ' <' + M + '.' + (+m + 1) + '.0' + } + } else { + ret = '>=' + M + '.' + m + '.' + p + + ' <' + (+M + 1) + '.0.0' + } + } + + debug('caret return', ret) + return ret + }) +} + +function replaceXRanges (comp, options) { + debug('replaceXRanges', comp, options) + return comp.split(/\s+/).map(function (comp) { + return replaceXRange(comp, options) + }).join(' ') +} + +function replaceXRange (comp, options) { + comp = comp.trim() + var r = options.loose ? re[XRANGELOOSE] : re[XRANGE] + return comp.replace(r, function (ret, gtlt, M, m, p, pr) { + debug('xRange', comp, ret, gtlt, M, m, p, pr) + var xM = isX(M) + var xm = xM || isX(m) + var xp = xm || isX(p) + var anyX = xp + + if (gtlt === '=' && anyX) { + gtlt = '' + } + + if (xM) { + if (gtlt === '>' || gtlt === '<') { + // nothing is allowed + ret = '<0.0.0' + } else { + // nothing is forbidden + ret = '*' + } + } else if (gtlt && anyX) { + // we know patch is an x, because we have any x at all. + // replace X with 0 + if (xm) { + m = 0 + } + p = 0 + + if (gtlt === '>') { + // >1 => >=2.0.0 + // >1.2 => >=1.3.0 + // >1.2.3 => >= 1.2.4 + gtlt = '>=' + if (xm) { + M = +M + 1 + m = 0 + p = 0 + } else { + m = +m + 1 + p = 0 + } + } else if (gtlt === '<=') { + // <=0.7.x is actually <0.8.0, since any 0.7.x should + // pass. Similarly, <=7.x is actually <8.0.0, etc. + gtlt = '<' + if (xm) { + M = +M + 1 + } else { + m = +m + 1 + } + } + + ret = gtlt + M + '.' + m + '.' + p + } else if (xm) { + ret = '>=' + M + '.0.0 <' + (+M + 1) + '.0.0' + } else if (xp) { + ret = '>=' + M + '.' + m + '.0 <' + M + '.' + (+m + 1) + '.0' + } + + debug('xRange return', ret) + + return ret + }) +} + +// Because * is AND-ed with everything else in the comparator, +// and '' means "any version", just remove the *s entirely. +function replaceStars (comp, options) { + debug('replaceStars', comp, options) + // Looseness is ignored here. star is always as loose as it gets! + return comp.trim().replace(re[STAR], '') +} + +// This function is passed to string.replace(re[HYPHENRANGE]) +// M, m, patch, prerelease, build +// 1.2 - 3.4.5 => >=1.2.0 <=3.4.5 +// 1.2.3 - 3.4 => >=1.2.0 <3.5.0 Any 3.4.x will do +// 1.2 - 3.4 => >=1.2.0 <3.5.0 +function hyphenReplace ($0, + from, fM, fm, fp, fpr, fb, + to, tM, tm, tp, tpr, tb) { + if (isX(fM)) { + from = '' + } else if (isX(fm)) { + from = '>=' + fM + '.0.0' + } else if (isX(fp)) { + from = '>=' + fM + '.' + fm + '.0' + } else { + from = '>=' + from + } + + if (isX(tM)) { + to = '' + } else if (isX(tm)) { + to = '<' + (+tM + 1) + '.0.0' + } else if (isX(tp)) { + to = '<' + tM + '.' + (+tm + 1) + '.0' + } else if (tpr) { + to = '<=' + tM + '.' + tm + '.' + tp + '-' + tpr + } else { + to = '<=' + to + } + + return (from + ' ' + to).trim() +} + +// if ANY of the sets match ALL of its comparators, then pass +Range.prototype.test = function (version) { + if (!version) { + return false + } + + if (typeof version === 'string') { + version = new SemVer(version, this.options) + } + + for (var i = 0; i < this.set.length; i++) { + if (testSet(this.set[i], version, this.options)) { + return true + } + } + return false +} + +function testSet (set, version, options) { + for (var i = 0; i < set.length; i++) { + if (!set[i].test(version)) { + return false + } + } + + if (version.prerelease.length && !options.includePrerelease) { + // Find the set of versions that are allowed to have prereleases + // For example, ^1.2.3-pr.1 desugars to >=1.2.3-pr.1 <2.0.0 + // That should allow `1.2.3-pr.2` to pass. + // However, `1.2.4-alpha.notready` should NOT be allowed, + // even though it's within the range set by the comparators. + for (i = 0; i < set.length; i++) { + debug(set[i].semver) + if (set[i].semver === ANY) { + continue + } + + if (set[i].semver.prerelease.length > 0) { + var allowed = set[i].semver + if (allowed.major === version.major && + allowed.minor === version.minor && + allowed.patch === version.patch) { + return true + } + } + } + + // Version has a -pre, but it's not one of the ones we like. + return false + } + + return true +} + +exports.satisfies = satisfies +function satisfies (version, range, options) { + try { + range = new Range(range, options) + } catch (er) { + return false + } + return range.test(version) +} + +exports.maxSatisfying = maxSatisfying +function maxSatisfying (versions, range, options) { + var max = null + var maxSV = null + try { + var rangeObj = new Range(range, options) + } catch (er) { + return null + } + versions.forEach(function (v) { + if (rangeObj.test(v)) { + // satisfies(v, range, options) + if (!max || maxSV.compare(v) === -1) { + // compare(max, v, true) + max = v + maxSV = new SemVer(max, options) + } + } + }) + return max +} + +exports.minSatisfying = minSatisfying +function minSatisfying (versions, range, options) { + var min = null + var minSV = null + try { + var rangeObj = new Range(range, options) + } catch (er) { + return null + } + versions.forEach(function (v) { + if (rangeObj.test(v)) { + // satisfies(v, range, options) + if (!min || minSV.compare(v) === 1) { + // compare(min, v, true) + min = v + minSV = new SemVer(min, options) + } + } + }) + return min +} + +exports.minVersion = minVersion +function minVersion (range, loose) { + range = new Range(range, loose) + + var minver = new SemVer('0.0.0') + if (range.test(minver)) { + return minver + } + + minver = new SemVer('0.0.0-0') + if (range.test(minver)) { + return minver + } + + minver = null + for (var i = 0; i < range.set.length; ++i) { + var comparators = range.set[i] + + comparators.forEach(function (comparator) { + // Clone to avoid manipulating the comparator's semver object. + var compver = new SemVer(comparator.semver.version) + switch (comparator.operator) { + case '>': + if (compver.prerelease.length === 0) { + compver.patch++ + } else { + compver.prerelease.push(0) + } + compver.raw = compver.format() + /* fallthrough */ + case '': + case '>=': + if (!minver || gt(minver, compver)) { + minver = compver + } + break + case '<': + case '<=': + /* Ignore maximum versions */ + break + /* istanbul ignore next */ + default: + throw new Error('Unexpected operation: ' + comparator.operator) + } + }) + } + + if (minver && range.test(minver)) { + return minver + } + + return null +} + +exports.validRange = validRange +function validRange (range, options) { + try { + // Return '*' instead of '' so that truthiness works. + // This will throw if it's invalid anyway + return new Range(range, options).range || '*' + } catch (er) { + return null + } +} + +// Determine if version is less than all the versions possible in the range +exports.ltr = ltr +function ltr (version, range, options) { + return outside(version, range, '<', options) +} + +// Determine if version is greater than all the versions possible in the range. +exports.gtr = gtr +function gtr (version, range, options) { + return outside(version, range, '>', options) +} + +exports.outside = outside +function outside (version, range, hilo, options) { + version = new SemVer(version, options) + range = new Range(range, options) + + var gtfn, ltefn, ltfn, comp, ecomp + switch (hilo) { + case '>': + gtfn = gt + ltefn = lte + ltfn = lt + comp = '>' + ecomp = '>=' + break + case '<': + gtfn = lt + ltefn = gte + ltfn = gt + comp = '<' + ecomp = '<=' + break + default: + throw new TypeError('Must provide a hilo val of "<" or ">"') + } + + // If it satisifes the range it is not outside + if (satisfies(version, range, options)) { + return false + } + + // From now on, variable terms are as if we're in "gtr" mode. + // but note that everything is flipped for the "ltr" function. + + for (var i = 0; i < range.set.length; ++i) { + var comparators = range.set[i] + + var high = null + var low = null + + comparators.forEach(function (comparator) { + if (comparator.semver === ANY) { + comparator = new Comparator('>=0.0.0') + } + high = high || comparator + low = low || comparator + if (gtfn(comparator.semver, high.semver, options)) { + high = comparator + } else if (ltfn(comparator.semver, low.semver, options)) { + low = comparator + } + }) + + // If the edge version comparator has a operator then our version + // isn't outside it + if (high.operator === comp || high.operator === ecomp) { + return false + } + + // If the lowest version comparator has an operator and our version + // is less than it then it isn't higher than the range + if ((!low.operator || low.operator === comp) && + ltefn(version, low.semver)) { + return false + } else if (low.operator === ecomp && ltfn(version, low.semver)) { + return false + } + } + return true +} + +exports.prerelease = prerelease +function prerelease (version, options) { + var parsed = parse(version, options) + return (parsed && parsed.prerelease.length) ? parsed.prerelease : null +} + +exports.intersects = intersects +function intersects (r1, r2, options) { + r1 = new Range(r1, options) + r2 = new Range(r2, options) + return r1.intersects(r2) +} + +exports.coerce = coerce +function coerce (version) { + if (version instanceof SemVer) { + return version + } + + if (typeof version !== 'string') { + return null + } + + var match = version.match(re[COERCE]) + + if (match == null) { + return null + } + + return parse(match[1] + + '.' + (match[2] || '0') + + '.' + (match[3] || '0')) +} + + +/***/ }), + +/***/ 293: +/***/ (function(module, __unusedexports, __webpack_require__) { + +module.exports = authenticationRequestError; + +const { RequestError } = __webpack_require__(497); + +function authenticationRequestError(state, error, options) { + if (!error.headers) throw error; + + const otpRequired = /required/.test(error.headers["x-github-otp"] || ""); + // handle "2FA required" error only + if (error.status !== 401 || !otpRequired) { + throw error; + } + + if ( + error.status === 401 && + otpRequired && + error.request && + error.request.headers["x-github-otp"] + ) { + if (state.otp) { + delete state.otp; // no longer valid, request again + } else { + throw new RequestError( + "Invalid one-time password for two-factor authentication", + 401, + { + headers: error.headers, + request: options + } + ); + } + } + + if (typeof state.auth.on2fa !== "function") { + throw new RequestError( + "2FA required, but options.on2fa is not a function. See https://github.com/octokit/rest.js#authentication", + 401, + { + headers: error.headers, + request: options + } + ); + } + + return Promise.resolve() + .then(() => { + return state.auth.on2fa(); + }) + .then(oneTimePassword => { + const newOptions = Object.assign(options, { + headers: Object.assign(options.headers, { + "x-github-otp": oneTimePassword + }) + }); + return state.octokit.request(newOptions).then(response => { + // If OTP still valid, then persist it for following requests + state.otp = oneTimePassword; + return response; + }); + }); +} + + +/***/ }), + +/***/ 294: +/***/ (function(module, __unusedexports, __webpack_require__) { + +module.exports = parseOptions; + +const { Deprecation } = __webpack_require__(692); +const { getUserAgent } = __webpack_require__(796); +const once = __webpack_require__(969); + +const pkg = __webpack_require__(215); + +const deprecateOptionsTimeout = once((log, deprecation) => + log.warn(deprecation) +); +const deprecateOptionsAgent = once((log, deprecation) => log.warn(deprecation)); +const deprecateOptionsHeaders = once((log, deprecation) => + log.warn(deprecation) +); + +function parseOptions(options, log, hook) { + if (options.headers) { + options.headers = Object.keys(options.headers).reduce((newObj, key) => { + newObj[key.toLowerCase()] = options.headers[key]; + return newObj; + }, {}); + } + + const clientDefaults = { + headers: options.headers || {}, + request: options.request || {}, + mediaType: { + previews: [], + format: "" + } + }; + + if (options.baseUrl) { + clientDefaults.baseUrl = options.baseUrl; + } + + if (options.userAgent) { + clientDefaults.headers["user-agent"] = options.userAgent; + } + + if (options.previews) { + clientDefaults.mediaType.previews = options.previews; + } + + if (options.timeZone) { + clientDefaults.headers["time-zone"] = options.timeZone; + } + + if (options.timeout) { + deprecateOptionsTimeout( + log, + new Deprecation( + "[@octokit/rest] new Octokit({timeout}) is deprecated. Use {request: {timeout}} instead. See https://github.com/octokit/request.js#request" + ) + ); + clientDefaults.request.timeout = options.timeout; + } + + if (options.agent) { + deprecateOptionsAgent( + log, + new Deprecation( + "[@octokit/rest] new Octokit({agent}) is deprecated. Use {request: {agent}} instead. See https://github.com/octokit/request.js#request" + ) + ); + clientDefaults.request.agent = options.agent; + } + + if (options.headers) { + deprecateOptionsHeaders( + log, + new Deprecation( + "[@octokit/rest] new Octokit({headers}) is deprecated. Use {userAgent, previews} instead. See https://github.com/octokit/request.js#request" + ) + ); + } + + const userAgentOption = clientDefaults.headers["user-agent"]; + const defaultUserAgent = `octokit.js/${pkg.version} ${getUserAgent()}`; + + clientDefaults.headers["user-agent"] = [userAgentOption, defaultUserAgent] + .filter(Boolean) + .join(" "); + + clientDefaults.request.hook = hook.bind(null, "request"); + + return clientDefaults; +} + + +/***/ }), + +/***/ 297: +/***/ (function(module) { + +module.exports = class HttpError extends Error { + constructor (message, code, headers) { + super(message) + + // Maintains proper stack trace (only available on V8) + /* istanbul ignore next */ + if (Error.captureStackTrace) { + Error.captureStackTrace(this, this.constructor) + } + + this.name = 'HttpError' + this.code = code + this.headers = headers + } +} + + +/***/ }), + +/***/ 299: +/***/ (function(__unusedmodule, exports) { + +"use strict"; + + +Object.defineProperty(exports, '__esModule', { value: true }); + +const VERSION = "1.1.2"; + +/** + * Some “list” response that can be paginated have a different response structure + * + * They have a `total_count` key in the response (search also has `incomplete_results`, + * /installation/repositories also has `repository_selection`), as well as a key with + * the list of the items which name varies from endpoint to endpoint: + * + * - https://developer.github.com/v3/search/#example (key `items`) + * - https://developer.github.com/v3/checks/runs/#response-3 (key: `check_runs`) + * - https://developer.github.com/v3/checks/suites/#response-1 (key: `check_suites`) + * - https://developer.github.com/v3/apps/installations/#list-repositories (key: `repositories`) + * - https://developer.github.com/v3/apps/installations/#list-installations-for-a-user (key `installations`) + * + * Octokit normalizes these responses so that paginated results are always returned following + * the same structure. One challenge is that if the list response has only one page, no Link + * header is provided, so this header alone is not sufficient to check wether a response is + * paginated or not. For the exceptions with the namespace, a fallback check for the route + * paths has to be added in order to normalize the response. We cannot check for the total_count + * property because it also exists in the response of Get the combined status for a specific ref. + */ +const REGEX = [/^\/search\//, /^\/repos\/[^/]+\/[^/]+\/commits\/[^/]+\/(check-runs|check-suites)([^/]|$)/, /^\/installation\/repositories([^/]|$)/, /^\/user\/installations([^/]|$)/, /^\/repos\/[^/]+\/[^/]+\/actions\/secrets([^/]|$)/, /^\/repos\/[^/]+\/[^/]+\/actions\/workflows(\/[^/]+\/runs)?([^/]|$)/, /^\/repos\/[^/]+\/[^/]+\/actions\/runs(\/[^/]+\/(artifacts|jobs))?([^/]|$)/]; +function normalizePaginatedListResponse(octokit, url, response) { + const path = url.replace(octokit.request.endpoint.DEFAULTS.baseUrl, ""); + const responseNeedsNormalization = REGEX.find(regex => regex.test(path)); + if (!responseNeedsNormalization) return; // keep the additional properties intact as there is currently no other way + // to retrieve the same information. + + const incompleteResults = response.data.incomplete_results; + const repositorySelection = response.data.repository_selection; + const totalCount = response.data.total_count; + delete response.data.incomplete_results; + delete response.data.repository_selection; + delete response.data.total_count; + const namespaceKey = Object.keys(response.data)[0]; + const data = response.data[namespaceKey]; + response.data = data; + + if (typeof incompleteResults !== "undefined") { + response.data.incomplete_results = incompleteResults; + } + + if (typeof repositorySelection !== "undefined") { + response.data.repository_selection = repositorySelection; + } + + response.data.total_count = totalCount; + Object.defineProperty(response.data, namespaceKey, { + get() { + octokit.log.warn(`[@octokit/paginate-rest] "response.data.${namespaceKey}" is deprecated for "GET ${path}". Get the results directly from "response.data"`); + return Array.from(data); + } + + }); +} + +function iterator(octokit, route, parameters) { + const options = octokit.request.endpoint(route, parameters); + const method = options.method; + const headers = options.headers; + let url = options.url; + return { + [Symbol.asyncIterator]: () => ({ + next() { + if (!url) { + return Promise.resolve({ + done: true + }); + } + + return octokit.request({ + method, + url, + headers + }).then(response => { + normalizePaginatedListResponse(octokit, url, response); // `response.headers.link` format: + // '; rel="next", ; rel="last"' + // sets `url` to undefined if "next" URL is not present or `link` header is not set + + url = ((response.headers.link || "").match(/<([^>]+)>;\s*rel="next"/) || [])[1]; + return { + value: response + }; + }); + } + + }) + }; +} + +function paginate(octokit, route, parameters, mapFn) { + if (typeof parameters === "function") { + mapFn = parameters; + parameters = undefined; + } + + return gather(octokit, [], iterator(octokit, route, parameters)[Symbol.asyncIterator](), mapFn); +} + +function gather(octokit, results, iterator, mapFn) { + return iterator.next().then(result => { + if (result.done) { + return results; + } + + let earlyExit = false; + + function done() { + earlyExit = true; + } + + results = results.concat(mapFn ? mapFn(result.value, done) : result.value.data); + + if (earlyExit) { + return results; + } + + return gather(octokit, results, iterator, mapFn); + }); +} + +/** + * @param octokit Octokit instance + * @param options Options passed to Octokit constructor + */ + +function paginateRest(octokit) { + return { + paginate: Object.assign(paginate.bind(null, octokit), { + iterator: iterator.bind(null, octokit) + }) + }; +} +paginateRest.VERSION = VERSION; + +exports.paginateRest = paginateRest; +//# sourceMappingURL=index.js.map + + +/***/ }), + +/***/ 314: +/***/ (function(__unusedmodule, exports, __webpack_require__) { + +"use strict"; + +// A mechanism for evaluating user-provided strings or scripts. For +// strings, this will take user input and parse anything within +// double curly-braces (`{{ }}`) as eval-able JavaScript. Several +// helper functions (like `date()`, `time()`, etc) will be provided. +// Users can provide additional data that will be given to the +// functions. +Object.defineProperty(exports, "__esModule", { value: true }); +const date_1 = __webpack_require__(404); +class Evaluate { + static invokeAsyncFunction(source, args) { + const asyncFn = Object.getPrototypeOf(async () => { }).constructor; + const fn = new asyncFn(...Object.keys(args), source); + return fn(...Object.values(args)); + } + static createArgs(additional = null) { + let args = { + date: date_1.date, + time: date_1.time, + datetime: date_1.datetime + }; + for (let key in additional) { + if (key in args) { + throw new Error(`cannot redefine evaluation global '${key}'`); + } + args[key] = additional[key]; + } + return args; + } + static async runScript(input, additional = null) { + const args = Evaluate.createArgs(additional); + return await Evaluate.invokeAsyncFunction(input, args); + } + static async parseExpression(raw, additional = null) { + const args = Evaluate.createArgs(additional); + const search = new RegExp('{{(.*?)}}', 'g'); + let match; + let output = new Array(); + let last = 0; + while (match = search.exec(raw)) { + if (match.index > 0) { + output.push(raw.substring(last, match.index)); + } + output.push(await Evaluate.invokeAsyncFunction(`return (async () => ${match[1]})()`, args)); + last = search.lastIndex; + } + if (last < raw.length) { + output.push(raw.substring(last, raw.length)); + } + return output.join(''); + } +} +exports.Evaluate = Evaluate; + + +/***/ }), + +/***/ 323: +/***/ (function(module) { + +"use strict"; + + +var isStream = module.exports = function (stream) { + return stream !== null && typeof stream === 'object' && typeof stream.pipe === 'function'; +}; + +isStream.writable = function (stream) { + return isStream(stream) && stream.writable !== false && typeof stream._write === 'function' && typeof stream._writableState === 'object'; +}; + +isStream.readable = function (stream) { + return isStream(stream) && stream.readable !== false && typeof stream._read === 'function' && typeof stream._readableState === 'object'; +}; + +isStream.duplex = function (stream) { + return isStream.writable(stream) && isStream.readable(stream); +}; + +isStream.transform = function (stream) { + return isStream.duplex(stream) && typeof stream._transform === 'function' && typeof stream._transformState === 'object'; +}; + + +/***/ }), + +/***/ 336: +/***/ (function(module, __unusedexports, __webpack_require__) { + +module.exports = hasLastPage + +const deprecate = __webpack_require__(370) +const getPageLinks = __webpack_require__(577) + +function hasLastPage (link) { + deprecate(`octokit.hasLastPage() – You can use octokit.paginate or async iterators instead: https://github.com/octokit/rest.js#pagination.`) + return getPageLinks(link).last +} + + +/***/ }), + +/***/ 348: +/***/ (function(module, __unusedexports, __webpack_require__) { + +"use strict"; + + +module.exports = validate; + +const { RequestError } = __webpack_require__(497); +const get = __webpack_require__(854); +const set = __webpack_require__(883); + +function validate(octokit, options) { + if (!options.request.validate) { + return; + } + const { validate: params } = options.request; + + Object.keys(params).forEach(parameterName => { + const parameter = get(params, parameterName); + + const expectedType = parameter.type; + let parentParameterName; + let parentValue; + let parentParamIsPresent = true; + let parentParameterIsArray = false; + + if (/\./.test(parameterName)) { + parentParameterName = parameterName.replace(/\.[^.]+$/, ""); + parentParameterIsArray = parentParameterName.slice(-2) === "[]"; + if (parentParameterIsArray) { + parentParameterName = parentParameterName.slice(0, -2); + } + parentValue = get(options, parentParameterName); + parentParamIsPresent = + parentParameterName === "headers" || + (typeof parentValue === "object" && parentValue !== null); + } + + const values = parentParameterIsArray + ? (get(options, parentParameterName) || []).map( + value => value[parameterName.split(/\./).pop()] + ) + : [get(options, parameterName)]; + + values.forEach((value, i) => { + const valueIsPresent = typeof value !== "undefined"; + const valueIsNull = value === null; + const currentParameterName = parentParameterIsArray + ? parameterName.replace(/\[\]/, `[${i}]`) + : parameterName; + + if (!parameter.required && !valueIsPresent) { + return; + } + + // if the parent parameter is of type object but allows null + // then the child parameters can be ignored + if (!parentParamIsPresent) { + return; + } + + if (parameter.allowNull && valueIsNull) { + return; + } + + if (!parameter.allowNull && valueIsNull) { + throw new RequestError( + `'${currentParameterName}' cannot be null`, + 400, + { + request: options + } + ); + } + + if (parameter.required && !valueIsPresent) { + throw new RequestError( + `Empty value for parameter '${currentParameterName}': ${JSON.stringify( + value + )}`, + 400, + { + request: options + } + ); + } + + // parse to integer before checking for enum + // so that string "1" will match enum with number 1 + if (expectedType === "integer") { + const unparsedValue = value; + value = parseInt(value, 10); + if (isNaN(value)) { + throw new RequestError( + `Invalid value for parameter '${currentParameterName}': ${JSON.stringify( + unparsedValue + )} is NaN`, + 400, + { + request: options + } + ); + } + } + + if (parameter.enum && parameter.enum.indexOf(String(value)) === -1) { + throw new RequestError( + `Invalid value for parameter '${currentParameterName}': ${JSON.stringify( + value + )}`, + 400, + { + request: options + } + ); + } + + if (parameter.validation) { + const regex = new RegExp(parameter.validation); + if (!regex.test(value)) { + throw new RequestError( + `Invalid value for parameter '${currentParameterName}': ${JSON.stringify( + value + )}`, + 400, + { + request: options + } + ); + } + } + + if (expectedType === "object" && typeof value === "string") { + try { + value = JSON.parse(value); + } catch (exception) { + throw new RequestError( + `JSON parse error of value for parameter '${currentParameterName}': ${JSON.stringify( + value + )}`, + 400, + { + request: options + } + ); + } + } + + set(options, parameter.mapTo || currentParameterName, value); + }); + }); + + return options; +} + + +/***/ }), + +/***/ 349: +/***/ (function(module, __unusedexports, __webpack_require__) { + +module.exports = authenticationRequestError; + +const { RequestError } = __webpack_require__(497); + +function authenticationRequestError(state, error, options) { + /* istanbul ignore next */ + if (!error.headers) throw error; + + const otpRequired = /required/.test(error.headers["x-github-otp"] || ""); + // handle "2FA required" error only + if (error.status !== 401 || !otpRequired) { + throw error; + } + + if ( + error.status === 401 && + otpRequired && + error.request && + error.request.headers["x-github-otp"] + ) { + throw new RequestError( + "Invalid one-time password for two-factor authentication", + 401, + { + headers: error.headers, + request: options + } + ); + } + + if (typeof state.auth.on2fa !== "function") { + throw new RequestError( + "2FA required, but options.on2fa is not a function. See https://github.com/octokit/rest.js#authentication", + 401, + { + headers: error.headers, + request: options + } + ); + } + + return Promise.resolve() + .then(() => { + return state.auth.on2fa(); + }) + .then(oneTimePassword => { + const newOptions = Object.assign(options, { + headers: Object.assign( + { "x-github-otp": oneTimePassword }, + options.headers + ) + }); + return state.octokit.request(newOptions); + }); +} + + +/***/ }), + +/***/ 352: +/***/ (function(module, __unusedexports, __webpack_require__) { + +"use strict"; + + +var esprima; + +// Browserified version does not have esprima +// +// 1. For node.js just require module as deps +// 2. For browser try to require mudule via external AMD system. +// If not found - try to fallback to window.esprima. If not +// found too - then fail to parse. +// +try { + // workaround to exclude package from browserify list. + var _require = require; + esprima = _require('esprima'); +} catch (_) { + /*global window */ + if (typeof window !== 'undefined') esprima = window.esprima; +} + +var Type = __webpack_require__(945); + +function resolveJavascriptFunction(data) { + if (data === null) return false; + + try { + var source = '(' + data + ')', + ast = esprima.parse(source, { range: true }); + + if (ast.type !== 'Program' || + ast.body.length !== 1 || + ast.body[0].type !== 'ExpressionStatement' || + (ast.body[0].expression.type !== 'ArrowFunctionExpression' && + ast.body[0].expression.type !== 'FunctionExpression')) { + return false; + } + + return true; + } catch (err) { + return false; + } +} + +function constructJavascriptFunction(data) { + /*jslint evil:true*/ + + var source = '(' + data + ')', + ast = esprima.parse(source, { range: true }), + params = [], + body; + + if (ast.type !== 'Program' || + ast.body.length !== 1 || + ast.body[0].type !== 'ExpressionStatement' || + (ast.body[0].expression.type !== 'ArrowFunctionExpression' && + ast.body[0].expression.type !== 'FunctionExpression')) { + throw new Error('Failed to resolve function'); + } + + ast.body[0].expression.params.forEach(function (param) { + params.push(param.name); + }); + + body = ast.body[0].expression.body.range; + + // Esprima's ranges include the first '{' and the last '}' characters on + // function expressions. So cut them out. + if (ast.body[0].expression.body.type === 'BlockStatement') { + /*eslint-disable no-new-func*/ + return new Function(params, source.slice(body[0] + 1, body[1] - 1)); + } + // ES6 arrow functions can omit the BlockStatement. In that case, just return + // the body. + /*eslint-disable no-new-func*/ + return new Function(params, 'return ' + source.slice(body[0], body[1])); +} + +function representJavascriptFunction(object /*, style*/) { + return object.toString(); +} + +function isFunction(object) { + return Object.prototype.toString.call(object) === '[object Function]'; +} + +module.exports = new Type('tag:yaml.org,2002:js/function', { + kind: 'scalar', + resolve: resolveJavascriptFunction, + construct: constructJavascriptFunction, + predicate: isFunction, + represent: representJavascriptFunction +}); + + +/***/ }), + +/***/ 357: +/***/ (function(module) { + +module.exports = require("assert"); + +/***/ }), + +/***/ 363: +/***/ (function(module) { + +module.exports = register + +function register (state, name, method, options) { + if (typeof method !== 'function') { + throw new Error('method for before hook must be a function') + } + + if (!options) { + options = {} + } + + if (Array.isArray(name)) { + return name.reverse().reduce(function (callback, name) { + return register.bind(null, state, name, callback, options) + }, method)() + } + + return Promise.resolve() + .then(function () { + if (!state.registry[name]) { + return method(options) + } + + return (state.registry[name]).reduce(function (method, registered) { + return registered.hook.bind(null, method, options) + }, method)() + }) +} + + +/***/ }), + +/***/ 368: +/***/ (function(module) { + +module.exports = function atob(str) { + return Buffer.from(str, 'base64').toString('binary') +} + + +/***/ }), + +/***/ 370: +/***/ (function(module) { + +module.exports = deprecate + +const loggedMessages = {} + +function deprecate (message) { + if (loggedMessages[message]) { + return + } + + console.warn(`DEPRECATED (@octokit/rest): ${message}`) + loggedMessages[message] = 1 +} + + +/***/ }), + +/***/ 385: +/***/ (function(__unusedmodule, exports, __webpack_require__) { + +"use strict"; + + +Object.defineProperty(exports, '__esModule', { value: true }); + +function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; } + +var isPlainObject = _interopDefault(__webpack_require__(696)); +var universalUserAgent = __webpack_require__(562); + +function lowercaseKeys(object) { + if (!object) { + return {}; + } + + return Object.keys(object).reduce((newObj, key) => { + newObj[key.toLowerCase()] = object[key]; + return newObj; + }, {}); +} + +function mergeDeep(defaults, options) { + const result = Object.assign({}, defaults); + Object.keys(options).forEach(key => { + if (isPlainObject(options[key])) { + if (!(key in defaults)) Object.assign(result, { + [key]: options[key] + });else result[key] = mergeDeep(defaults[key], options[key]); + } else { + Object.assign(result, { + [key]: options[key] + }); + } + }); + return result; +} + +function merge(defaults, route, options) { + if (typeof route === "string") { + let [method, url] = route.split(" "); + options = Object.assign(url ? { + method, + url + } : { + url: method + }, options); + } else { + options = Object.assign({}, route); + } // lowercase header names before merging with defaults to avoid duplicates + + + options.headers = lowercaseKeys(options.headers); + const mergedOptions = mergeDeep(defaults || {}, options); // mediaType.previews arrays are merged, instead of overwritten + + if (defaults && defaults.mediaType.previews.length) { + mergedOptions.mediaType.previews = defaults.mediaType.previews.filter(preview => !mergedOptions.mediaType.previews.includes(preview)).concat(mergedOptions.mediaType.previews); + } + + mergedOptions.mediaType.previews = mergedOptions.mediaType.previews.map(preview => preview.replace(/-preview/, "")); + return mergedOptions; +} + +function addQueryParameters(url, parameters) { + const separator = /\?/.test(url) ? "&" : "?"; + const names = Object.keys(parameters); + + if (names.length === 0) { + return url; + } + + return url + separator + names.map(name => { + if (name === "q") { + return "q=" + parameters.q.split("+").map(encodeURIComponent).join("+"); + } + + return `${name}=${encodeURIComponent(parameters[name])}`; + }).join("&"); +} + +const urlVariableRegex = /\{[^}]+\}/g; + +function removeNonChars(variableName) { + return variableName.replace(/^\W+|\W+$/g, "").split(/,/); +} + +function extractUrlVariableNames(url) { + const matches = url.match(urlVariableRegex); + + if (!matches) { + return []; + } + + return matches.map(removeNonChars).reduce((a, b) => a.concat(b), []); +} + +function omit(object, keysToOmit) { + return Object.keys(object).filter(option => !keysToOmit.includes(option)).reduce((obj, key) => { + obj[key] = object[key]; + return obj; + }, {}); +} + +// Based on https://github.com/bramstein/url-template, licensed under BSD +// TODO: create separate package. +// +// Copyright (c) 2012-2014, Bram Stein +// All rights reserved. +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions +// are met: +// 1. Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// 2. Redistributions in binary form must reproduce the above copyright +// notice, this list of conditions and the following disclaimer in the +// documentation and/or other materials provided with the distribution. +// 3. The name of the author may not be used to endorse or promote products +// derived from this software without specific prior written permission. +// THIS SOFTWARE IS PROVIDED BY THE AUTHOR "AS IS" AND ANY EXPRESS OR IMPLIED +// WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF +// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO +// EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, +// INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, +// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY +// OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING +// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, +// EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +/* istanbul ignore file */ +function encodeReserved(str) { + return str.split(/(%[0-9A-Fa-f]{2})/g).map(function (part) { + if (!/%[0-9A-Fa-f]/.test(part)) { + part = encodeURI(part).replace(/%5B/g, "[").replace(/%5D/g, "]"); + } + + return part; + }).join(""); +} + +function encodeUnreserved(str) { + return encodeURIComponent(str).replace(/[!'()*]/g, function (c) { + return "%" + c.charCodeAt(0).toString(16).toUpperCase(); + }); +} + +function encodeValue(operator, value, key) { + value = operator === "+" || operator === "#" ? encodeReserved(value) : encodeUnreserved(value); + + if (key) { + return encodeUnreserved(key) + "=" + value; + } else { + return value; + } +} + +function isDefined(value) { + return value !== undefined && value !== null; +} + +function isKeyOperator(operator) { + return operator === ";" || operator === "&" || operator === "?"; +} + +function getValues(context, operator, key, modifier) { + var value = context[key], + result = []; + + if (isDefined(value) && value !== "") { + if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") { + value = value.toString(); + + if (modifier && modifier !== "*") { + value = value.substring(0, parseInt(modifier, 10)); + } + + result.push(encodeValue(operator, value, isKeyOperator(operator) ? key : "")); + } else { + if (modifier === "*") { + if (Array.isArray(value)) { + value.filter(isDefined).forEach(function (value) { + result.push(encodeValue(operator, value, isKeyOperator(operator) ? key : "")); + }); + } else { + Object.keys(value).forEach(function (k) { + if (isDefined(value[k])) { + result.push(encodeValue(operator, value[k], k)); + } + }); + } + } else { + const tmp = []; + + if (Array.isArray(value)) { + value.filter(isDefined).forEach(function (value) { + tmp.push(encodeValue(operator, value)); + }); + } else { + Object.keys(value).forEach(function (k) { + if (isDefined(value[k])) { + tmp.push(encodeUnreserved(k)); + tmp.push(encodeValue(operator, value[k].toString())); + } + }); + } + + if (isKeyOperator(operator)) { + result.push(encodeUnreserved(key) + "=" + tmp.join(",")); + } else if (tmp.length !== 0) { + result.push(tmp.join(",")); + } + } + } + } else { + if (operator === ";") { + if (isDefined(value)) { + result.push(encodeUnreserved(key)); + } + } else if (value === "" && (operator === "&" || operator === "?")) { + result.push(encodeUnreserved(key) + "="); + } else if (value === "") { + result.push(""); + } + } + + return result; +} + +function parseUrl(template) { + return { + expand: expand.bind(null, template) + }; +} + +function expand(template, context) { + var operators = ["+", "#", ".", "/", ";", "?", "&"]; + return template.replace(/\{([^\{\}]+)\}|([^\{\}]+)/g, function (_, expression, literal) { + if (expression) { + let operator = ""; + const values = []; + + if (operators.indexOf(expression.charAt(0)) !== -1) { + operator = expression.charAt(0); + expression = expression.substr(1); + } + + expression.split(/,/g).forEach(function (variable) { + var tmp = /([^:\*]*)(?::(\d+)|(\*))?/.exec(variable); + values.push(getValues(context, operator, tmp[1], tmp[2] || tmp[3])); + }); + + if (operator && operator !== "+") { + var separator = ","; + + if (operator === "?") { + separator = "&"; + } else if (operator !== "#") { + separator = operator; + } + + return (values.length !== 0 ? operator : "") + values.join(separator); + } else { + return values.join(","); + } + } else { + return encodeReserved(literal); + } + }); +} + +function parse(options) { + // https://fetch.spec.whatwg.org/#methods + let method = options.method.toUpperCase(); // replace :varname with {varname} to make it RFC 6570 compatible + + let url = (options.url || "/").replace(/:([a-z]\w+)/g, "{+$1}"); + let headers = Object.assign({}, options.headers); + let body; + let parameters = omit(options, ["method", "baseUrl", "url", "headers", "request", "mediaType"]); // extract variable names from URL to calculate remaining variables later + + const urlVariableNames = extractUrlVariableNames(url); + url = parseUrl(url).expand(parameters); + + if (!/^http/.test(url)) { + url = options.baseUrl + url; + } + + const omittedParameters = Object.keys(options).filter(option => urlVariableNames.includes(option)).concat("baseUrl"); + const remainingParameters = omit(parameters, omittedParameters); + const isBinaryRequset = /application\/octet-stream/i.test(headers.accept); + + if (!isBinaryRequset) { + if (options.mediaType.format) { + // e.g. application/vnd.github.v3+json => application/vnd.github.v3.raw + headers.accept = headers.accept.split(/,/).map(preview => preview.replace(/application\/vnd(\.\w+)(\.v3)?(\.\w+)?(\+json)?$/, `application/vnd$1$2.${options.mediaType.format}`)).join(","); + } + + if (options.mediaType.previews.length) { + const previewsFromAcceptHeader = headers.accept.match(/[\w-]+(?=-preview)/g) || []; + headers.accept = previewsFromAcceptHeader.concat(options.mediaType.previews).map(preview => { + const format = options.mediaType.format ? `.${options.mediaType.format}` : "+json"; + return `application/vnd.github.${preview}-preview${format}`; + }).join(","); + } + } // for GET/HEAD requests, set URL query parameters from remaining parameters + // for PATCH/POST/PUT/DELETE requests, set request body from remaining parameters + + + if (["GET", "HEAD"].includes(method)) { + url = addQueryParameters(url, remainingParameters); + } else { + if ("data" in remainingParameters) { + body = remainingParameters.data; + } else { + if (Object.keys(remainingParameters).length) { + body = remainingParameters; + } else { + headers["content-length"] = 0; + } + } + } // default content-type for JSON if body is set + + + if (!headers["content-type"] && typeof body !== "undefined") { + headers["content-type"] = "application/json; charset=utf-8"; + } // GitHub expects 'content-length: 0' header for PUT/PATCH requests without body. + // fetch does not allow to set `content-length` header, but we can set body to an empty string + + + if (["PATCH", "PUT"].includes(method) && typeof body === "undefined") { + body = ""; + } // Only return body/request keys if present + + + return Object.assign({ + method, + url, + headers + }, typeof body !== "undefined" ? { + body + } : null, options.request ? { + request: options.request + } : null); +} + +function endpointWithDefaults(defaults, route, options) { + return parse(merge(defaults, route, options)); +} + +function withDefaults(oldDefaults, newDefaults) { + const DEFAULTS = merge(oldDefaults, newDefaults); + const endpoint = endpointWithDefaults.bind(null, DEFAULTS); + return Object.assign(endpoint, { + DEFAULTS, + defaults: withDefaults.bind(null, DEFAULTS), + merge: merge.bind(null, DEFAULTS), + parse + }); +} + +const VERSION = "6.0.0"; + +const userAgent = `octokit-endpoint.js/${VERSION} ${universalUserAgent.getUserAgent()}`; // DEFAULTS has all properties set that EndpointOptions has, except url. +// So we use RequestParameters and add method as additional required property. + +const DEFAULTS = { + method: "GET", + baseUrl: "https://api.github.com", + headers: { + accept: "application/vnd.github.v3+json", + "user-agent": userAgent + }, + mediaType: { + format: "", + previews: [] + } +}; + +const endpoint = withDefaults(null, DEFAULTS); + +exports.endpoint = endpoint; +//# sourceMappingURL=index.js.map + + +/***/ }), + +/***/ 386: +/***/ (function(module, __unusedexports, __webpack_require__) { + +"use strict"; + + +var Type = __webpack_require__(945); + +function resolveJavascriptUndefined() { + return true; +} + +function constructJavascriptUndefined() { + /*eslint-disable no-undefined*/ + return undefined; +} + +function representJavascriptUndefined() { + return ''; +} + +function isUndefined(object) { + return typeof object === 'undefined'; +} + +module.exports = new Type('tag:yaml.org,2002:js/undefined', { + kind: 'scalar', + resolve: resolveJavascriptUndefined, + construct: constructJavascriptUndefined, + predicate: isUndefined, + represent: representJavascriptUndefined +}); + + +/***/ }), + +/***/ 389: +/***/ (function(module, __unusedexports, __webpack_require__) { + +"use strict"; + + +const fs = __webpack_require__(747); +const shebangCommand = __webpack_require__(866); + +function readShebang(command) { + // Read the first 150 bytes from the file + const size = 150; + let buffer; + + if (Buffer.alloc) { + // Node.js v4.5+ / v5.10+ + buffer = Buffer.alloc(size); + } else { + // Old Node.js API + buffer = new Buffer(size); + buffer.fill(0); // zero-fill + } + + let fd; + + try { + fd = fs.openSync(command, 'r'); + fs.readSync(fd, buffer, 0, size, 0); + fs.closeSync(fd); + } catch (e) { /* Empty */ } + + // Attempt to extract shebang (null is returned if not a shebang) + return shebangCommand(buffer.toString()); +} + +module.exports = readShebang; + + +/***/ }), + +/***/ 402: +/***/ (function(module, __unusedexports, __webpack_require__) { + +module.exports = Octokit; + +const { request } = __webpack_require__(753); +const Hook = __webpack_require__(523); + +const parseClientOptions = __webpack_require__(294); + +function Octokit(plugins, options) { + options = options || {}; + const hook = new Hook.Collection(); + const log = Object.assign( + { + debug: () => {}, + info: () => {}, + warn: console.warn, + error: console.error + }, + options && options.log + ); + const api = { + hook, + log, + request: request.defaults(parseClientOptions(options, log, hook)) + }; + + plugins.forEach(pluginFunction => pluginFunction(api, options)); + + return api; +} + + +/***/ }), + +/***/ 404: +/***/ (function(__unusedmodule, exports, __webpack_require__) { + +"use strict"; + +var __importDefault = (this && this.__importDefault) || function (mod) { + return (mod && mod.__esModule) ? mod : { "default": mod }; +}; +Object.defineProperty(exports, "__esModule", { value: true }); +const dayjs_1 = __importDefault(__webpack_require__(629)); +const utc_1 = __importDefault(__webpack_require__(130)); +const customParseFormat_1 = __importDefault(__webpack_require__(499)); +function parse(input = '') { + dayjs_1.default.extend(utc_1.default); + dayjs_1.default.extend(customParseFormat_1.default); + let value; + let match; + let currentDate = false; + input = input.toString().replace(/^\s+/, ''); + if (match = input.match(/^(\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2})Z/)) { + value = dayjs_1.default(match[0]); + input = input.substring(match[0].length); + } + else if (match = input.match(/^(\d{4}-\d{2}-\d{2})/)) { + value = dayjs_1.default(`${match[0]} -0000`, 'YYYY-MM-DD Z'); + input = input.substring(match[0].length); + } + else if (match = input.match(/^(\d{2}):(\d{2}):(\d{2})/)) { + value = dayjs_1.default(); + value = value.utc().hour(+match[1]); + value = value.utc().minute(+match[2]); + value = value.utc().second(+match[3]); + input = input.substring(match[0].length); + } + else { + value = dayjs_1.default(); + currentDate = true; + } + while (input.length > 0) { + let operator; + input = input.replace(/^\s+/, ''); + if (match = input.match(/^([+-])\s*/)) { + operator = match[1]; + input = input.substring(match[0].length); + } + else if (currentDate != null) { + // if no date was specified, users don't need a starting operator + operator = '+'; + currentDate = false; + } + else { + throw new Error(`operator expected, got '${input}'`); + } + let operation = (operator == '-') ? + (d, v, u) => d.utc().subtract(v, u) : + (d, v, u) => d.utc().add(v, u); + if (match = input.match(/^([\d]+)\s*(year|month|day|hour|minute|second)(s?)\s*/)) { + input = input.substring(match[0].length); + value = operation(value, +match[1], match[2]); + } + else if (match = input.match(/^(\d{2}):(\d{2}):(\d{2})\s*/)) { + input = input.substring(match[0].length); + value = operation(value, +match[1], 'hours'); + value = operation(value, +match[2], 'minutes'); + value = operation(value, +match[3], 'seconds'); + } + else { + throw new Error(`date adjustment expected, got '${input}'`); + } + } + return value.utc(); +} +function date(input = undefined) { + return parse(input).format('YYYY-MM-DD'); +} +exports.date = date; +function time(input = undefined) { + return parse(input).format('HH:mm:ss'); +} +exports.time = time; +function datetime(input = undefined) { + return parse(input).format(); +} +exports.datetime = datetime; + + +/***/ }), + +/***/ 413: +/***/ (function(module) { + +module.exports = require("stream"); + +/***/ }), + +/***/ 414: +/***/ (function(module, __unusedexports, __webpack_require__) { + +"use strict"; + + + +var yaml = __webpack_require__(819); + + +module.exports = yaml; + + +/***/ }), + +/***/ 417: +/***/ (function(module, __unusedexports, __webpack_require__) { + +"use strict"; + + +var common = __webpack_require__(740); +var Type = __webpack_require__(945); + +var YAML_FLOAT_PATTERN = new RegExp( + // 2.5e4, 2.5 and integers + '^(?:[-+]?(?:0|[1-9][0-9_]*)(?:\\.[0-9_]*)?(?:[eE][-+]?[0-9]+)?' + + // .2e4, .2 + // special case, seems not from spec + '|\\.[0-9_]+(?:[eE][-+]?[0-9]+)?' + + // 20:59 + '|[-+]?[0-9][0-9_]*(?::[0-5]?[0-9])+\\.[0-9_]*' + + // .inf + '|[-+]?\\.(?:inf|Inf|INF)' + + // .nan + '|\\.(?:nan|NaN|NAN))$'); + +function resolveYamlFloat(data) { + if (data === null) return false; + + if (!YAML_FLOAT_PATTERN.test(data) || + // Quick hack to not allow integers end with `_` + // Probably should update regexp & check speed + data[data.length - 1] === '_') { + return false; + } + + return true; +} + +function constructYamlFloat(data) { + var value, sign, base, digits; + + value = data.replace(/_/g, '').toLowerCase(); + sign = value[0] === '-' ? -1 : 1; + digits = []; + + if ('+-'.indexOf(value[0]) >= 0) { + value = value.slice(1); + } + + if (value === '.inf') { + return (sign === 1) ? Number.POSITIVE_INFINITY : Number.NEGATIVE_INFINITY; + + } else if (value === '.nan') { + return NaN; + + } else if (value.indexOf(':') >= 0) { + value.split(':').forEach(function (v) { + digits.unshift(parseFloat(v, 10)); + }); + + value = 0.0; + base = 1; + + digits.forEach(function (d) { + value += d * base; + base *= 60; + }); + + return sign * value; + + } + return sign * parseFloat(value, 10); +} + + +var SCIENTIFIC_WITHOUT_DOT = /^[-+]?[0-9]+e/; + +function representYamlFloat(object, style) { + var res; + + if (isNaN(object)) { + switch (style) { + case 'lowercase': return '.nan'; + case 'uppercase': return '.NAN'; + case 'camelcase': return '.NaN'; + } + } else if (Number.POSITIVE_INFINITY === object) { + switch (style) { + case 'lowercase': return '.inf'; + case 'uppercase': return '.INF'; + case 'camelcase': return '.Inf'; + } + } else if (Number.NEGATIVE_INFINITY === object) { + switch (style) { + case 'lowercase': return '-.inf'; + case 'uppercase': return '-.INF'; + case 'camelcase': return '-.Inf'; + } + } else if (common.isNegativeZero(object)) { + return '-0.0'; + } + + res = object.toString(10); + + // JS stringifier can build scientific format without dots: 5e-100, + // while YAML requres dot: 5.e-100. Fix it with simple hack + + return SCIENTIFIC_WITHOUT_DOT.test(res) ? res.replace('e', '.e') : res; +} + +function isFloat(object) { + return (Object.prototype.toString.call(object) === '[object Number]') && + (object % 1 !== 0 || common.isNegativeZero(object)); +} + +module.exports = new Type('tag:yaml.org,2002:float', { + kind: 'scalar', + resolve: resolveYamlFloat, + construct: constructYamlFloat, + predicate: isFloat, + represent: representYamlFloat, + defaultStyle: 'lowercase' +}); + + +/***/ }), + +/***/ 427: +/***/ (function(module, __unusedexports, __webpack_require__) { + +"use strict"; + +// Older verions of Node.js might not have `util.getSystemErrorName()`. +// In that case, fall back to a deprecated internal. +const util = __webpack_require__(669); + +let uv; + +if (typeof util.getSystemErrorName === 'function') { + module.exports = util.getSystemErrorName; +} else { + try { + uv = process.binding('uv'); + + if (typeof uv.errname !== 'function') { + throw new TypeError('uv.errname is not a function'); + } + } catch (err) { + console.error('execa/lib/errname: unable to establish process.binding(\'uv\')', err); + uv = null; + } + + module.exports = code => errname(uv, code); +} + +// Used for testing the fallback behavior +module.exports.__test__ = errname; + +function errname(uv, code) { + if (uv) { + return uv.errname(code); + } + + if (!(code < 0)) { + throw new Error('err >= 0'); + } + + return `Unknown system error ${code}`; +} + + + +/***/ }), + +/***/ 430: +/***/ (function(module, __unusedexports, __webpack_require__) { + +module.exports = octokitValidate; + +const validate = __webpack_require__(348); + +function octokitValidate(octokit) { + octokit.hook.before("request", validate.bind(null, octokit)); +} + + +/***/ }), + +/***/ 431: +/***/ (function(__unusedmodule, exports, __webpack_require__) { + +"use strict"; + +var __importStar = (this && this.__importStar) || function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k]; + result["default"] = mod; + return result; +}; +Object.defineProperty(exports, "__esModule", { value: true }); +const os = __importStar(__webpack_require__(87)); +/** + * Commands + * + * Command Format: + * ::name key=value,key=value::message + * + * Examples: + * ::warning::This is the message + * ::set-env name=MY_VAR::some value + */ +function issueCommand(command, properties, message) { + const cmd = new Command(command, properties, message); + process.stdout.write(cmd.toString() + os.EOL); +} +exports.issueCommand = issueCommand; +function issue(name, message = '') { + issueCommand(name, {}, message); +} +exports.issue = issue; +const CMD_STRING = '::'; +class Command { + constructor(command, properties, message) { + if (!command) { + command = 'missing.command'; + } + this.command = command; + this.properties = properties; + this.message = message; + } + toString() { + let cmdStr = CMD_STRING + this.command; + if (this.properties && Object.keys(this.properties).length > 0) { + cmdStr += ' '; + let first = true; + for (const key in this.properties) { + if (this.properties.hasOwnProperty(key)) { + const val = this.properties[key]; + if (val) { + if (first) { + first = false; + } + else { + cmdStr += ','; + } + cmdStr += `${key}=${escapeProperty(val)}`; + } + } + } + } + cmdStr += `${CMD_STRING}${escapeData(this.message)}`; + return cmdStr; + } +} +function escapeData(s) { + return (s || '') + .replace(/%/g, '%25') + .replace(/\r/g, '%0D') + .replace(/\n/g, '%0A'); +} +function escapeProperty(s) { + return (s || '') + .replace(/%/g, '%25') + .replace(/\r/g, '%0D') + .replace(/\n/g, '%0A') + .replace(/:/g, '%3A') + .replace(/,/g, '%2C'); +} +//# sourceMappingURL=command.js.map + +/***/ }), + +/***/ 453: +/***/ (function(module, __unusedexports, __webpack_require__) { + +var once = __webpack_require__(969) +var eos = __webpack_require__(9) +var fs = __webpack_require__(747) // we only need fs to get the ReadStream and WriteStream prototypes + +var noop = function () {} +var ancient = /^v?\.0/.test(process.version) + +var isFn = function (fn) { + return typeof fn === 'function' +} + +var isFS = function (stream) { + if (!ancient) return false // newer node version do not need to care about fs is a special way + if (!fs) return false // browser + return (stream instanceof (fs.ReadStream || noop) || stream instanceof (fs.WriteStream || noop)) && isFn(stream.close) +} + +var isRequest = function (stream) { + return stream.setHeader && isFn(stream.abort) +} + +var destroyer = function (stream, reading, writing, callback) { + callback = once(callback) + + var closed = false + stream.on('close', function () { + closed = true + }) + + eos(stream, {readable: reading, writable: writing}, function (err) { + if (err) return callback(err) + closed = true + callback() + }) + + var destroyed = false + return function (err) { + if (closed) return + if (destroyed) return + destroyed = true + + if (isFS(stream)) return stream.close(noop) // use close for fs streams to avoid fd leaks + if (isRequest(stream)) return stream.abort() // request.destroy just do .end - .abort is what we want + + if (isFn(stream.destroy)) return stream.destroy() + + callback(err || new Error('stream was destroyed')) + } +} + +var call = function (fn) { + fn() +} + +var pipe = function (from, to) { + return from.pipe(to) +} + +var pump = function () { + var streams = Array.prototype.slice.call(arguments) + var callback = isFn(streams[streams.length - 1] || noop) && streams.pop() || noop + + if (Array.isArray(streams[0])) streams = streams[0] + if (streams.length < 2) throw new Error('pump requires two streams per minimum') + + var error + var destroys = streams.map(function (stream, i) { + var reading = i < streams.length - 1 + var writing = i > 0 + return destroyer(stream, reading, writing, function (err) { + if (!error) error = err + if (err) destroys.forEach(call) + if (reading) return + destroys.forEach(call) + callback(error) + }) + }) + + return streams.reduce(pipe) +} + +module.exports = pump + + +/***/ }), + +/***/ 454: +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + + +Object.defineProperty(exports, '__esModule', { value: true }); + +function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; } + +var Stream = _interopDefault(__webpack_require__(413)); +var http = _interopDefault(__webpack_require__(605)); +var Url = _interopDefault(__webpack_require__(835)); +var https = _interopDefault(__webpack_require__(34)); +var zlib = _interopDefault(__webpack_require__(761)); + +// Based on https://github.com/tmpvar/jsdom/blob/aa85b2abf07766ff7bf5c1f6daafb3726f2f2db5/lib/jsdom/living/blob.js + +// fix for "Readable" isn't a named export issue +const Readable = Stream.Readable; + +const BUFFER = Symbol('buffer'); +const TYPE = Symbol('type'); + +class Blob { + constructor() { + this[TYPE] = ''; + + const blobParts = arguments[0]; + const options = arguments[1]; + + const buffers = []; + let size = 0; + + if (blobParts) { + const a = blobParts; + const length = Number(a.length); + for (let i = 0; i < length; i++) { + const element = a[i]; + let buffer; + if (element instanceof Buffer) { + buffer = element; + } else if (ArrayBuffer.isView(element)) { + buffer = Buffer.from(element.buffer, element.byteOffset, element.byteLength); + } else if (element instanceof ArrayBuffer) { + buffer = Buffer.from(element); + } else if (element instanceof Blob) { + buffer = element[BUFFER]; + } else { + buffer = Buffer.from(typeof element === 'string' ? element : String(element)); + } + size += buffer.length; + buffers.push(buffer); + } + } + + this[BUFFER] = Buffer.concat(buffers); + + let type = options && options.type !== undefined && String(options.type).toLowerCase(); + if (type && !/[^\u0020-\u007E]/.test(type)) { + this[TYPE] = type; + } + } + get size() { + return this[BUFFER].length; + } + get type() { + return this[TYPE]; + } + text() { + return Promise.resolve(this[BUFFER].toString()); + } + arrayBuffer() { + const buf = this[BUFFER]; + const ab = buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.byteLength); + return Promise.resolve(ab); + } + stream() { + const readable = new Readable(); + readable._read = function () {}; + readable.push(this[BUFFER]); + readable.push(null); + return readable; + } + toString() { + return '[object Blob]'; + } + slice() { + const size = this.size; + + const start = arguments[0]; + const end = arguments[1]; + let relativeStart, relativeEnd; + if (start === undefined) { + relativeStart = 0; + } else if (start < 0) { + relativeStart = Math.max(size + start, 0); + } else { + relativeStart = Math.min(start, size); + } + if (end === undefined) { + relativeEnd = size; + } else if (end < 0) { + relativeEnd = Math.max(size + end, 0); + } else { + relativeEnd = Math.min(end, size); + } + const span = Math.max(relativeEnd - relativeStart, 0); + + const buffer = this[BUFFER]; + const slicedBuffer = buffer.slice(relativeStart, relativeStart + span); + const blob = new Blob([], { type: arguments[2] }); + blob[BUFFER] = slicedBuffer; + return blob; + } +} + +Object.defineProperties(Blob.prototype, { + size: { enumerable: true }, + type: { enumerable: true }, + slice: { enumerable: true } +}); + +Object.defineProperty(Blob.prototype, Symbol.toStringTag, { + value: 'Blob', + writable: false, + enumerable: false, + configurable: true +}); + +/** + * fetch-error.js + * + * FetchError interface for operational errors + */ + +/** + * Create FetchError instance + * + * @param String message Error message for human + * @param String type Error type for machine + * @param String systemError For Node.js system error + * @return FetchError + */ +function FetchError(message, type, systemError) { + Error.call(this, message); + + this.message = message; + this.type = type; + + // when err.type is `system`, err.code contains system error code + if (systemError) { + this.code = this.errno = systemError.code; + } + + // hide custom error implementation details from end-users + Error.captureStackTrace(this, this.constructor); +} + +FetchError.prototype = Object.create(Error.prototype); +FetchError.prototype.constructor = FetchError; +FetchError.prototype.name = 'FetchError'; + +let convert; +try { + convert = __webpack_require__(18).convert; +} catch (e) {} + +const INTERNALS = Symbol('Body internals'); + +// fix an issue where "PassThrough" isn't a named export for node <10 +const PassThrough = Stream.PassThrough; + +/** + * Body mixin + * + * Ref: https://fetch.spec.whatwg.org/#body + * + * @param Stream body Readable stream + * @param Object opts Response options + * @return Void + */ +function Body(body) { + var _this = this; + + var _ref = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}, + _ref$size = _ref.size; + + let size = _ref$size === undefined ? 0 : _ref$size; + var _ref$timeout = _ref.timeout; + let timeout = _ref$timeout === undefined ? 0 : _ref$timeout; + + if (body == null) { + // body is undefined or null + body = null; + } else if (isURLSearchParams(body)) { + // body is a URLSearchParams + body = Buffer.from(body.toString()); + } else if (isBlob(body)) ; else if (Buffer.isBuffer(body)) ; else if (Object.prototype.toString.call(body) === '[object ArrayBuffer]') { + // body is ArrayBuffer + body = Buffer.from(body); + } else if (ArrayBuffer.isView(body)) { + // body is ArrayBufferView + body = Buffer.from(body.buffer, body.byteOffset, body.byteLength); + } else if (body instanceof Stream) ; else { + // none of the above + // coerce to string then buffer + body = Buffer.from(String(body)); + } + this[INTERNALS] = { + body, + disturbed: false, + error: null + }; + this.size = size; + this.timeout = timeout; + + if (body instanceof Stream) { + body.on('error', function (err) { + const error = err.name === 'AbortError' ? err : new FetchError(`Invalid response body while trying to fetch ${_this.url}: ${err.message}`, 'system', err); + _this[INTERNALS].error = error; + }); + } +} + +Body.prototype = { + get body() { + return this[INTERNALS].body; + }, + + get bodyUsed() { + return this[INTERNALS].disturbed; + }, + + /** + * Decode response as ArrayBuffer + * + * @return Promise + */ + arrayBuffer() { + return consumeBody.call(this).then(function (buf) { + return buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.byteLength); + }); + }, + + /** + * Return raw response as Blob + * + * @return Promise + */ + blob() { + let ct = this.headers && this.headers.get('content-type') || ''; + return consumeBody.call(this).then(function (buf) { + return Object.assign( + // Prevent copying + new Blob([], { + type: ct.toLowerCase() + }), { + [BUFFER]: buf + }); + }); + }, + + /** + * Decode response as json + * + * @return Promise + */ + json() { + var _this2 = this; + + return consumeBody.call(this).then(function (buffer) { + try { + return JSON.parse(buffer.toString()); + } catch (err) { + return Body.Promise.reject(new FetchError(`invalid json response body at ${_this2.url} reason: ${err.message}`, 'invalid-json')); + } + }); + }, + + /** + * Decode response as text + * + * @return Promise + */ + text() { + return consumeBody.call(this).then(function (buffer) { + return buffer.toString(); + }); + }, + + /** + * Decode response as buffer (non-spec api) + * + * @return Promise + */ + buffer() { + return consumeBody.call(this); + }, + + /** + * Decode response as text, while automatically detecting the encoding and + * trying to decode to UTF-8 (non-spec api) + * + * @return Promise + */ + textConverted() { + var _this3 = this; + + return consumeBody.call(this).then(function (buffer) { + return convertBody(buffer, _this3.headers); + }); + } +}; + +// In browsers, all properties are enumerable. +Object.defineProperties(Body.prototype, { + body: { enumerable: true }, + bodyUsed: { enumerable: true }, + arrayBuffer: { enumerable: true }, + blob: { enumerable: true }, + json: { enumerable: true }, + text: { enumerable: true } +}); + +Body.mixIn = function (proto) { + for (const name of Object.getOwnPropertyNames(Body.prototype)) { + // istanbul ignore else: future proof + if (!(name in proto)) { + const desc = Object.getOwnPropertyDescriptor(Body.prototype, name); + Object.defineProperty(proto, name, desc); + } + } +}; + +/** + * Consume and convert an entire Body to a Buffer. + * + * Ref: https://fetch.spec.whatwg.org/#concept-body-consume-body + * + * @return Promise + */ +function consumeBody() { + var _this4 = this; + + if (this[INTERNALS].disturbed) { + return Body.Promise.reject(new TypeError(`body used already for: ${this.url}`)); + } + + this[INTERNALS].disturbed = true; + + if (this[INTERNALS].error) { + return Body.Promise.reject(this[INTERNALS].error); + } + + let body = this.body; + + // body is null + if (body === null) { + return Body.Promise.resolve(Buffer.alloc(0)); + } + + // body is blob + if (isBlob(body)) { + body = body.stream(); + } + + // body is buffer + if (Buffer.isBuffer(body)) { + return Body.Promise.resolve(body); + } + + // istanbul ignore if: should never happen + if (!(body instanceof Stream)) { + return Body.Promise.resolve(Buffer.alloc(0)); + } + + // body is stream + // get ready to actually consume the body + let accum = []; + let accumBytes = 0; + let abort = false; + + return new Body.Promise(function (resolve, reject) { + let resTimeout; + + // allow timeout on slow response body + if (_this4.timeout) { + resTimeout = setTimeout(function () { + abort = true; + reject(new FetchError(`Response timeout while trying to fetch ${_this4.url} (over ${_this4.timeout}ms)`, 'body-timeout')); + }, _this4.timeout); + } + + // handle stream errors + body.on('error', function (err) { + if (err.name === 'AbortError') { + // if the request was aborted, reject with this Error + abort = true; + reject(err); + } else { + // other errors, such as incorrect content-encoding + reject(new FetchError(`Invalid response body while trying to fetch ${_this4.url}: ${err.message}`, 'system', err)); + } + }); + + body.on('data', function (chunk) { + if (abort || chunk === null) { + return; + } + + if (_this4.size && accumBytes + chunk.length > _this4.size) { + abort = true; + reject(new FetchError(`content size at ${_this4.url} over limit: ${_this4.size}`, 'max-size')); + return; + } + + accumBytes += chunk.length; + accum.push(chunk); + }); + + body.on('end', function () { + if (abort) { + return; + } + + clearTimeout(resTimeout); + + try { + resolve(Buffer.concat(accum, accumBytes)); + } catch (err) { + // handle streams that have accumulated too much data (issue #414) + reject(new FetchError(`Could not create Buffer from response body for ${_this4.url}: ${err.message}`, 'system', err)); + } + }); + }); +} + +/** + * Detect buffer encoding and convert to target encoding + * ref: http://www.w3.org/TR/2011/WD-html5-20110113/parsing.html#determining-the-character-encoding + * + * @param Buffer buffer Incoming buffer + * @param String encoding Target encoding + * @return String + */ +function convertBody(buffer, headers) { + if (typeof convert !== 'function') { + throw new Error('The package `encoding` must be installed to use the textConverted() function'); + } + + const ct = headers.get('content-type'); + let charset = 'utf-8'; + let res, str; + + // header + if (ct) { + res = /charset=([^;]*)/i.exec(ct); + } + + // no charset in content type, peek at response body for at most 1024 bytes + str = buffer.slice(0, 1024).toString(); + + // html5 + if (!res && str) { + res = / 0 && arguments[0] !== undefined ? arguments[0] : undefined; + + this[MAP] = Object.create(null); + + if (init instanceof Headers) { + const rawHeaders = init.raw(); + const headerNames = Object.keys(rawHeaders); + + for (const headerName of headerNames) { + for (const value of rawHeaders[headerName]) { + this.append(headerName, value); + } + } + + return; + } + + // We don't worry about converting prop to ByteString here as append() + // will handle it. + if (init == null) ; else if (typeof init === 'object') { + const method = init[Symbol.iterator]; + if (method != null) { + if (typeof method !== 'function') { + throw new TypeError('Header pairs must be iterable'); + } + + // sequence> + // Note: per spec we have to first exhaust the lists then process them + const pairs = []; + for (const pair of init) { + if (typeof pair !== 'object' || typeof pair[Symbol.iterator] !== 'function') { + throw new TypeError('Each header pair must be iterable'); + } + pairs.push(Array.from(pair)); + } + + for (const pair of pairs) { + if (pair.length !== 2) { + throw new TypeError('Each header pair must be a name/value tuple'); + } + this.append(pair[0], pair[1]); + } + } else { + // record + for (const key of Object.keys(init)) { + const value = init[key]; + this.append(key, value); + } + } + } else { + throw new TypeError('Provided initializer must be an object'); + } + } + + /** + * Return combined header value given name + * + * @param String name Header name + * @return Mixed + */ + get(name) { + name = `${name}`; + validateName(name); + const key = find(this[MAP], name); + if (key === undefined) { + return null; + } + + return this[MAP][key].join(', '); + } + + /** + * Iterate over all headers + * + * @param Function callback Executed for each item with parameters (value, name, thisArg) + * @param Boolean thisArg `this` context for callback function + * @return Void + */ + forEach(callback) { + let thisArg = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : undefined; + + let pairs = getHeaders(this); + let i = 0; + while (i < pairs.length) { + var _pairs$i = pairs[i]; + const name = _pairs$i[0], + value = _pairs$i[1]; + + callback.call(thisArg, value, name, this); + pairs = getHeaders(this); + i++; + } + } + + /** + * Overwrite header values given name + * + * @param String name Header name + * @param String value Header value + * @return Void + */ + set(name, value) { + name = `${name}`; + value = `${value}`; + validateName(name); + validateValue(value); + const key = find(this[MAP], name); + this[MAP][key !== undefined ? key : name] = [value]; + } + + /** + * Append a value onto existing header + * + * @param String name Header name + * @param String value Header value + * @return Void + */ + append(name, value) { + name = `${name}`; + value = `${value}`; + validateName(name); + validateValue(value); + const key = find(this[MAP], name); + if (key !== undefined) { + this[MAP][key].push(value); + } else { + this[MAP][name] = [value]; + } + } + + /** + * Check for header name existence + * + * @param String name Header name + * @return Boolean + */ + has(name) { + name = `${name}`; + validateName(name); + return find(this[MAP], name) !== undefined; + } + + /** + * Delete all header values given name + * + * @param String name Header name + * @return Void + */ + delete(name) { + name = `${name}`; + validateName(name); + const key = find(this[MAP], name); + if (key !== undefined) { + delete this[MAP][key]; + } + } + + /** + * Return raw headers (non-spec api) + * + * @return Object + */ + raw() { + return this[MAP]; + } + + /** + * Get an iterator on keys. + * + * @return Iterator + */ + keys() { + return createHeadersIterator(this, 'key'); + } + + /** + * Get an iterator on values. + * + * @return Iterator + */ + values() { + return createHeadersIterator(this, 'value'); + } + + /** + * Get an iterator on entries. + * + * This is the default iterator of the Headers object. + * + * @return Iterator + */ + [Symbol.iterator]() { + return createHeadersIterator(this, 'key+value'); + } +} +Headers.prototype.entries = Headers.prototype[Symbol.iterator]; + +Object.defineProperty(Headers.prototype, Symbol.toStringTag, { + value: 'Headers', + writable: false, + enumerable: false, + configurable: true +}); + +Object.defineProperties(Headers.prototype, { + get: { enumerable: true }, + forEach: { enumerable: true }, + set: { enumerable: true }, + append: { enumerable: true }, + has: { enumerable: true }, + delete: { enumerable: true }, + keys: { enumerable: true }, + values: { enumerable: true }, + entries: { enumerable: true } +}); + +function getHeaders(headers) { + let kind = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'key+value'; + + const keys = Object.keys(headers[MAP]).sort(); + return keys.map(kind === 'key' ? function (k) { + return k.toLowerCase(); + } : kind === 'value' ? function (k) { + return headers[MAP][k].join(', '); + } : function (k) { + return [k.toLowerCase(), headers[MAP][k].join(', ')]; + }); +} + +const INTERNAL = Symbol('internal'); + +function createHeadersIterator(target, kind) { + const iterator = Object.create(HeadersIteratorPrototype); + iterator[INTERNAL] = { + target, + kind, + index: 0 + }; + return iterator; +} + +const HeadersIteratorPrototype = Object.setPrototypeOf({ + next() { + // istanbul ignore if + if (!this || Object.getPrototypeOf(this) !== HeadersIteratorPrototype) { + throw new TypeError('Value of `this` is not a HeadersIterator'); + } + + var _INTERNAL = this[INTERNAL]; + const target = _INTERNAL.target, + kind = _INTERNAL.kind, + index = _INTERNAL.index; + + const values = getHeaders(target, kind); + const len = values.length; + if (index >= len) { + return { + value: undefined, + done: true + }; + } + + this[INTERNAL].index = index + 1; + + return { + value: values[index], + done: false + }; + } +}, Object.getPrototypeOf(Object.getPrototypeOf([][Symbol.iterator]()))); + +Object.defineProperty(HeadersIteratorPrototype, Symbol.toStringTag, { + value: 'HeadersIterator', + writable: false, + enumerable: false, + configurable: true +}); + +/** + * Export the Headers object in a form that Node.js can consume. + * + * @param Headers headers + * @return Object + */ +function exportNodeCompatibleHeaders(headers) { + const obj = Object.assign({ __proto__: null }, headers[MAP]); + + // http.request() only supports string as Host header. This hack makes + // specifying custom Host header possible. + const hostHeaderKey = find(headers[MAP], 'Host'); + if (hostHeaderKey !== undefined) { + obj[hostHeaderKey] = obj[hostHeaderKey][0]; + } + + return obj; +} + +/** + * Create a Headers object from an object of headers, ignoring those that do + * not conform to HTTP grammar productions. + * + * @param Object obj Object of headers + * @return Headers + */ +function createHeadersLenient(obj) { + const headers = new Headers(); + for (const name of Object.keys(obj)) { + if (invalidTokenRegex.test(name)) { + continue; + } + if (Array.isArray(obj[name])) { + for (const val of obj[name]) { + if (invalidHeaderCharRegex.test(val)) { + continue; + } + if (headers[MAP][name] === undefined) { + headers[MAP][name] = [val]; + } else { + headers[MAP][name].push(val); + } + } + } else if (!invalidHeaderCharRegex.test(obj[name])) { + headers[MAP][name] = [obj[name]]; + } + } + return headers; +} + +const INTERNALS$1 = Symbol('Response internals'); + +// fix an issue where "STATUS_CODES" aren't a named export for node <10 +const STATUS_CODES = http.STATUS_CODES; + +/** + * Response class + * + * @param Stream body Readable stream + * @param Object opts Response options + * @return Void + */ +class Response { + constructor() { + let body = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null; + let opts = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; + + Body.call(this, body, opts); + + const status = opts.status || 200; + const headers = new Headers(opts.headers); + + if (body != null && !headers.has('Content-Type')) { + const contentType = extractContentType(body); + if (contentType) { + headers.append('Content-Type', contentType); + } + } + + this[INTERNALS$1] = { + url: opts.url, + status, + statusText: opts.statusText || STATUS_CODES[status], + headers, + counter: opts.counter + }; + } + + get url() { + return this[INTERNALS$1].url || ''; + } + + get status() { + return this[INTERNALS$1].status; + } + + /** + * Convenience property representing if the request ended normally + */ + get ok() { + return this[INTERNALS$1].status >= 200 && this[INTERNALS$1].status < 300; + } + + get redirected() { + return this[INTERNALS$1].counter > 0; + } + + get statusText() { + return this[INTERNALS$1].statusText; + } + + get headers() { + return this[INTERNALS$1].headers; + } + + /** + * Clone this response + * + * @return Response + */ + clone() { + return new Response(clone(this), { + url: this.url, + status: this.status, + statusText: this.statusText, + headers: this.headers, + ok: this.ok, + redirected: this.redirected + }); + } +} + +Body.mixIn(Response.prototype); + +Object.defineProperties(Response.prototype, { + url: { enumerable: true }, + status: { enumerable: true }, + ok: { enumerable: true }, + redirected: { enumerable: true }, + statusText: { enumerable: true }, + headers: { enumerable: true }, + clone: { enumerable: true } +}); + +Object.defineProperty(Response.prototype, Symbol.toStringTag, { + value: 'Response', + writable: false, + enumerable: false, + configurable: true +}); + +const INTERNALS$2 = Symbol('Request internals'); + +// fix an issue where "format", "parse" aren't a named export for node <10 +const parse_url = Url.parse; +const format_url = Url.format; + +const streamDestructionSupported = 'destroy' in Stream.Readable.prototype; + +/** + * Check if a value is an instance of Request. + * + * @param Mixed input + * @return Boolean + */ +function isRequest(input) { + return typeof input === 'object' && typeof input[INTERNALS$2] === 'object'; +} + +function isAbortSignal(signal) { + const proto = signal && typeof signal === 'object' && Object.getPrototypeOf(signal); + return !!(proto && proto.constructor.name === 'AbortSignal'); +} + +/** + * Request class + * + * @param Mixed input Url or Request instance + * @param Object init Custom options + * @return Void + */ +class Request { + constructor(input) { + let init = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; + + let parsedURL; + + // normalize input + if (!isRequest(input)) { + if (input && input.href) { + // in order to support Node.js' Url objects; though WHATWG's URL objects + // will fall into this branch also (since their `toString()` will return + // `href` property anyway) + parsedURL = parse_url(input.href); + } else { + // coerce input to a string before attempting to parse + parsedURL = parse_url(`${input}`); + } + input = {}; + } else { + parsedURL = parse_url(input.url); + } + + let method = init.method || input.method || 'GET'; + method = method.toUpperCase(); + + if ((init.body != null || isRequest(input) && input.body !== null) && (method === 'GET' || method === 'HEAD')) { + throw new TypeError('Request with GET/HEAD method cannot have body'); + } + + let inputBody = init.body != null ? init.body : isRequest(input) && input.body !== null ? clone(input) : null; + + Body.call(this, inputBody, { + timeout: init.timeout || input.timeout || 0, + size: init.size || input.size || 0 + }); + + const headers = new Headers(init.headers || input.headers || {}); + + if (inputBody != null && !headers.has('Content-Type')) { + const contentType = extractContentType(inputBody); + if (contentType) { + headers.append('Content-Type', contentType); + } + } + + let signal = isRequest(input) ? input.signal : null; + if ('signal' in init) signal = init.signal; + + if (signal != null && !isAbortSignal(signal)) { + throw new TypeError('Expected signal to be an instanceof AbortSignal'); + } + + this[INTERNALS$2] = { + method, + redirect: init.redirect || input.redirect || 'follow', + headers, + parsedURL, + signal + }; + + // node-fetch-only options + this.follow = init.follow !== undefined ? init.follow : input.follow !== undefined ? input.follow : 20; + this.compress = init.compress !== undefined ? init.compress : input.compress !== undefined ? input.compress : true; + this.counter = init.counter || input.counter || 0; + this.agent = init.agent || input.agent; + } + + get method() { + return this[INTERNALS$2].method; + } + + get url() { + return format_url(this[INTERNALS$2].parsedURL); + } + + get headers() { + return this[INTERNALS$2].headers; + } + + get redirect() { + return this[INTERNALS$2].redirect; + } + + get signal() { + return this[INTERNALS$2].signal; + } + + /** + * Clone this request + * + * @return Request + */ + clone() { + return new Request(this); + } +} + +Body.mixIn(Request.prototype); + +Object.defineProperty(Request.prototype, Symbol.toStringTag, { + value: 'Request', + writable: false, + enumerable: false, + configurable: true +}); + +Object.defineProperties(Request.prototype, { + method: { enumerable: true }, + url: { enumerable: true }, + headers: { enumerable: true }, + redirect: { enumerable: true }, + clone: { enumerable: true }, + signal: { enumerable: true } +}); + +/** + * Convert a Request to Node.js http request options. + * + * @param Request A Request instance + * @return Object The options object to be passed to http.request + */ +function getNodeRequestOptions(request) { + const parsedURL = request[INTERNALS$2].parsedURL; + const headers = new Headers(request[INTERNALS$2].headers); + + // fetch step 1.3 + if (!headers.has('Accept')) { + headers.set('Accept', '*/*'); + } + + // Basic fetch + if (!parsedURL.protocol || !parsedURL.hostname) { + throw new TypeError('Only absolute URLs are supported'); + } + + if (!/^https?:$/.test(parsedURL.protocol)) { + throw new TypeError('Only HTTP(S) protocols are supported'); + } + + if (request.signal && request.body instanceof Stream.Readable && !streamDestructionSupported) { + throw new Error('Cancellation of streamed requests with AbortSignal is not supported in node < 8'); + } + + // HTTP-network-or-cache fetch steps 2.4-2.7 + let contentLengthValue = null; + if (request.body == null && /^(POST|PUT)$/i.test(request.method)) { + contentLengthValue = '0'; + } + if (request.body != null) { + const totalBytes = getTotalBytes(request); + if (typeof totalBytes === 'number') { + contentLengthValue = String(totalBytes); + } + } + if (contentLengthValue) { + headers.set('Content-Length', contentLengthValue); + } + + // HTTP-network-or-cache fetch step 2.11 + if (!headers.has('User-Agent')) { + headers.set('User-Agent', 'node-fetch/1.0 (+https://github.com/bitinn/node-fetch)'); + } + + // HTTP-network-or-cache fetch step 2.15 + if (request.compress && !headers.has('Accept-Encoding')) { + headers.set('Accept-Encoding', 'gzip,deflate'); + } + + let agent = request.agent; + if (typeof agent === 'function') { + agent = agent(parsedURL); + } + + if (!headers.has('Connection') && !agent) { + headers.set('Connection', 'close'); + } + + // HTTP-network fetch step 4.2 + // chunked encoding is handled by Node.js + + return Object.assign({}, parsedURL, { + method: request.method, + headers: exportNodeCompatibleHeaders(headers), + agent + }); +} + +/** + * abort-error.js + * + * AbortError interface for cancelled requests + */ + +/** + * Create AbortError instance + * + * @param String message Error message for human + * @return AbortError + */ +function AbortError(message) { + Error.call(this, message); + + this.type = 'aborted'; + this.message = message; + + // hide custom error implementation details from end-users + Error.captureStackTrace(this, this.constructor); +} + +AbortError.prototype = Object.create(Error.prototype); +AbortError.prototype.constructor = AbortError; +AbortError.prototype.name = 'AbortError'; + +// fix an issue where "PassThrough", "resolve" aren't a named export for node <10 +const PassThrough$1 = Stream.PassThrough; +const resolve_url = Url.resolve; + +/** + * Fetch function + * + * @param Mixed url Absolute url or Request instance + * @param Object opts Fetch options + * @return Promise + */ +function fetch(url, opts) { + + // allow custom promise + if (!fetch.Promise) { + throw new Error('native promise missing, set fetch.Promise to your favorite alternative'); + } + + Body.Promise = fetch.Promise; + + // wrap http.request into fetch + return new fetch.Promise(function (resolve, reject) { + // build request object + const request = new Request(url, opts); + const options = getNodeRequestOptions(request); + + const send = (options.protocol === 'https:' ? https : http).request; + const signal = request.signal; + + let response = null; + + const abort = function abort() { + let error = new AbortError('The user aborted a request.'); + reject(error); + if (request.body && request.body instanceof Stream.Readable) { + request.body.destroy(error); + } + if (!response || !response.body) return; + response.body.emit('error', error); + }; + + if (signal && signal.aborted) { + abort(); + return; + } + + const abortAndFinalize = function abortAndFinalize() { + abort(); + finalize(); + }; + + // send request + const req = send(options); + let reqTimeout; + + if (signal) { + signal.addEventListener('abort', abortAndFinalize); + } + + function finalize() { + req.abort(); + if (signal) signal.removeEventListener('abort', abortAndFinalize); + clearTimeout(reqTimeout); + } + + if (request.timeout) { + req.once('socket', function (socket) { + reqTimeout = setTimeout(function () { + reject(new FetchError(`network timeout at: ${request.url}`, 'request-timeout')); + finalize(); + }, request.timeout); + }); + } + + req.on('error', function (err) { + reject(new FetchError(`request to ${request.url} failed, reason: ${err.message}`, 'system', err)); + finalize(); + }); + + req.on('response', function (res) { + clearTimeout(reqTimeout); + + const headers = createHeadersLenient(res.headers); + + // HTTP fetch step 5 + if (fetch.isRedirect(res.statusCode)) { + // HTTP fetch step 5.2 + const location = headers.get('Location'); + + // HTTP fetch step 5.3 + const locationURL = location === null ? null : resolve_url(request.url, location); + + // HTTP fetch step 5.5 + switch (request.redirect) { + case 'error': + reject(new FetchError(`redirect mode is set to error: ${request.url}`, 'no-redirect')); + finalize(); + return; + case 'manual': + // node-fetch-specific step: make manual redirect a bit easier to use by setting the Location header value to the resolved URL. + if (locationURL !== null) { + // handle corrupted header + try { + headers.set('Location', locationURL); + } catch (err) { + // istanbul ignore next: nodejs server prevent invalid response headers, we can't test this through normal request + reject(err); + } + } + break; + case 'follow': + // HTTP-redirect fetch step 2 + if (locationURL === null) { + break; + } + + // HTTP-redirect fetch step 5 + if (request.counter >= request.follow) { + reject(new FetchError(`maximum redirect reached at: ${request.url}`, 'max-redirect')); + finalize(); + return; + } + + // HTTP-redirect fetch step 6 (counter increment) + // Create a new Request object. + const requestOpts = { + headers: new Headers(request.headers), + follow: request.follow, + counter: request.counter + 1, + agent: request.agent, + compress: request.compress, + method: request.method, + body: request.body, + signal: request.signal, + timeout: request.timeout + }; + + // HTTP-redirect fetch step 9 + if (res.statusCode !== 303 && request.body && getTotalBytes(request) === null) { + reject(new FetchError('Cannot follow redirect with body being a readable stream', 'unsupported-redirect')); + finalize(); + return; + } + + // HTTP-redirect fetch step 11 + if (res.statusCode === 303 || (res.statusCode === 301 || res.statusCode === 302) && request.method === 'POST') { + requestOpts.method = 'GET'; + requestOpts.body = undefined; + requestOpts.headers.delete('content-length'); + } + + // HTTP-redirect fetch step 15 + resolve(fetch(new Request(locationURL, requestOpts))); + finalize(); + return; + } + } + + // prepare response + res.once('end', function () { + if (signal) signal.removeEventListener('abort', abortAndFinalize); + }); + let body = res.pipe(new PassThrough$1()); + + const response_options = { + url: request.url, + status: res.statusCode, + statusText: res.statusMessage, + headers: headers, + size: request.size, + timeout: request.timeout, + counter: request.counter + }; + + // HTTP-network fetch step 12.1.1.3 + const codings = headers.get('Content-Encoding'); + + // HTTP-network fetch step 12.1.1.4: handle content codings + + // in following scenarios we ignore compression support + // 1. compression support is disabled + // 2. HEAD request + // 3. no Content-Encoding header + // 4. no content response (204) + // 5. content not modified response (304) + if (!request.compress || request.method === 'HEAD' || codings === null || res.statusCode === 204 || res.statusCode === 304) { + response = new Response(body, response_options); + resolve(response); + return; + } + + // For Node v6+ + // Be less strict when decoding compressed responses, since sometimes + // servers send slightly invalid responses that are still accepted + // by common browsers. + // Always using Z_SYNC_FLUSH is what cURL does. + const zlibOptions = { + flush: zlib.Z_SYNC_FLUSH, + finishFlush: zlib.Z_SYNC_FLUSH + }; + + // for gzip + if (codings == 'gzip' || codings == 'x-gzip') { + body = body.pipe(zlib.createGunzip(zlibOptions)); + response = new Response(body, response_options); + resolve(response); + return; + } + + // for deflate + if (codings == 'deflate' || codings == 'x-deflate') { + // handle the infamous raw deflate response from old servers + // a hack for old IIS and Apache servers + const raw = res.pipe(new PassThrough$1()); + raw.once('data', function (chunk) { + // see http://stackoverflow.com/questions/37519828 + if ((chunk[0] & 0x0F) === 0x08) { + body = body.pipe(zlib.createInflate()); + } else { + body = body.pipe(zlib.createInflateRaw()); + } + response = new Response(body, response_options); + resolve(response); + }); + return; + } + + // for br + if (codings == 'br' && typeof zlib.createBrotliDecompress === 'function') { + body = body.pipe(zlib.createBrotliDecompress()); + response = new Response(body, response_options); + resolve(response); + return; + } + + // otherwise, use response as-is + response = new Response(body, response_options); + resolve(response); + }); + + writeToStream(req, request); + }); +} +/** + * Redirect code matching + * + * @param Number code Status code + * @return Boolean + */ +fetch.isRedirect = function (code) { + return code === 301 || code === 302 || code === 303 || code === 307 || code === 308; +}; + +// expose Promise +fetch.Promise = global.Promise; + +module.exports = exports = fetch; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.default = exports; +exports.Headers = Headers; +exports.Request = Request; +exports.Response = Response; +exports.FetchError = FetchError; + + +/***/ }), + +/***/ 457: +/***/ (function(module, __unusedexports, __webpack_require__) { + +"use strict"; + + +/*eslint-disable max-len,no-use-before-define*/ + +var common = __webpack_require__(740); +var YAMLException = __webpack_require__(556); +var Mark = __webpack_require__(93); +var DEFAULT_SAFE_SCHEMA = __webpack_require__(723); +var DEFAULT_FULL_SCHEMA = __webpack_require__(910); + + +var _hasOwnProperty = Object.prototype.hasOwnProperty; + + +var CONTEXT_FLOW_IN = 1; +var CONTEXT_FLOW_OUT = 2; +var CONTEXT_BLOCK_IN = 3; +var CONTEXT_BLOCK_OUT = 4; + + +var CHOMPING_CLIP = 1; +var CHOMPING_STRIP = 2; +var CHOMPING_KEEP = 3; + + +var PATTERN_NON_PRINTABLE = /[\x00-\x08\x0B\x0C\x0E-\x1F\x7F-\x84\x86-\x9F\uFFFE\uFFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF]/; +var PATTERN_NON_ASCII_LINE_BREAKS = /[\x85\u2028\u2029]/; +var PATTERN_FLOW_INDICATORS = /[,\[\]\{\}]/; +var PATTERN_TAG_HANDLE = /^(?:!|!!|![a-z\-]+!)$/i; +var PATTERN_TAG_URI = /^(?:!|[^,\[\]\{\}])(?:%[0-9a-f]{2}|[0-9a-z\-#;\/\?:@&=\+\$,_\.!~\*'\(\)\[\]])*$/i; + + +function _class(obj) { return Object.prototype.toString.call(obj); } + +function is_EOL(c) { + return (c === 0x0A/* LF */) || (c === 0x0D/* CR */); +} + +function is_WHITE_SPACE(c) { + return (c === 0x09/* Tab */) || (c === 0x20/* Space */); +} + +function is_WS_OR_EOL(c) { + return (c === 0x09/* Tab */) || + (c === 0x20/* Space */) || + (c === 0x0A/* LF */) || + (c === 0x0D/* CR */); +} + +function is_FLOW_INDICATOR(c) { + return c === 0x2C/* , */ || + c === 0x5B/* [ */ || + c === 0x5D/* ] */ || + c === 0x7B/* { */ || + c === 0x7D/* } */; +} + +function fromHexCode(c) { + var lc; + + if ((0x30/* 0 */ <= c) && (c <= 0x39/* 9 */)) { + return c - 0x30; + } + + /*eslint-disable no-bitwise*/ + lc = c | 0x20; + + if ((0x61/* a */ <= lc) && (lc <= 0x66/* f */)) { + return lc - 0x61 + 10; + } + + return -1; +} + +function escapedHexLen(c) { + if (c === 0x78/* x */) { return 2; } + if (c === 0x75/* u */) { return 4; } + if (c === 0x55/* U */) { return 8; } + return 0; +} + +function fromDecimalCode(c) { + if ((0x30/* 0 */ <= c) && (c <= 0x39/* 9 */)) { + return c - 0x30; + } + + return -1; +} + +function simpleEscapeSequence(c) { + /* eslint-disable indent */ + return (c === 0x30/* 0 */) ? '\x00' : + (c === 0x61/* a */) ? '\x07' : + (c === 0x62/* b */) ? '\x08' : + (c === 0x74/* t */) ? '\x09' : + (c === 0x09/* Tab */) ? '\x09' : + (c === 0x6E/* n */) ? '\x0A' : + (c === 0x76/* v */) ? '\x0B' : + (c === 0x66/* f */) ? '\x0C' : + (c === 0x72/* r */) ? '\x0D' : + (c === 0x65/* e */) ? '\x1B' : + (c === 0x20/* Space */) ? ' ' : + (c === 0x22/* " */) ? '\x22' : + (c === 0x2F/* / */) ? '/' : + (c === 0x5C/* \ */) ? '\x5C' : + (c === 0x4E/* N */) ? '\x85' : + (c === 0x5F/* _ */) ? '\xA0' : + (c === 0x4C/* L */) ? '\u2028' : + (c === 0x50/* P */) ? '\u2029' : ''; +} + +function charFromCodepoint(c) { + if (c <= 0xFFFF) { + return String.fromCharCode(c); + } + // Encode UTF-16 surrogate pair + // https://en.wikipedia.org/wiki/UTF-16#Code_points_U.2B010000_to_U.2B10FFFF + return String.fromCharCode( + ((c - 0x010000) >> 10) + 0xD800, + ((c - 0x010000) & 0x03FF) + 0xDC00 + ); +} + +var simpleEscapeCheck = new Array(256); // integer, for fast access +var simpleEscapeMap = new Array(256); +for (var i = 0; i < 256; i++) { + simpleEscapeCheck[i] = simpleEscapeSequence(i) ? 1 : 0; + simpleEscapeMap[i] = simpleEscapeSequence(i); +} + + +function State(input, options) { + this.input = input; + + this.filename = options['filename'] || null; + this.schema = options['schema'] || DEFAULT_FULL_SCHEMA; + this.onWarning = options['onWarning'] || null; + this.legacy = options['legacy'] || false; + this.json = options['json'] || false; + this.listener = options['listener'] || null; + + this.implicitTypes = this.schema.compiledImplicit; + this.typeMap = this.schema.compiledTypeMap; + + this.length = input.length; + this.position = 0; + this.line = 0; + this.lineStart = 0; + this.lineIndent = 0; + + this.documents = []; + + /* + this.version; + this.checkLineBreaks; + this.tagMap; + this.anchorMap; + this.tag; + this.anchor; + this.kind; + this.result;*/ + +} + + +function generateError(state, message) { + return new YAMLException( + message, + new Mark(state.filename, state.input, state.position, state.line, (state.position - state.lineStart))); +} + +function throwError(state, message) { + throw generateError(state, message); +} + +function throwWarning(state, message) { + if (state.onWarning) { + state.onWarning.call(null, generateError(state, message)); + } +} + + +var directiveHandlers = { + + YAML: function handleYamlDirective(state, name, args) { + + var match, major, minor; + + if (state.version !== null) { + throwError(state, 'duplication of %YAML directive'); + } + + if (args.length !== 1) { + throwError(state, 'YAML directive accepts exactly one argument'); + } + + match = /^([0-9]+)\.([0-9]+)$/.exec(args[0]); + + if (match === null) { + throwError(state, 'ill-formed argument of the YAML directive'); + } + + major = parseInt(match[1], 10); + minor = parseInt(match[2], 10); + + if (major !== 1) { + throwError(state, 'unacceptable YAML version of the document'); + } + + state.version = args[0]; + state.checkLineBreaks = (minor < 2); + + if (minor !== 1 && minor !== 2) { + throwWarning(state, 'unsupported YAML version of the document'); + } + }, + + TAG: function handleTagDirective(state, name, args) { + + var handle, prefix; + + if (args.length !== 2) { + throwError(state, 'TAG directive accepts exactly two arguments'); + } + + handle = args[0]; + prefix = args[1]; + + if (!PATTERN_TAG_HANDLE.test(handle)) { + throwError(state, 'ill-formed tag handle (first argument) of the TAG directive'); + } + + if (_hasOwnProperty.call(state.tagMap, handle)) { + throwError(state, 'there is a previously declared suffix for "' + handle + '" tag handle'); + } + + if (!PATTERN_TAG_URI.test(prefix)) { + throwError(state, 'ill-formed tag prefix (second argument) of the TAG directive'); + } + + state.tagMap[handle] = prefix; + } +}; + + +function captureSegment(state, start, end, checkJson) { + var _position, _length, _character, _result; + + if (start < end) { + _result = state.input.slice(start, end); + + if (checkJson) { + for (_position = 0, _length = _result.length; _position < _length; _position += 1) { + _character = _result.charCodeAt(_position); + if (!(_character === 0x09 || + (0x20 <= _character && _character <= 0x10FFFF))) { + throwError(state, 'expected valid JSON character'); + } + } + } else if (PATTERN_NON_PRINTABLE.test(_result)) { + throwError(state, 'the stream contains non-printable characters'); + } + + state.result += _result; + } +} + +function mergeMappings(state, destination, source, overridableKeys) { + var sourceKeys, key, index, quantity; + + if (!common.isObject(source)) { + throwError(state, 'cannot merge mappings; the provided source object is unacceptable'); + } + + sourceKeys = Object.keys(source); + + for (index = 0, quantity = sourceKeys.length; index < quantity; index += 1) { + key = sourceKeys[index]; + + if (!_hasOwnProperty.call(destination, key)) { + destination[key] = source[key]; + overridableKeys[key] = true; + } + } +} + +function storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, valueNode, startLine, startPos) { + var index, quantity; + + // The output is a plain object here, so keys can only be strings. + // We need to convert keyNode to a string, but doing so can hang the process + // (deeply nested arrays that explode exponentially using aliases). + if (Array.isArray(keyNode)) { + keyNode = Array.prototype.slice.call(keyNode); + + for (index = 0, quantity = keyNode.length; index < quantity; index += 1) { + if (Array.isArray(keyNode[index])) { + throwError(state, 'nested arrays are not supported inside keys'); + } + + if (typeof keyNode === 'object' && _class(keyNode[index]) === '[object Object]') { + keyNode[index] = '[object Object]'; + } + } + } + + // Avoid code execution in load() via toString property + // (still use its own toString for arrays, timestamps, + // and whatever user schema extensions happen to have @@toStringTag) + if (typeof keyNode === 'object' && _class(keyNode) === '[object Object]') { + keyNode = '[object Object]'; + } + + + keyNode = String(keyNode); + + if (_result === null) { + _result = {}; + } + + if (keyTag === 'tag:yaml.org,2002:merge') { + if (Array.isArray(valueNode)) { + for (index = 0, quantity = valueNode.length; index < quantity; index += 1) { + mergeMappings(state, _result, valueNode[index], overridableKeys); + } + } else { + mergeMappings(state, _result, valueNode, overridableKeys); + } + } else { + if (!state.json && + !_hasOwnProperty.call(overridableKeys, keyNode) && + _hasOwnProperty.call(_result, keyNode)) { + state.line = startLine || state.line; + state.position = startPos || state.position; + throwError(state, 'duplicated mapping key'); + } + _result[keyNode] = valueNode; + delete overridableKeys[keyNode]; + } + + return _result; +} + +function readLineBreak(state) { + var ch; + + ch = state.input.charCodeAt(state.position); + + if (ch === 0x0A/* LF */) { + state.position++; + } else if (ch === 0x0D/* CR */) { + state.position++; + if (state.input.charCodeAt(state.position) === 0x0A/* LF */) { + state.position++; + } + } else { + throwError(state, 'a line break is expected'); + } + + state.line += 1; + state.lineStart = state.position; +} + +function skipSeparationSpace(state, allowComments, checkIndent) { + var lineBreaks = 0, + ch = state.input.charCodeAt(state.position); + + while (ch !== 0) { + while (is_WHITE_SPACE(ch)) { + ch = state.input.charCodeAt(++state.position); + } + + if (allowComments && ch === 0x23/* # */) { + do { + ch = state.input.charCodeAt(++state.position); + } while (ch !== 0x0A/* LF */ && ch !== 0x0D/* CR */ && ch !== 0); + } + + if (is_EOL(ch)) { + readLineBreak(state); + + ch = state.input.charCodeAt(state.position); + lineBreaks++; + state.lineIndent = 0; + + while (ch === 0x20/* Space */) { + state.lineIndent++; + ch = state.input.charCodeAt(++state.position); + } + } else { + break; + } + } + + if (checkIndent !== -1 && lineBreaks !== 0 && state.lineIndent < checkIndent) { + throwWarning(state, 'deficient indentation'); + } + + return lineBreaks; +} + +function testDocumentSeparator(state) { + var _position = state.position, + ch; + + ch = state.input.charCodeAt(_position); + + // Condition state.position === state.lineStart is tested + // in parent on each call, for efficiency. No needs to test here again. + if ((ch === 0x2D/* - */ || ch === 0x2E/* . */) && + ch === state.input.charCodeAt(_position + 1) && + ch === state.input.charCodeAt(_position + 2)) { + + _position += 3; + + ch = state.input.charCodeAt(_position); + + if (ch === 0 || is_WS_OR_EOL(ch)) { + return true; + } + } + + return false; +} + +function writeFoldedLines(state, count) { + if (count === 1) { + state.result += ' '; + } else if (count > 1) { + state.result += common.repeat('\n', count - 1); + } +} + + +function readPlainScalar(state, nodeIndent, withinFlowCollection) { + var preceding, + following, + captureStart, + captureEnd, + hasPendingContent, + _line, + _lineStart, + _lineIndent, + _kind = state.kind, + _result = state.result, + ch; + + ch = state.input.charCodeAt(state.position); + + if (is_WS_OR_EOL(ch) || + is_FLOW_INDICATOR(ch) || + ch === 0x23/* # */ || + ch === 0x26/* & */ || + ch === 0x2A/* * */ || + ch === 0x21/* ! */ || + ch === 0x7C/* | */ || + ch === 0x3E/* > */ || + ch === 0x27/* ' */ || + ch === 0x22/* " */ || + ch === 0x25/* % */ || + ch === 0x40/* @ */ || + ch === 0x60/* ` */) { + return false; + } + + if (ch === 0x3F/* ? */ || ch === 0x2D/* - */) { + following = state.input.charCodeAt(state.position + 1); + + if (is_WS_OR_EOL(following) || + withinFlowCollection && is_FLOW_INDICATOR(following)) { + return false; + } + } + + state.kind = 'scalar'; + state.result = ''; + captureStart = captureEnd = state.position; + hasPendingContent = false; + + while (ch !== 0) { + if (ch === 0x3A/* : */) { + following = state.input.charCodeAt(state.position + 1); + + if (is_WS_OR_EOL(following) || + withinFlowCollection && is_FLOW_INDICATOR(following)) { + break; + } + + } else if (ch === 0x23/* # */) { + preceding = state.input.charCodeAt(state.position - 1); + + if (is_WS_OR_EOL(preceding)) { + break; + } + + } else if ((state.position === state.lineStart && testDocumentSeparator(state)) || + withinFlowCollection && is_FLOW_INDICATOR(ch)) { + break; + + } else if (is_EOL(ch)) { + _line = state.line; + _lineStart = state.lineStart; + _lineIndent = state.lineIndent; + skipSeparationSpace(state, false, -1); + + if (state.lineIndent >= nodeIndent) { + hasPendingContent = true; + ch = state.input.charCodeAt(state.position); + continue; + } else { + state.position = captureEnd; + state.line = _line; + state.lineStart = _lineStart; + state.lineIndent = _lineIndent; + break; + } + } + + if (hasPendingContent) { + captureSegment(state, captureStart, captureEnd, false); + writeFoldedLines(state, state.line - _line); + captureStart = captureEnd = state.position; + hasPendingContent = false; + } + + if (!is_WHITE_SPACE(ch)) { + captureEnd = state.position + 1; + } + + ch = state.input.charCodeAt(++state.position); + } + + captureSegment(state, captureStart, captureEnd, false); + + if (state.result) { + return true; + } + + state.kind = _kind; + state.result = _result; + return false; +} + +function readSingleQuotedScalar(state, nodeIndent) { + var ch, + captureStart, captureEnd; + + ch = state.input.charCodeAt(state.position); + + if (ch !== 0x27/* ' */) { + return false; + } + + state.kind = 'scalar'; + state.result = ''; + state.position++; + captureStart = captureEnd = state.position; + + while ((ch = state.input.charCodeAt(state.position)) !== 0) { + if (ch === 0x27/* ' */) { + captureSegment(state, captureStart, state.position, true); + ch = state.input.charCodeAt(++state.position); + + if (ch === 0x27/* ' */) { + captureStart = state.position; + state.position++; + captureEnd = state.position; + } else { + return true; + } + + } else if (is_EOL(ch)) { + captureSegment(state, captureStart, captureEnd, true); + writeFoldedLines(state, skipSeparationSpace(state, false, nodeIndent)); + captureStart = captureEnd = state.position; + + } else if (state.position === state.lineStart && testDocumentSeparator(state)) { + throwError(state, 'unexpected end of the document within a single quoted scalar'); + + } else { + state.position++; + captureEnd = state.position; + } + } + + throwError(state, 'unexpected end of the stream within a single quoted scalar'); +} + +function readDoubleQuotedScalar(state, nodeIndent) { + var captureStart, + captureEnd, + hexLength, + hexResult, + tmp, + ch; + + ch = state.input.charCodeAt(state.position); + + if (ch !== 0x22/* " */) { + return false; + } + + state.kind = 'scalar'; + state.result = ''; + state.position++; + captureStart = captureEnd = state.position; + + while ((ch = state.input.charCodeAt(state.position)) !== 0) { + if (ch === 0x22/* " */) { + captureSegment(state, captureStart, state.position, true); + state.position++; + return true; + + } else if (ch === 0x5C/* \ */) { + captureSegment(state, captureStart, state.position, true); + ch = state.input.charCodeAt(++state.position); + + if (is_EOL(ch)) { + skipSeparationSpace(state, false, nodeIndent); + + // TODO: rework to inline fn with no type cast? + } else if (ch < 256 && simpleEscapeCheck[ch]) { + state.result += simpleEscapeMap[ch]; + state.position++; + + } else if ((tmp = escapedHexLen(ch)) > 0) { + hexLength = tmp; + hexResult = 0; + + for (; hexLength > 0; hexLength--) { + ch = state.input.charCodeAt(++state.position); + + if ((tmp = fromHexCode(ch)) >= 0) { + hexResult = (hexResult << 4) + tmp; + + } else { + throwError(state, 'expected hexadecimal character'); + } + } + + state.result += charFromCodepoint(hexResult); + + state.position++; + + } else { + throwError(state, 'unknown escape sequence'); + } + + captureStart = captureEnd = state.position; + + } else if (is_EOL(ch)) { + captureSegment(state, captureStart, captureEnd, true); + writeFoldedLines(state, skipSeparationSpace(state, false, nodeIndent)); + captureStart = captureEnd = state.position; + + } else if (state.position === state.lineStart && testDocumentSeparator(state)) { + throwError(state, 'unexpected end of the document within a double quoted scalar'); + + } else { + state.position++; + captureEnd = state.position; + } + } + + throwError(state, 'unexpected end of the stream within a double quoted scalar'); +} + +function readFlowCollection(state, nodeIndent) { + var readNext = true, + _line, + _tag = state.tag, + _result, + _anchor = state.anchor, + following, + terminator, + isPair, + isExplicitPair, + isMapping, + overridableKeys = {}, + keyNode, + keyTag, + valueNode, + ch; + + ch = state.input.charCodeAt(state.position); + + if (ch === 0x5B/* [ */) { + terminator = 0x5D;/* ] */ + isMapping = false; + _result = []; + } else if (ch === 0x7B/* { */) { + terminator = 0x7D;/* } */ + isMapping = true; + _result = {}; + } else { + return false; + } + + if (state.anchor !== null) { + state.anchorMap[state.anchor] = _result; + } + + ch = state.input.charCodeAt(++state.position); + + while (ch !== 0) { + skipSeparationSpace(state, true, nodeIndent); + + ch = state.input.charCodeAt(state.position); + + if (ch === terminator) { + state.position++; + state.tag = _tag; + state.anchor = _anchor; + state.kind = isMapping ? 'mapping' : 'sequence'; + state.result = _result; + return true; + } else if (!readNext) { + throwError(state, 'missed comma between flow collection entries'); + } + + keyTag = keyNode = valueNode = null; + isPair = isExplicitPair = false; + + if (ch === 0x3F/* ? */) { + following = state.input.charCodeAt(state.position + 1); + + if (is_WS_OR_EOL(following)) { + isPair = isExplicitPair = true; + state.position++; + skipSeparationSpace(state, true, nodeIndent); + } + } + + _line = state.line; + composeNode(state, nodeIndent, CONTEXT_FLOW_IN, false, true); + keyTag = state.tag; + keyNode = state.result; + skipSeparationSpace(state, true, nodeIndent); + + ch = state.input.charCodeAt(state.position); + + if ((isExplicitPair || state.line === _line) && ch === 0x3A/* : */) { + isPair = true; + ch = state.input.charCodeAt(++state.position); + skipSeparationSpace(state, true, nodeIndent); + composeNode(state, nodeIndent, CONTEXT_FLOW_IN, false, true); + valueNode = state.result; + } + + if (isMapping) { + storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, valueNode); + } else if (isPair) { + _result.push(storeMappingPair(state, null, overridableKeys, keyTag, keyNode, valueNode)); + } else { + _result.push(keyNode); + } + + skipSeparationSpace(state, true, nodeIndent); + + ch = state.input.charCodeAt(state.position); + + if (ch === 0x2C/* , */) { + readNext = true; + ch = state.input.charCodeAt(++state.position); + } else { + readNext = false; + } + } + + throwError(state, 'unexpected end of the stream within a flow collection'); +} + +function readBlockScalar(state, nodeIndent) { + var captureStart, + folding, + chomping = CHOMPING_CLIP, + didReadContent = false, + detectedIndent = false, + textIndent = nodeIndent, + emptyLines = 0, + atMoreIndented = false, + tmp, + ch; + + ch = state.input.charCodeAt(state.position); + + if (ch === 0x7C/* | */) { + folding = false; + } else if (ch === 0x3E/* > */) { + folding = true; + } else { + return false; + } + + state.kind = 'scalar'; + state.result = ''; + + while (ch !== 0) { + ch = state.input.charCodeAt(++state.position); + + if (ch === 0x2B/* + */ || ch === 0x2D/* - */) { + if (CHOMPING_CLIP === chomping) { + chomping = (ch === 0x2B/* + */) ? CHOMPING_KEEP : CHOMPING_STRIP; + } else { + throwError(state, 'repeat of a chomping mode identifier'); + } + + } else if ((tmp = fromDecimalCode(ch)) >= 0) { + if (tmp === 0) { + throwError(state, 'bad explicit indentation width of a block scalar; it cannot be less than one'); + } else if (!detectedIndent) { + textIndent = nodeIndent + tmp - 1; + detectedIndent = true; + } else { + throwError(state, 'repeat of an indentation width identifier'); + } + + } else { + break; + } + } + + if (is_WHITE_SPACE(ch)) { + do { ch = state.input.charCodeAt(++state.position); } + while (is_WHITE_SPACE(ch)); + + if (ch === 0x23/* # */) { + do { ch = state.input.charCodeAt(++state.position); } + while (!is_EOL(ch) && (ch !== 0)); + } + } + + while (ch !== 0) { + readLineBreak(state); + state.lineIndent = 0; + + ch = state.input.charCodeAt(state.position); + + while ((!detectedIndent || state.lineIndent < textIndent) && + (ch === 0x20/* Space */)) { + state.lineIndent++; + ch = state.input.charCodeAt(++state.position); + } + + if (!detectedIndent && state.lineIndent > textIndent) { + textIndent = state.lineIndent; + } + + if (is_EOL(ch)) { + emptyLines++; + continue; + } + + // End of the scalar. + if (state.lineIndent < textIndent) { + + // Perform the chomping. + if (chomping === CHOMPING_KEEP) { + state.result += common.repeat('\n', didReadContent ? 1 + emptyLines : emptyLines); + } else if (chomping === CHOMPING_CLIP) { + if (didReadContent) { // i.e. only if the scalar is not empty. + state.result += '\n'; + } + } + + // Break this `while` cycle and go to the funciton's epilogue. + break; + } + + // Folded style: use fancy rules to handle line breaks. + if (folding) { + + // Lines starting with white space characters (more-indented lines) are not folded. + if (is_WHITE_SPACE(ch)) { + atMoreIndented = true; + // except for the first content line (cf. Example 8.1) + state.result += common.repeat('\n', didReadContent ? 1 + emptyLines : emptyLines); + + // End of more-indented block. + } else if (atMoreIndented) { + atMoreIndented = false; + state.result += common.repeat('\n', emptyLines + 1); + + // Just one line break - perceive as the same line. + } else if (emptyLines === 0) { + if (didReadContent) { // i.e. only if we have already read some scalar content. + state.result += ' '; + } + + // Several line breaks - perceive as different lines. + } else { + state.result += common.repeat('\n', emptyLines); + } + + // Literal style: just add exact number of line breaks between content lines. + } else { + // Keep all line breaks except the header line break. + state.result += common.repeat('\n', didReadContent ? 1 + emptyLines : emptyLines); + } + + didReadContent = true; + detectedIndent = true; + emptyLines = 0; + captureStart = state.position; + + while (!is_EOL(ch) && (ch !== 0)) { + ch = state.input.charCodeAt(++state.position); + } + + captureSegment(state, captureStart, state.position, false); + } + + return true; +} + +function readBlockSequence(state, nodeIndent) { + var _line, + _tag = state.tag, + _anchor = state.anchor, + _result = [], + following, + detected = false, + ch; + + if (state.anchor !== null) { + state.anchorMap[state.anchor] = _result; + } + + ch = state.input.charCodeAt(state.position); + + while (ch !== 0) { + + if (ch !== 0x2D/* - */) { + break; + } + + following = state.input.charCodeAt(state.position + 1); + + if (!is_WS_OR_EOL(following)) { + break; + } + + detected = true; + state.position++; + + if (skipSeparationSpace(state, true, -1)) { + if (state.lineIndent <= nodeIndent) { + _result.push(null); + ch = state.input.charCodeAt(state.position); + continue; + } + } + + _line = state.line; + composeNode(state, nodeIndent, CONTEXT_BLOCK_IN, false, true); + _result.push(state.result); + skipSeparationSpace(state, true, -1); + + ch = state.input.charCodeAt(state.position); + + if ((state.line === _line || state.lineIndent > nodeIndent) && (ch !== 0)) { + throwError(state, 'bad indentation of a sequence entry'); + } else if (state.lineIndent < nodeIndent) { + break; + } + } + + if (detected) { + state.tag = _tag; + state.anchor = _anchor; + state.kind = 'sequence'; + state.result = _result; + return true; + } + return false; +} + +function readBlockMapping(state, nodeIndent, flowIndent) { + var following, + allowCompact, + _line, + _pos, + _tag = state.tag, + _anchor = state.anchor, + _result = {}, + overridableKeys = {}, + keyTag = null, + keyNode = null, + valueNode = null, + atExplicitKey = false, + detected = false, + ch; + + if (state.anchor !== null) { + state.anchorMap[state.anchor] = _result; + } + + ch = state.input.charCodeAt(state.position); + + while (ch !== 0) { + following = state.input.charCodeAt(state.position + 1); + _line = state.line; // Save the current line. + _pos = state.position; + + // + // Explicit notation case. There are two separate blocks: + // first for the key (denoted by "?") and second for the value (denoted by ":") + // + if ((ch === 0x3F/* ? */ || ch === 0x3A/* : */) && is_WS_OR_EOL(following)) { + + if (ch === 0x3F/* ? */) { + if (atExplicitKey) { + storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, null); + keyTag = keyNode = valueNode = null; + } + + detected = true; + atExplicitKey = true; + allowCompact = true; + + } else if (atExplicitKey) { + // i.e. 0x3A/* : */ === character after the explicit key. + atExplicitKey = false; + allowCompact = true; + + } else { + throwError(state, 'incomplete explicit mapping pair; a key node is missed; or followed by a non-tabulated empty line'); + } + + state.position += 1; + ch = following; + + // + // Implicit notation case. Flow-style node as the key first, then ":", and the value. + // + } else if (composeNode(state, flowIndent, CONTEXT_FLOW_OUT, false, true)) { + + if (state.line === _line) { + ch = state.input.charCodeAt(state.position); + + while (is_WHITE_SPACE(ch)) { + ch = state.input.charCodeAt(++state.position); + } + + if (ch === 0x3A/* : */) { + ch = state.input.charCodeAt(++state.position); + + if (!is_WS_OR_EOL(ch)) { + throwError(state, 'a whitespace character is expected after the key-value separator within a block mapping'); + } + + if (atExplicitKey) { + storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, null); + keyTag = keyNode = valueNode = null; + } + + detected = true; + atExplicitKey = false; + allowCompact = false; + keyTag = state.tag; + keyNode = state.result; + + } else if (detected) { + throwError(state, 'can not read an implicit mapping pair; a colon is missed'); + + } else { + state.tag = _tag; + state.anchor = _anchor; + return true; // Keep the result of `composeNode`. + } + + } else if (detected) { + throwError(state, 'can not read a block mapping entry; a multiline key may not be an implicit key'); + + } else { + state.tag = _tag; + state.anchor = _anchor; + return true; // Keep the result of `composeNode`. + } + + } else { + break; // Reading is done. Go to the epilogue. + } + + // + // Common reading code for both explicit and implicit notations. + // + if (state.line === _line || state.lineIndent > nodeIndent) { + if (composeNode(state, nodeIndent, CONTEXT_BLOCK_OUT, true, allowCompact)) { + if (atExplicitKey) { + keyNode = state.result; + } else { + valueNode = state.result; + } + } + + if (!atExplicitKey) { + storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, valueNode, _line, _pos); + keyTag = keyNode = valueNode = null; + } + + skipSeparationSpace(state, true, -1); + ch = state.input.charCodeAt(state.position); + } + + if (state.lineIndent > nodeIndent && (ch !== 0)) { + throwError(state, 'bad indentation of a mapping entry'); + } else if (state.lineIndent < nodeIndent) { + break; + } + } + + // + // Epilogue. + // + + // Special case: last mapping's node contains only the key in explicit notation. + if (atExplicitKey) { + storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, null); + } + + // Expose the resulting mapping. + if (detected) { + state.tag = _tag; + state.anchor = _anchor; + state.kind = 'mapping'; + state.result = _result; + } + + return detected; +} + +function readTagProperty(state) { + var _position, + isVerbatim = false, + isNamed = false, + tagHandle, + tagName, + ch; + + ch = state.input.charCodeAt(state.position); + + if (ch !== 0x21/* ! */) return false; + + if (state.tag !== null) { + throwError(state, 'duplication of a tag property'); + } + + ch = state.input.charCodeAt(++state.position); + + if (ch === 0x3C/* < */) { + isVerbatim = true; + ch = state.input.charCodeAt(++state.position); + + } else if (ch === 0x21/* ! */) { + isNamed = true; + tagHandle = '!!'; + ch = state.input.charCodeAt(++state.position); + + } else { + tagHandle = '!'; + } + + _position = state.position; + + if (isVerbatim) { + do { ch = state.input.charCodeAt(++state.position); } + while (ch !== 0 && ch !== 0x3E/* > */); + + if (state.position < state.length) { + tagName = state.input.slice(_position, state.position); + ch = state.input.charCodeAt(++state.position); + } else { + throwError(state, 'unexpected end of the stream within a verbatim tag'); + } + } else { + while (ch !== 0 && !is_WS_OR_EOL(ch)) { + + if (ch === 0x21/* ! */) { + if (!isNamed) { + tagHandle = state.input.slice(_position - 1, state.position + 1); + + if (!PATTERN_TAG_HANDLE.test(tagHandle)) { + throwError(state, 'named tag handle cannot contain such characters'); + } + + isNamed = true; + _position = state.position + 1; + } else { + throwError(state, 'tag suffix cannot contain exclamation marks'); + } + } + + ch = state.input.charCodeAt(++state.position); + } + + tagName = state.input.slice(_position, state.position); + + if (PATTERN_FLOW_INDICATORS.test(tagName)) { + throwError(state, 'tag suffix cannot contain flow indicator characters'); + } + } + + if (tagName && !PATTERN_TAG_URI.test(tagName)) { + throwError(state, 'tag name cannot contain such characters: ' + tagName); + } + + if (isVerbatim) { + state.tag = tagName; + + } else if (_hasOwnProperty.call(state.tagMap, tagHandle)) { + state.tag = state.tagMap[tagHandle] + tagName; + + } else if (tagHandle === '!') { + state.tag = '!' + tagName; + + } else if (tagHandle === '!!') { + state.tag = 'tag:yaml.org,2002:' + tagName; + + } else { + throwError(state, 'undeclared tag handle "' + tagHandle + '"'); + } + + return true; +} + +function readAnchorProperty(state) { + var _position, + ch; + + ch = state.input.charCodeAt(state.position); + + if (ch !== 0x26/* & */) return false; + + if (state.anchor !== null) { + throwError(state, 'duplication of an anchor property'); + } + + ch = state.input.charCodeAt(++state.position); + _position = state.position; + + while (ch !== 0 && !is_WS_OR_EOL(ch) && !is_FLOW_INDICATOR(ch)) { + ch = state.input.charCodeAt(++state.position); + } + + if (state.position === _position) { + throwError(state, 'name of an anchor node must contain at least one character'); + } + + state.anchor = state.input.slice(_position, state.position); + return true; +} + +function readAlias(state) { + var _position, alias, + ch; + + ch = state.input.charCodeAt(state.position); + + if (ch !== 0x2A/* * */) return false; + + ch = state.input.charCodeAt(++state.position); + _position = state.position; + + while (ch !== 0 && !is_WS_OR_EOL(ch) && !is_FLOW_INDICATOR(ch)) { + ch = state.input.charCodeAt(++state.position); + } + + if (state.position === _position) { + throwError(state, 'name of an alias node must contain at least one character'); + } + + alias = state.input.slice(_position, state.position); + + if (!state.anchorMap.hasOwnProperty(alias)) { + throwError(state, 'unidentified alias "' + alias + '"'); + } + + state.result = state.anchorMap[alias]; + skipSeparationSpace(state, true, -1); + return true; +} + +function composeNode(state, parentIndent, nodeContext, allowToSeek, allowCompact) { + var allowBlockStyles, + allowBlockScalars, + allowBlockCollections, + indentStatus = 1, // 1: this>parent, 0: this=parent, -1: this parentIndent) { + indentStatus = 1; + } else if (state.lineIndent === parentIndent) { + indentStatus = 0; + } else if (state.lineIndent < parentIndent) { + indentStatus = -1; + } + } + } + + if (indentStatus === 1) { + while (readTagProperty(state) || readAnchorProperty(state)) { + if (skipSeparationSpace(state, true, -1)) { + atNewLine = true; + allowBlockCollections = allowBlockStyles; + + if (state.lineIndent > parentIndent) { + indentStatus = 1; + } else if (state.lineIndent === parentIndent) { + indentStatus = 0; + } else if (state.lineIndent < parentIndent) { + indentStatus = -1; + } + } else { + allowBlockCollections = false; + } + } + } + + if (allowBlockCollections) { + allowBlockCollections = atNewLine || allowCompact; + } + + if (indentStatus === 1 || CONTEXT_BLOCK_OUT === nodeContext) { + if (CONTEXT_FLOW_IN === nodeContext || CONTEXT_FLOW_OUT === nodeContext) { + flowIndent = parentIndent; + } else { + flowIndent = parentIndent + 1; + } + + blockIndent = state.position - state.lineStart; + + if (indentStatus === 1) { + if (allowBlockCollections && + (readBlockSequence(state, blockIndent) || + readBlockMapping(state, blockIndent, flowIndent)) || + readFlowCollection(state, flowIndent)) { + hasContent = true; + } else { + if ((allowBlockScalars && readBlockScalar(state, flowIndent)) || + readSingleQuotedScalar(state, flowIndent) || + readDoubleQuotedScalar(state, flowIndent)) { + hasContent = true; + + } else if (readAlias(state)) { + hasContent = true; + + if (state.tag !== null || state.anchor !== null) { + throwError(state, 'alias node should not have any properties'); + } + + } else if (readPlainScalar(state, flowIndent, CONTEXT_FLOW_IN === nodeContext)) { + hasContent = true; + + if (state.tag === null) { + state.tag = '?'; + } + } + + if (state.anchor !== null) { + state.anchorMap[state.anchor] = state.result; + } + } + } else if (indentStatus === 0) { + // Special case: block sequences are allowed to have same indentation level as the parent. + // http://www.yaml.org/spec/1.2/spec.html#id2799784 + hasContent = allowBlockCollections && readBlockSequence(state, blockIndent); + } + } + + if (state.tag !== null && state.tag !== '!') { + if (state.tag === '?') { + for (typeIndex = 0, typeQuantity = state.implicitTypes.length; typeIndex < typeQuantity; typeIndex += 1) { + type = state.implicitTypes[typeIndex]; + + // Implicit resolving is not allowed for non-scalar types, and '?' + // non-specific tag is only assigned to plain scalars. So, it isn't + // needed to check for 'kind' conformity. + + if (type.resolve(state.result)) { // `state.result` updated in resolver if matched + state.result = type.construct(state.result); + state.tag = type.tag; + if (state.anchor !== null) { + state.anchorMap[state.anchor] = state.result; + } + break; + } + } + } else if (_hasOwnProperty.call(state.typeMap[state.kind || 'fallback'], state.tag)) { + type = state.typeMap[state.kind || 'fallback'][state.tag]; + + if (state.result !== null && type.kind !== state.kind) { + throwError(state, 'unacceptable node kind for !<' + state.tag + '> tag; it should be "' + type.kind + '", not "' + state.kind + '"'); + } + + if (!type.resolve(state.result)) { // `state.result` updated in resolver if matched + throwError(state, 'cannot resolve a node with !<' + state.tag + '> explicit tag'); + } else { + state.result = type.construct(state.result); + if (state.anchor !== null) { + state.anchorMap[state.anchor] = state.result; + } + } + } else { + throwError(state, 'unknown tag !<' + state.tag + '>'); + } + } + + if (state.listener !== null) { + state.listener('close', state); + } + return state.tag !== null || state.anchor !== null || hasContent; +} + +function readDocument(state) { + var documentStart = state.position, + _position, + directiveName, + directiveArgs, + hasDirectives = false, + ch; + + state.version = null; + state.checkLineBreaks = state.legacy; + state.tagMap = {}; + state.anchorMap = {}; + + while ((ch = state.input.charCodeAt(state.position)) !== 0) { + skipSeparationSpace(state, true, -1); + + ch = state.input.charCodeAt(state.position); + + if (state.lineIndent > 0 || ch !== 0x25/* % */) { + break; + } + + hasDirectives = true; + ch = state.input.charCodeAt(++state.position); + _position = state.position; + + while (ch !== 0 && !is_WS_OR_EOL(ch)) { + ch = state.input.charCodeAt(++state.position); + } + + directiveName = state.input.slice(_position, state.position); + directiveArgs = []; + + if (directiveName.length < 1) { + throwError(state, 'directive name must not be less than one character in length'); + } + + while (ch !== 0) { + while (is_WHITE_SPACE(ch)) { + ch = state.input.charCodeAt(++state.position); + } + + if (ch === 0x23/* # */) { + do { ch = state.input.charCodeAt(++state.position); } + while (ch !== 0 && !is_EOL(ch)); + break; + } + + if (is_EOL(ch)) break; + + _position = state.position; + + while (ch !== 0 && !is_WS_OR_EOL(ch)) { + ch = state.input.charCodeAt(++state.position); + } + + directiveArgs.push(state.input.slice(_position, state.position)); + } + + if (ch !== 0) readLineBreak(state); + + if (_hasOwnProperty.call(directiveHandlers, directiveName)) { + directiveHandlers[directiveName](state, directiveName, directiveArgs); + } else { + throwWarning(state, 'unknown document directive "' + directiveName + '"'); + } + } + + skipSeparationSpace(state, true, -1); + + if (state.lineIndent === 0 && + state.input.charCodeAt(state.position) === 0x2D/* - */ && + state.input.charCodeAt(state.position + 1) === 0x2D/* - */ && + state.input.charCodeAt(state.position + 2) === 0x2D/* - */) { + state.position += 3; + skipSeparationSpace(state, true, -1); + + } else if (hasDirectives) { + throwError(state, 'directives end mark is expected'); + } + + composeNode(state, state.lineIndent - 1, CONTEXT_BLOCK_OUT, false, true); + skipSeparationSpace(state, true, -1); + + if (state.checkLineBreaks && + PATTERN_NON_ASCII_LINE_BREAKS.test(state.input.slice(documentStart, state.position))) { + throwWarning(state, 'non-ASCII line breaks are interpreted as content'); + } + + state.documents.push(state.result); + + if (state.position === state.lineStart && testDocumentSeparator(state)) { + + if (state.input.charCodeAt(state.position) === 0x2E/* . */) { + state.position += 3; + skipSeparationSpace(state, true, -1); + } + return; + } + + if (state.position < (state.length - 1)) { + throwError(state, 'end of the stream or a document separator is expected'); + } else { + return; + } +} + + +function loadDocuments(input, options) { + input = String(input); + options = options || {}; + + if (input.length !== 0) { + + // Add tailing `\n` if not exists + if (input.charCodeAt(input.length - 1) !== 0x0A/* LF */ && + input.charCodeAt(input.length - 1) !== 0x0D/* CR */) { + input += '\n'; + } + + // Strip BOM + if (input.charCodeAt(0) === 0xFEFF) { + input = input.slice(1); + } + } + + var state = new State(input, options); + + // Use 0 as string terminator. That significantly simplifies bounds check. + state.input += '\0'; + + while (state.input.charCodeAt(state.position) === 0x20/* Space */) { + state.lineIndent += 1; + state.position += 1; + } + + while (state.position < (state.length - 1)) { + readDocument(state); + } + + return state.documents; +} + + +function loadAll(input, iterator, options) { + var documents = loadDocuments(input, options), index, length; + + if (typeof iterator !== 'function') { + return documents; + } + + for (index = 0, length = documents.length; index < length; index += 1) { + iterator(documents[index]); + } +} + + +function load(input, options) { + var documents = loadDocuments(input, options); + + if (documents.length === 0) { + /*eslint-disable no-undefined*/ + return undefined; + } else if (documents.length === 1) { + return documents[0]; + } + throw new YAMLException('expected a single document in the stream, but found more'); +} + + +function safeLoadAll(input, output, options) { + if (typeof output === 'function') { + loadAll(input, output, common.extend({ schema: DEFAULT_SAFE_SCHEMA }, options)); + } else { + return loadAll(input, common.extend({ schema: DEFAULT_SAFE_SCHEMA }, options)); + } +} + + +function safeLoad(input, options) { + return load(input, common.extend({ schema: DEFAULT_SAFE_SCHEMA }, options)); +} + + +module.exports.loadAll = loadAll; +module.exports.load = load; +module.exports.safeLoadAll = safeLoadAll; +module.exports.safeLoad = safeLoad; + + +/***/ }), + +/***/ 462: +/***/ (function(module) { + +"use strict"; + + +// See http://www.robvanderwoude.com/escapechars.php +const metaCharsRegExp = /([()\][%!^"`<>&|;, *?])/g; + +function escapeCommand(arg) { + // Escape meta chars + arg = arg.replace(metaCharsRegExp, '^$1'); + + return arg; +} + +function escapeArgument(arg, doubleEscapeMetaChars) { + // Convert to string + arg = `${arg}`; + + // Algorithm below is based on https://qntm.org/cmd + + // Sequence of backslashes followed by a double quote: + // double up all the backslashes and escape the double quote + arg = arg.replace(/(\\*)"/g, '$1$1\\"'); + + // Sequence of backslashes followed by the end of the string + // (which will become a double quote later): + // double up all the backslashes + arg = arg.replace(/(\\*)$/, '$1$1'); + + // All other backslashes occur literally + + // Quote the whole thing: + arg = `"${arg}"`; + + // Escape meta chars + arg = arg.replace(metaCharsRegExp, '^$1'); + + // Double escape meta chars if necessary + if (doubleEscapeMetaChars) { + arg = arg.replace(metaCharsRegExp, '^$1'); + } + + return arg; +} + +module.exports.command = escapeCommand; +module.exports.argument = escapeArgument; + + +/***/ }), + +/***/ 463: +/***/ (function(__unusedmodule, exports, __webpack_require__) { + +"use strict"; + + +Object.defineProperty(exports, '__esModule', { value: true }); + +function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; } + +var deprecation = __webpack_require__(692); +var once = _interopDefault(__webpack_require__(969)); + +const logOnce = once(deprecation => console.warn(deprecation)); +/** + * Error with extra properties to help with debugging + */ + +class RequestError extends Error { + constructor(message, statusCode, options) { + super(message); // Maintains proper stack trace (only available on V8) + + /* istanbul ignore next */ + + if (Error.captureStackTrace) { + Error.captureStackTrace(this, this.constructor); + } + + this.name = "HttpError"; + this.status = statusCode; + Object.defineProperty(this, "code", { + get() { + logOnce(new deprecation.Deprecation("[@octokit/request-error] `error.code` is deprecated, use `error.status`.")); + return statusCode; + } + + }); + this.headers = options.headers || {}; // redact request credentials without mutating original request options + + const requestCopy = Object.assign({}, options.request); + + if (options.request.headers.authorization) { + requestCopy.headers = Object.assign({}, options.request.headers, { + authorization: options.request.headers.authorization.replace(/ .*$/, " [REDACTED]") + }); + } + + requestCopy.url = requestCopy.url // client_id & client_secret can be passed as URL query parameters to increase rate limit + // see https://developer.github.com/v3/#increasing-the-unauthenticated-rate-limit-for-oauth-applications + .replace(/\bclient_secret=\w+/g, "client_secret=[REDACTED]") // OAuth tokens can be passed as URL query parameters, although it is not recommended + // see https://developer.github.com/v3/#oauth2-token-sent-in-a-header + .replace(/\baccess_token=\w+/g, "access_token=[REDACTED]"); + this.request = requestCopy; + } + +} + +exports.RequestError = RequestError; +//# sourceMappingURL=index.js.map + + +/***/ }), + +/***/ 469: +/***/ (function(__unusedmodule, exports, __webpack_require__) { + +"use strict"; + +var __importStar = (this && this.__importStar) || function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k]; + result["default"] = mod; + return result; +}; +Object.defineProperty(exports, "__esModule", { value: true }); +// Originally pulled from https://github.com/JasonEtco/actions-toolkit/blob/master/src/github.ts +const graphql_1 = __webpack_require__(898); +const rest_1 = __webpack_require__(0); +const Context = __importStar(__webpack_require__(262)); +const httpClient = __importStar(__webpack_require__(539)); +// We need this in order to extend Octokit +rest_1.Octokit.prototype = new rest_1.Octokit(); +exports.context = new Context.Context(); +class GitHub extends rest_1.Octokit { + constructor(token, opts) { + super(GitHub.getOctokitOptions(GitHub.disambiguate(token, opts))); + this.graphql = GitHub.getGraphQL(GitHub.disambiguate(token, opts)); + } + /** + * Disambiguates the constructor overload parameters + */ + static disambiguate(token, opts) { + return [ + typeof token === 'string' ? token : '', + typeof token === 'object' ? token : opts || {} + ]; + } + static getOctokitOptions(args) { + const token = args[0]; + const options = Object.assign({}, args[1]); // Shallow clone - don't mutate the object provided by the caller + // Auth + const auth = GitHub.getAuthString(token, options); + if (auth) { + options.auth = auth; + } + // Proxy + const agent = GitHub.getProxyAgent(options); + if (agent) { + // Shallow clone - don't mutate the object provided by the caller + options.request = options.request ? Object.assign({}, options.request) : {}; + // Set the agent + options.request.agent = agent; + } + return options; + } + static getGraphQL(args) { + const defaults = {}; + const token = args[0]; + const options = args[1]; + // Authorization + const auth = this.getAuthString(token, options); + if (auth) { + defaults.headers = { + authorization: auth + }; + } + // Proxy + const agent = GitHub.getProxyAgent(options); + if (agent) { + defaults.request = { agent }; + } + return graphql_1.graphql.defaults(defaults); + } + static getAuthString(token, options) { + // Validate args + if (!token && !options.auth) { + throw new Error('Parameter token or opts.auth is required'); + } + else if (token && options.auth) { + throw new Error('Parameters token and opts.auth may not both be specified'); + } + return typeof options.auth === 'string' ? options.auth : `token ${token}`; + } + static getProxyAgent(options) { + var _a; + if (!((_a = options.request) === null || _a === void 0 ? void 0 : _a.agent)) { + const serverUrl = 'https://api.github.com'; + if (httpClient.getProxyUrl(serverUrl)) { + const hc = new httpClient.HttpClient(); + return hc.getAgent(serverUrl); + } + } + return undefined; + } +} +exports.GitHub = GitHub; +//# sourceMappingURL=github.js.map + +/***/ }), + +/***/ 470: +/***/ (function(__unusedmodule, exports, __webpack_require__) { + +"use strict"; + +var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { + function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); } + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +}; +var __importStar = (this && this.__importStar) || function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k]; + result["default"] = mod; + return result; +}; +Object.defineProperty(exports, "__esModule", { value: true }); +const command_1 = __webpack_require__(431); +const os = __importStar(__webpack_require__(87)); +const path = __importStar(__webpack_require__(622)); +/** + * The code to exit an action + */ +var ExitCode; +(function (ExitCode) { + /** + * A code indicating that the action was successful + */ + ExitCode[ExitCode["Success"] = 0] = "Success"; + /** + * A code indicating that the action was a failure + */ + ExitCode[ExitCode["Failure"] = 1] = "Failure"; +})(ExitCode = exports.ExitCode || (exports.ExitCode = {})); +//----------------------------------------------------------------------- +// Variables +//----------------------------------------------------------------------- +/** + * Sets env variable for this action and future actions in the job + * @param name the name of the variable to set + * @param val the value of the variable + */ +function exportVariable(name, val) { + process.env[name] = val; + command_1.issueCommand('set-env', { name }, val); +} +exports.exportVariable = exportVariable; +/** + * Registers a secret which will get masked from logs + * @param secret value of the secret + */ +function setSecret(secret) { + command_1.issueCommand('add-mask', {}, secret); +} +exports.setSecret = setSecret; +/** + * Prepends inputPath to the PATH (for this action and future actions) + * @param inputPath + */ +function addPath(inputPath) { + command_1.issueCommand('add-path', {}, inputPath); + process.env['PATH'] = `${inputPath}${path.delimiter}${process.env['PATH']}`; +} +exports.addPath = addPath; +/** + * Gets the value of an input. The value is also trimmed. + * + * @param name name of the input to get + * @param options optional. See InputOptions. + * @returns string + */ +function getInput(name, options) { + const val = process.env[`INPUT_${name.replace(/ /g, '_').toUpperCase()}`] || ''; + if (options && options.required && !val) { + throw new Error(`Input required and not supplied: ${name}`); + } + return val.trim(); +} +exports.getInput = getInput; +/** + * Sets the value of an output. + * + * @param name name of the output to set + * @param value value to store + */ +function setOutput(name, value) { + command_1.issueCommand('set-output', { name }, value); +} +exports.setOutput = setOutput; +//----------------------------------------------------------------------- +// Results +//----------------------------------------------------------------------- +/** + * Sets the action status to failed. + * When the action exits it will be with an exit code of 1 + * @param message add error issue message + */ +function setFailed(message) { + process.exitCode = ExitCode.Failure; + error(message); +} +exports.setFailed = setFailed; +//----------------------------------------------------------------------- +// Logging Commands +//----------------------------------------------------------------------- +/** + * Gets whether Actions Step Debug is on or not + */ +function isDebug() { + return process.env['RUNNER_DEBUG'] === '1'; +} +exports.isDebug = isDebug; +/** + * Writes debug message to user log + * @param message debug message + */ +function debug(message) { + command_1.issueCommand('debug', {}, message); +} +exports.debug = debug; +/** + * Adds an error issue + * @param message error issue message + */ +function error(message) { + command_1.issue('error', message); +} +exports.error = error; +/** + * Adds an warning issue + * @param message warning issue message + */ +function warning(message) { + command_1.issue('warning', message); +} +exports.warning = warning; +/** + * Writes info to log with console.log. + * @param message info message + */ +function info(message) { + process.stdout.write(message + os.EOL); +} +exports.info = info; +/** + * Begin an output group. + * + * Output until the next `groupEnd` will be foldable in this group + * + * @param name The name of the output group + */ +function startGroup(name) { + command_1.issue('group', name); +} +exports.startGroup = startGroup; +/** + * End an output group. + */ +function endGroup() { + command_1.issue('endgroup'); +} +exports.endGroup = endGroup; +/** + * Wrap an asynchronous function call in a group. + * + * Returns the same type as the function itself. + * + * @param name The name of the group + * @param fn The function to wrap in the group + */ +function group(name, fn) { + return __awaiter(this, void 0, void 0, function* () { + startGroup(name); + let result; + try { + result = yield fn(); + } + finally { + endGroup(); + } + return result; + }); +} +exports.group = group; +//----------------------------------------------------------------------- +// Wrapper action state +//----------------------------------------------------------------------- +/** + * Saves state for current action, the state can only be retrieved by this action's post job execution. + * + * @param name name of the state to store + * @param value value to store + */ +function saveState(name, value) { + command_1.issueCommand('save-state', { name }, value); +} +exports.saveState = saveState; +/** + * Gets the value of an state set by this action's main execution. + * + * @param name name of the state to get + * @returns string + */ +function getState(name) { + return process.env[`STATE_${name}`] || ''; +} +exports.getState = getState; +//# sourceMappingURL=core.js.map + +/***/ }), + +/***/ 471: +/***/ (function(module, __unusedexports, __webpack_require__) { + +module.exports = authenticationBeforeRequest; + +const btoa = __webpack_require__(675); +const uniq = __webpack_require__(126); + +function authenticationBeforeRequest(state, options) { + if (!state.auth.type) { + return; + } + + if (state.auth.type === "basic") { + const hash = btoa(`${state.auth.username}:${state.auth.password}`); + options.headers.authorization = `Basic ${hash}`; + return; + } + + if (state.auth.type === "token") { + options.headers.authorization = `token ${state.auth.token}`; + return; + } + + if (state.auth.type === "app") { + options.headers.authorization = `Bearer ${state.auth.token}`; + const acceptHeaders = options.headers.accept + .split(",") + .concat("application/vnd.github.machine-man-preview+json"); + options.headers.accept = uniq(acceptHeaders) + .filter(Boolean) + .join(","); + return; + } + + options.url += options.url.indexOf("?") === -1 ? "?" : "&"; + + if (state.auth.token) { + options.url += `access_token=${encodeURIComponent(state.auth.token)}`; + return; + } + + const key = encodeURIComponent(state.auth.key); + const secret = encodeURIComponent(state.auth.secret); + options.url += `client_id=${key}&client_secret=${secret}`; +} + + +/***/ }), + +/***/ 478: +/***/ (function(__unusedmodule, exports, __webpack_require__) { + +"use strict"; + +// A configuration is an `Analytics` structure of its own. It will take +// the YAML configuration and parse it into an `AnalyticsConfig`. This +// will contain the literal definition from the configuration itself. +// By running the `evaluate` on the `Analytics`, it will take the input, +// including any queries, and execute them to produce a static `Analytics` +// structure with the actual values. +var __importStar = (this && this.__importStar) || function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k]; + result["default"] = mod; + return result; +}; +Object.defineProperty(exports, "__esModule", { value: true }); +const analytics_1 = __webpack_require__(847); +const yaml = __importStar(__webpack_require__(414)); +function configError(context, message) { + const location = context ? ` for ${context}` : ''; + throw new Error(`config: invalid configuration${location}: ${message}`); +} +function configValue(config, context, key, required = false) { + if (!(key in config) && required) { + configError(context, `missing required option '${key}'`); + } + let value = config[key]; + delete config[key]; + return value; +} +function ensureConfigEmpty(config, context) { + var remaining = Object.keys(config); + if (remaining.length != 0) { + configError(context, `unexpected option '${remaining[0]}'`); + } +} +function keyList(keys, andor) { + let result = new Array(); + for (let i = 0; i < keys.length; i++) { + if (i == keys.length - 1) { + result.push(` ${andor} `); + } + else if (i > 0) { + result.push(', '); + } + result.push(`'${keys[i]}'`); + } + return result.join(''); +} +function ensureOneConfigKey(config, context, keys) { + let found = new Array(); + for (let key of keys) { + if (key in config) { + found.push(key); + } + } + if (found.length == 0) { + configError(context, `expected one of: ${keyList(keys, 'or')}`); + } + if (found.length > 1) { + configError(context, `expected only one of: ${keyList(found, 'or')}`); + } +} +class AnalyticsConfig extends analytics_1.Analytics { + constructor(title, description, sections, output, setup, shutdown) { + super(title, description, sections, setup, shutdown); + this.output = output; + } + static loadStringWidget(config) { + let widget; + if (typeof config == 'string') { + config = { value: config }; + } + ensureOneConfigKey(config, 'string widget', ['value', 'script']); + let title = configValue(config, 'string widget', 'title'); + let url = configValue(config, 'string widget', 'url'); + let color = configValue(config, 'string widget', 'color'); + let align = configValue(config, 'string widget', 'align'); + let value = configValue(config, 'string widget', 'value'); + let script = configValue(config, 'string widget', 'script'); + if (script != null) { + widget = new analytics_1.ScriptStringWidget(title, url, script, align, color); + } + else if (value != null) { + widget = new analytics_1.StringWidget(title, url, value, align, color); + } + else { + throw new Error(); + } + ensureConfigEmpty(config, 'string widget'); + return widget; + } + static loadNumberWidget(config) { + let widget; + ensureOneConfigKey(config, 'number widget', ['issue_query', 'value', 'script']); + let title = configValue(config, 'number widget', 'title'); + let url = configValue(config, 'number widget', 'url'); + let color = configValue(config, 'number widget', 'color'); + let value = configValue(config, 'number widget', 'value'); + let script = configValue(config, 'number widget', 'script'); + let query = configValue(config, 'number widget', 'issue_query'); + let query_type = 0 /* Issue */; + if (query != null) { + widget = new analytics_1.QueryNumberWidget(title, url, query_type, query, color); + } + else if (script != null) { + widget = new analytics_1.ScriptNumberWidget(title, url, script, color); + } + else if (value != null) { + widget = new analytics_1.NumberWidget(title, url, value, color); + } + else { + throw new Error(); + } + ensureConfigEmpty(config, 'number widget'); + return widget; + } + static loadGraphWidget(config) { + let widgets = new Array(); + let title = configValue(config, 'graph widget', 'title'); + let url = configValue(config, 'graph widget', 'url'); + let elements = configValue(config, 'graph widget', 'elements', true); + for (let element of elements) { + ensureOneConfigKey(element, 'graph widget element', ['issue_query', 'value']); + let title = configValue(element, 'graph widget element', 'title'); + let url = configValue(element, 'graph widget element', 'url'); + let color = configValue(element, 'graph widget element', 'color'); + let query = configValue(element, 'graph widget element', 'issue_query'); + let query_type = 0 /* Issue */; + let value = configValue(element, 'graph widget element', 'value'); + if (query != null) { + widgets.push(new analytics_1.QueryNumberWidget(title, url, query_type, query, color)); + } + else if (value != null) { + widgets.push(new analytics_1.NumberWidget(title, url, value, color)); + } + ensureConfigEmpty(element, 'graph widget element'); + } + ensureConfigEmpty(config, 'graph widget'); + return new analytics_1.GraphWidget(title, url, widgets); + } + static loadQueryTableWidget(config) { + let title = configValue(config, 'table widget', 'title'); + let url = configValue(config, 'table widget', 'url'); + let fields = configValue(config, 'table widget', 'fields'); + let query = configValue(config, 'table widget', 'issue_query', true); + let limit = configValue(config, 'table widget', 'limit'); + let query_type = 0 /* Issue */; + if (fields != null && !Array.isArray(fields)) { + configError('table widget', `'fields' is not an array`); + } + return new analytics_1.QueryTableWidget(title, url, query_type, query, limit, fields); + } + static loadStaticTableWidget(config) { + const headers = new Array(); + const elements = new Array(); + let title = configValue(config, 'table widget', 'title'); + let url = configValue(config, 'table widget', 'url'); + let headerConfig = configValue(config, 'table widget', 'headers'); + let elementsConfig = configValue(config, 'table widget', 'elements', true); + if (headerConfig != null && Array.isArray(headerConfig)) { + for (let header of headerConfig) { + headers.push(AnalyticsConfig.loadStringWidget(header)); + } + } + else if (headerConfig != null) { + headers.push(AnalyticsConfig.loadStringWidget(headerConfig)); + } + if (elementsConfig != null && !Array.isArray(elementsConfig)) { + configError('table widget', `'elements' is not an array`); + } + for (let elementList of elementsConfig) { + if (Array.isArray(elementList)) { + let row = new Array(); + for (let element of elementList) { + row.push(AnalyticsConfig.loadStringWidget(element)); + } + elements.push(row); + } + else { + elements.push([AnalyticsConfig.loadStringWidget(elementList)]); + } + } + return new analytics_1.TableWidget(title, url, headers, elements); + } + static loadTableWidget(config) { + let widget; + ensureOneConfigKey(config, 'table widget', ['issue_query', 'elements']); + if (config.issue_query != null) { + widget = AnalyticsConfig.loadQueryTableWidget(config); + } + else { + widget = AnalyticsConfig.loadStaticTableWidget(config); + } + ensureConfigEmpty(config, 'table widget'); + return widget; + } + static loadWidget(config) { + let widget; + let type = configValue(config, 'widget', 'type', true); + if (type == 'number') { + widget = AnalyticsConfig.loadNumberWidget(config); + } + else if (type == 'string') { + widget = AnalyticsConfig.loadStringWidget(config); + } + else if (type == 'graph') { + widget = AnalyticsConfig.loadGraphWidget(config); + } + else if (type == 'table') { + widget = AnalyticsConfig.loadTableWidget(config); + } + else { + configError('widget', `invalid type '${type}'`); + } + ensureConfigEmpty(config, 'widget'); + return widget; + } + static loadSection(config) { + const widgets = new Array(); + let title = configValue(config, 'section', 'title'); + let description = configValue(config, 'section', 'description'); + let widgetConfig = configValue(config, 'section', 'widgets'); + if (widgetConfig != null) { + if (!Array.isArray(widgetConfig)) { + configError('section', `'widgets' is not an array`); + } + for (let wc of widgetConfig) { + widgets.push(AnalyticsConfig.loadWidget(wc)); + } + } + ensureConfigEmpty(config, 'section'); + return new analytics_1.Section(title, description, widgets); + } + static loadOutput(config) { + let output = {}; + if (!('format' in config)) { + throw new Error(`config: 'output.format' is not defined`); + } + for (let key in config) { + output[key] = config[key]; + } + return output; + } + static load(config) { + const sections = new Array(); + let title = configValue(config, null, 'title'); + let description = configValue(config, null, 'description'); + let setup = configValue(config, null, 'setup'); + let shutdown = configValue(config, null, 'shutdown'); + let outputConfig = configValue(config, null, 'output', true); + let sectionConfig = configValue(config, null, 'sections'); + if (sectionConfig != null) { + if (!Array.isArray(sectionConfig)) { + configError(null, `'sections' is not an array`); + } + for (let section of sectionConfig) { + sections.push(AnalyticsConfig.loadSection(section)); + } + } + let output = AnalyticsConfig.loadOutput(outputConfig); + ensureConfigEmpty(config, null); + return new AnalyticsConfig(title, description, sections, output, setup, shutdown); + } + static fromJson(config) { + return AnalyticsConfig.load(JSON.parse(config)); + } + static fromYaml(config) { + return AnalyticsConfig.load(yaml.safeLoad(config)); + } + static from(config) { + let ConfigFormat; + (function (ConfigFormat) { + ConfigFormat[ConfigFormat["JSON"] = 0] = "JSON"; + ConfigFormat[ConfigFormat["YAML"] = 1] = "YAML"; + })(ConfigFormat || (ConfigFormat = {})); + let format; + let input; + try { + input = JSON.parse(config); + format = ConfigFormat.JSON; + } + catch (e) { + input = yaml.safeLoad(config); + format = ConfigFormat.YAML; + } + if (format == ConfigFormat.JSON) { + return AnalyticsConfig.load(input); + } + else { + return AnalyticsConfig.load(input); + } + } +} +exports.AnalyticsConfig = AnalyticsConfig; + + +/***/ }), + +/***/ 489: +/***/ (function(module, __unusedexports, __webpack_require__) { + +"use strict"; + + +const path = __webpack_require__(622); +const which = __webpack_require__(814); +const pathKey = __webpack_require__(39)(); + +function resolveCommandAttempt(parsed, withoutPathExt) { + const cwd = process.cwd(); + const hasCustomCwd = parsed.options.cwd != null; + + // If a custom `cwd` was specified, we need to change the process cwd + // because `which` will do stat calls but does not support a custom cwd + if (hasCustomCwd) { + try { + process.chdir(parsed.options.cwd); + } catch (err) { + /* Empty */ + } + } + + let resolved; + + try { + resolved = which.sync(parsed.command, { + path: (parsed.options.env || process.env)[pathKey], + pathExt: withoutPathExt ? path.delimiter : undefined, + }); + } catch (e) { + /* Empty */ + } finally { + process.chdir(cwd); + } + + // If we successfully resolved, ensure that an absolute path is returned + // Note that when a custom `cwd` was used, we need to resolve to an absolute path based on it + if (resolved) { + resolved = path.resolve(hasCustomCwd ? parsed.options.cwd : '', resolved); + } + + return resolved; +} + +function resolveCommand(parsed) { + return resolveCommandAttempt(parsed) || resolveCommandAttempt(parsed, true); +} + +module.exports = resolveCommand; + + +/***/ }), + +/***/ 497: +/***/ (function(__unusedmodule, exports, __webpack_require__) { + +"use strict"; + + +Object.defineProperty(exports, '__esModule', { value: true }); + +function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; } + +var deprecation = __webpack_require__(692); +var once = _interopDefault(__webpack_require__(969)); + +const logOnce = once(deprecation => console.warn(deprecation)); +/** + * Error with extra properties to help with debugging + */ + +class RequestError extends Error { + constructor(message, statusCode, options) { + super(message); // Maintains proper stack trace (only available on V8) + + /* istanbul ignore next */ + + if (Error.captureStackTrace) { + Error.captureStackTrace(this, this.constructor); + } + + this.name = "HttpError"; + this.status = statusCode; + Object.defineProperty(this, "code", { + get() { + logOnce(new deprecation.Deprecation("[@octokit/request-error] `error.code` is deprecated, use `error.status`.")); + return statusCode; + } + + }); + this.headers = options.headers || {}; // redact request credentials without mutating original request options + + const requestCopy = Object.assign({}, options.request); + + if (options.request.headers.authorization) { + requestCopy.headers = Object.assign({}, options.request.headers, { + authorization: options.request.headers.authorization.replace(/ .*$/, " [REDACTED]") + }); + } + + requestCopy.url = requestCopy.url // client_id & client_secret can be passed as URL query parameters to increase rate limit + // see https://developer.github.com/v3/#increasing-the-unauthenticated-rate-limit-for-oauth-applications + .replace(/\bclient_secret=\w+/g, "client_secret=[REDACTED]") // OAuth tokens can be passed as URL query parameters, although it is not recommended + // see https://developer.github.com/v3/#oauth2-token-sent-in-a-header + .replace(/\baccess_token=\w+/g, "access_token=[REDACTED]"); + this.request = requestCopy; + } + +} + +exports.RequestError = RequestError; +//# sourceMappingURL=index.js.map + + +/***/ }), + +/***/ 499: +/***/ (function(module) { + +!function(t,n){ true?module.exports=n():undefined}(this,function(){"use strict";var t,n=/(\[[^[]*\])|([-:/.()\s]+)|(A|a|YYYY|YY?|MM?M?M?|Do|DD?|hh?|HH?|mm?|ss?|S{1,3}|z|ZZ?)/g,e=/\d\d/,o=/\d\d?/,r=/\d*[^\s\d-:/.()]+/;var s=function(t){return function(n){this[t]=+n}},i=[/[+-]\d\d:?\d\d/,function(t){var n,e;(this.zone||(this.zone={})).offset=(n=t.match(/([+-]|\d\d)/g),0===(e=60*n[1]+ +n[2])?0:"+"===n[0]?-e:e)}],a={A:[/[AP]M/,function(t){this.afternoon="PM"===t}],a:[/[ap]m/,function(t){this.afternoon="pm"===t}],S:[/\d/,function(t){this.milliseconds=100*+t}],SS:[e,function(t){this.milliseconds=10*+t}],SSS:[/\d{3}/,function(t){this.milliseconds=+t}],s:[o,s("seconds")],ss:[o,s("seconds")],m:[o,s("minutes")],mm:[o,s("minutes")],H:[o,s("hours")],h:[o,s("hours")],HH:[o,s("hours")],hh:[o,s("hours")],D:[o,s("day")],DD:[e,s("day")],Do:[r,function(n){var e=t.ordinal,o=n.match(/\d+/);if(this.day=o[0],e)for(var r=1;r<=31;r+=1)e(r).replace(/\[|\]/g,"")===n&&(this.day=r)}],M:[o,s("month")],MM:[e,s("month")],MMM:[r,function(n){var e=t,o=e.months,r=e.monthsShort,s=r?r.findIndex(function(t){return t===n}):o.findIndex(function(t){return t.substr(0,3)===n});if(s<0)throw new Error;this.month=s+1}],MMMM:[r,function(n){var e=t.months.indexOf(n);if(e<0)throw new Error;this.month=e+1}],Y:[/[+-]?\d+/,s("year")],YY:[e,function(t){t=+t,this.year=t+(t>68?1900:2e3)}],YYYY:[/\d{4}/,s("year")],Z:i,ZZ:i};var u=function(t,e,o){try{var r=function(t){for(var e=t.match(n),o=e.length,r=0;r0?i-1:l.getMonth());var y=f||0,D=h||0,Y=d||0,g=c||0;return m?new Date(Date.UTC(p,M,v,y,D,Y,g+60*m.offset*1e3)):o?new Date(Date.UTC(p,M,v,y,D,Y,g)):new Date(p,M,v,y,D,Y,g)}catch(t){return new Date("")}};return function(n,e,o){var r=e.prototype,s=r.parse;r.parse=function(n){var e=n.date,r=n.format,i=n.pl,a=n.utc;this.$u=a,r?(t=i?o.Ls[i]:this.$locale(),this.$d=u(e,r,a),this.init(n),i&&(this.$L=i)):s.call(this,n)}}}); + + +/***/ }), + +/***/ 510: +/***/ (function(module) { + +module.exports = addHook + +function addHook (state, kind, name, hook) { + var orig = hook + if (!state.registry[name]) { + state.registry[name] = [] + } + + if (kind === 'before') { + hook = function (method, options) { + return Promise.resolve() + .then(orig.bind(null, options)) + .then(method.bind(null, options)) + } + } + + if (kind === 'after') { + hook = function (method, options) { + var result + return Promise.resolve() + .then(method.bind(null, options)) + .then(function (result_) { + result = result_ + return orig(result, options) + }) + .then(function () { + return result + }) + } + } + + if (kind === 'error') { + hook = function (method, options) { + return Promise.resolve() + .then(method.bind(null, options)) + .catch(function (error) { + return orig(error, options) + }) + } + } + + state.registry[name].push({ + hook: hook, + orig: orig + }) +} + + +/***/ }), + +/***/ 523: +/***/ (function(module, __unusedexports, __webpack_require__) { + +var register = __webpack_require__(363) +var addHook = __webpack_require__(510) +var removeHook = __webpack_require__(763) + +// bind with array of arguments: https://stackoverflow.com/a/21792913 +var bind = Function.bind +var bindable = bind.bind(bind) + +function bindApi (hook, state, name) { + var removeHookRef = bindable(removeHook, null).apply(null, name ? [state, name] : [state]) + hook.api = { remove: removeHookRef } + hook.remove = removeHookRef + + ;['before', 'error', 'after', 'wrap'].forEach(function (kind) { + var args = name ? [state, kind, name] : [state, kind] + hook[kind] = hook.api[kind] = bindable(addHook, null).apply(null, args) + }) +} + +function HookSingular () { + var singularHookName = 'h' + var singularHookState = { + registry: {} + } + var singularHook = register.bind(null, singularHookState, singularHookName) + bindApi(singularHook, singularHookState, singularHookName) + return singularHook +} + +function HookCollection () { + var state = { + registry: {} + } + + var hook = register.bind(null, state) + bindApi(hook, state) + + return hook +} + +var collectionHookDeprecationMessageDisplayed = false +function Hook () { + if (!collectionHookDeprecationMessageDisplayed) { + console.warn('[before-after-hook]: "Hook()" repurposing warning, use "Hook.Collection()". Read more: https://git.io/upgrade-before-after-hook-to-1.4') + collectionHookDeprecationMessageDisplayed = true + } + return HookCollection() +} + +Hook.Singular = HookSingular.bind() +Hook.Collection = HookCollection.bind() + +module.exports = Hook +// expose constructors as a named property for TypeScript +module.exports.Hook = Hook +module.exports.Singular = Hook.Singular +module.exports.Collection = Hook.Collection + + +/***/ }), + +/***/ 529: +/***/ (function(module, __unusedexports, __webpack_require__) { + +const factory = __webpack_require__(47); + +module.exports = factory(); + + +/***/ }), + +/***/ 536: +/***/ (function(module, __unusedexports, __webpack_require__) { + +module.exports = hasFirstPage + +const deprecate = __webpack_require__(370) +const getPageLinks = __webpack_require__(577) + +function hasFirstPage (link) { + deprecate(`octokit.hasFirstPage() – You can use octokit.paginate or async iterators instead: https://github.com/octokit/rest.js#pagination.`) + return getPageLinks(link).first +} + + +/***/ }), + +/***/ 539: +/***/ (function(__unusedmodule, exports, __webpack_require__) { + +"use strict"; + +Object.defineProperty(exports, "__esModule", { value: true }); +const url = __webpack_require__(835); +const http = __webpack_require__(605); +const https = __webpack_require__(34); +const pm = __webpack_require__(950); +let tunnel; +var HttpCodes; +(function (HttpCodes) { + HttpCodes[HttpCodes["OK"] = 200] = "OK"; + HttpCodes[HttpCodes["MultipleChoices"] = 300] = "MultipleChoices"; + HttpCodes[HttpCodes["MovedPermanently"] = 301] = "MovedPermanently"; + HttpCodes[HttpCodes["ResourceMoved"] = 302] = "ResourceMoved"; + HttpCodes[HttpCodes["SeeOther"] = 303] = "SeeOther"; + HttpCodes[HttpCodes["NotModified"] = 304] = "NotModified"; + HttpCodes[HttpCodes["UseProxy"] = 305] = "UseProxy"; + HttpCodes[HttpCodes["SwitchProxy"] = 306] = "SwitchProxy"; + HttpCodes[HttpCodes["TemporaryRedirect"] = 307] = "TemporaryRedirect"; + HttpCodes[HttpCodes["PermanentRedirect"] = 308] = "PermanentRedirect"; + HttpCodes[HttpCodes["BadRequest"] = 400] = "BadRequest"; + HttpCodes[HttpCodes["Unauthorized"] = 401] = "Unauthorized"; + HttpCodes[HttpCodes["PaymentRequired"] = 402] = "PaymentRequired"; + HttpCodes[HttpCodes["Forbidden"] = 403] = "Forbidden"; + HttpCodes[HttpCodes["NotFound"] = 404] = "NotFound"; + HttpCodes[HttpCodes["MethodNotAllowed"] = 405] = "MethodNotAllowed"; + HttpCodes[HttpCodes["NotAcceptable"] = 406] = "NotAcceptable"; + HttpCodes[HttpCodes["ProxyAuthenticationRequired"] = 407] = "ProxyAuthenticationRequired"; + HttpCodes[HttpCodes["RequestTimeout"] = 408] = "RequestTimeout"; + HttpCodes[HttpCodes["Conflict"] = 409] = "Conflict"; + HttpCodes[HttpCodes["Gone"] = 410] = "Gone"; + HttpCodes[HttpCodes["TooManyRequests"] = 429] = "TooManyRequests"; + HttpCodes[HttpCodes["InternalServerError"] = 500] = "InternalServerError"; + HttpCodes[HttpCodes["NotImplemented"] = 501] = "NotImplemented"; + HttpCodes[HttpCodes["BadGateway"] = 502] = "BadGateway"; + HttpCodes[HttpCodes["ServiceUnavailable"] = 503] = "ServiceUnavailable"; + HttpCodes[HttpCodes["GatewayTimeout"] = 504] = "GatewayTimeout"; +})(HttpCodes = exports.HttpCodes || (exports.HttpCodes = {})); +var Headers; +(function (Headers) { + Headers["Accept"] = "accept"; + Headers["ContentType"] = "content-type"; +})(Headers = exports.Headers || (exports.Headers = {})); +var MediaTypes; +(function (MediaTypes) { + MediaTypes["ApplicationJson"] = "application/json"; +})(MediaTypes = exports.MediaTypes || (exports.MediaTypes = {})); +/** + * Returns the proxy URL, depending upon the supplied url and proxy environment variables. + * @param serverUrl The server URL where the request will be sent. For example, https://api.github.com + */ +function getProxyUrl(serverUrl) { + let proxyUrl = pm.getProxyUrl(url.parse(serverUrl)); + return proxyUrl ? proxyUrl.href : ''; +} +exports.getProxyUrl = getProxyUrl; +const HttpRedirectCodes = [HttpCodes.MovedPermanently, HttpCodes.ResourceMoved, HttpCodes.SeeOther, HttpCodes.TemporaryRedirect, HttpCodes.PermanentRedirect]; +const HttpResponseRetryCodes = [HttpCodes.BadGateway, HttpCodes.ServiceUnavailable, HttpCodes.GatewayTimeout]; +const RetryableHttpVerbs = ['OPTIONS', 'GET', 'DELETE', 'HEAD']; +const ExponentialBackoffCeiling = 10; +const ExponentialBackoffTimeSlice = 5; +class HttpClientResponse { + constructor(message) { + this.message = message; + } + readBody() { + return new Promise(async (resolve, reject) => { + let output = Buffer.alloc(0); + this.message.on('data', (chunk) => { + output = Buffer.concat([output, chunk]); + }); + this.message.on('end', () => { + resolve(output.toString()); + }); + }); + } +} +exports.HttpClientResponse = HttpClientResponse; +function isHttps(requestUrl) { + let parsedUrl = url.parse(requestUrl); + return parsedUrl.protocol === 'https:'; +} +exports.isHttps = isHttps; +class HttpClient { + constructor(userAgent, handlers, requestOptions) { + this._ignoreSslError = false; + this._allowRedirects = true; + this._allowRedirectDowngrade = false; + this._maxRedirects = 50; + this._allowRetries = false; + this._maxRetries = 1; + this._keepAlive = false; + this._disposed = false; + this.userAgent = userAgent; + this.handlers = handlers || []; + this.requestOptions = requestOptions; + if (requestOptions) { + if (requestOptions.ignoreSslError != null) { + this._ignoreSslError = requestOptions.ignoreSslError; + } + this._socketTimeout = requestOptions.socketTimeout; + if (requestOptions.allowRedirects != null) { + this._allowRedirects = requestOptions.allowRedirects; + } + if (requestOptions.allowRedirectDowngrade != null) { + this._allowRedirectDowngrade = requestOptions.allowRedirectDowngrade; + } + if (requestOptions.maxRedirects != null) { + this._maxRedirects = Math.max(requestOptions.maxRedirects, 0); + } + if (requestOptions.keepAlive != null) { + this._keepAlive = requestOptions.keepAlive; + } + if (requestOptions.allowRetries != null) { + this._allowRetries = requestOptions.allowRetries; + } + if (requestOptions.maxRetries != null) { + this._maxRetries = requestOptions.maxRetries; + } + } + } + options(requestUrl, additionalHeaders) { + return this.request('OPTIONS', requestUrl, null, additionalHeaders || {}); + } + get(requestUrl, additionalHeaders) { + return this.request('GET', requestUrl, null, additionalHeaders || {}); + } + del(requestUrl, additionalHeaders) { + return this.request('DELETE', requestUrl, null, additionalHeaders || {}); + } + post(requestUrl, data, additionalHeaders) { + return this.request('POST', requestUrl, data, additionalHeaders || {}); + } + patch(requestUrl, data, additionalHeaders) { + return this.request('PATCH', requestUrl, data, additionalHeaders || {}); + } + put(requestUrl, data, additionalHeaders) { + return this.request('PUT', requestUrl, data, additionalHeaders || {}); + } + head(requestUrl, additionalHeaders) { + return this.request('HEAD', requestUrl, null, additionalHeaders || {}); + } + sendStream(verb, requestUrl, stream, additionalHeaders) { + return this.request(verb, requestUrl, stream, additionalHeaders); + } + /** + * Gets a typed object from an endpoint + * Be aware that not found returns a null. Other errors (4xx, 5xx) reject the promise + */ + async getJson(requestUrl, additionalHeaders = {}) { + additionalHeaders[Headers.Accept] = this._getExistingOrDefaultHeader(additionalHeaders, Headers.Accept, MediaTypes.ApplicationJson); + let res = await this.get(requestUrl, additionalHeaders); + return this._processResponse(res, this.requestOptions); + } + async postJson(requestUrl, obj, additionalHeaders = {}) { + let data = JSON.stringify(obj, null, 2); + additionalHeaders[Headers.Accept] = this._getExistingOrDefaultHeader(additionalHeaders, Headers.Accept, MediaTypes.ApplicationJson); + additionalHeaders[Headers.ContentType] = this._getExistingOrDefaultHeader(additionalHeaders, Headers.ContentType, MediaTypes.ApplicationJson); + let res = await this.post(requestUrl, data, additionalHeaders); + return this._processResponse(res, this.requestOptions); + } + async putJson(requestUrl, obj, additionalHeaders = {}) { + let data = JSON.stringify(obj, null, 2); + additionalHeaders[Headers.Accept] = this._getExistingOrDefaultHeader(additionalHeaders, Headers.Accept, MediaTypes.ApplicationJson); + additionalHeaders[Headers.ContentType] = this._getExistingOrDefaultHeader(additionalHeaders, Headers.ContentType, MediaTypes.ApplicationJson); + let res = await this.put(requestUrl, data, additionalHeaders); + return this._processResponse(res, this.requestOptions); + } + async patchJson(requestUrl, obj, additionalHeaders = {}) { + let data = JSON.stringify(obj, null, 2); + additionalHeaders[Headers.Accept] = this._getExistingOrDefaultHeader(additionalHeaders, Headers.Accept, MediaTypes.ApplicationJson); + additionalHeaders[Headers.ContentType] = this._getExistingOrDefaultHeader(additionalHeaders, Headers.ContentType, MediaTypes.ApplicationJson); + let res = await this.patch(requestUrl, data, additionalHeaders); + return this._processResponse(res, this.requestOptions); + } + /** + * Makes a raw http request. + * All other methods such as get, post, patch, and request ultimately call this. + * Prefer get, del, post and patch + */ + async request(verb, requestUrl, data, headers) { + if (this._disposed) { + throw new Error("Client has already been disposed."); + } + let parsedUrl = url.parse(requestUrl); + let info = this._prepareRequest(verb, parsedUrl, headers); + // Only perform retries on reads since writes may not be idempotent. + let maxTries = (this._allowRetries && RetryableHttpVerbs.indexOf(verb) != -1) ? this._maxRetries + 1 : 1; + let numTries = 0; + let response; + while (numTries < maxTries) { + response = await this.requestRaw(info, data); + // Check if it's an authentication challenge + if (response && response.message && response.message.statusCode === HttpCodes.Unauthorized) { + let authenticationHandler; + for (let i = 0; i < this.handlers.length; i++) { + if (this.handlers[i].canHandleAuthentication(response)) { + authenticationHandler = this.handlers[i]; + break; + } + } + if (authenticationHandler) { + return authenticationHandler.handleAuthentication(this, info, data); + } + else { + // We have received an unauthorized response but have no handlers to handle it. + // Let the response return to the caller. + return response; + } + } + let redirectsRemaining = this._maxRedirects; + while (HttpRedirectCodes.indexOf(response.message.statusCode) != -1 + && this._allowRedirects + && redirectsRemaining > 0) { + const redirectUrl = response.message.headers["location"]; + if (!redirectUrl) { + // if there's no location to redirect to, we won't + break; + } + let parsedRedirectUrl = url.parse(redirectUrl); + if (parsedUrl.protocol == 'https:' && parsedUrl.protocol != parsedRedirectUrl.protocol && !this._allowRedirectDowngrade) { + throw new Error("Redirect from HTTPS to HTTP protocol. This downgrade is not allowed for security reasons. If you want to allow this behavior, set the allowRedirectDowngrade option to true."); + } + // we need to finish reading the response before reassigning response + // which will leak the open socket. + await response.readBody(); + // let's make the request with the new redirectUrl + info = this._prepareRequest(verb, parsedRedirectUrl, headers); + response = await this.requestRaw(info, data); + redirectsRemaining--; + } + if (HttpResponseRetryCodes.indexOf(response.message.statusCode) == -1) { + // If not a retry code, return immediately instead of retrying + return response; + } + numTries += 1; + if (numTries < maxTries) { + await response.readBody(); + await this._performExponentialBackoff(numTries); + } + } + return response; + } + /** + * Needs to be called if keepAlive is set to true in request options. + */ + dispose() { + if (this._agent) { + this._agent.destroy(); + } + this._disposed = true; + } + /** + * Raw request. + * @param info + * @param data + */ + requestRaw(info, data) { + return new Promise((resolve, reject) => { + let callbackForResult = function (err, res) { + if (err) { + reject(err); + } + resolve(res); + }; + this.requestRawWithCallback(info, data, callbackForResult); + }); + } + /** + * Raw request with callback. + * @param info + * @param data + * @param onResult + */ + requestRawWithCallback(info, data, onResult) { + let socket; + if (typeof (data) === 'string') { + info.options.headers["Content-Length"] = Buffer.byteLength(data, 'utf8'); + } + let callbackCalled = false; + let handleResult = (err, res) => { + if (!callbackCalled) { + callbackCalled = true; + onResult(err, res); + } + }; + let req = info.httpModule.request(info.options, (msg) => { + let res = new HttpClientResponse(msg); + handleResult(null, res); + }); + req.on('socket', (sock) => { + socket = sock; + }); + // If we ever get disconnected, we want the socket to timeout eventually + req.setTimeout(this._socketTimeout || 3 * 60000, () => { + if (socket) { + socket.end(); + } + handleResult(new Error('Request timeout: ' + info.options.path), null); + }); + req.on('error', function (err) { + // err has statusCode property + // res should have headers + handleResult(err, null); + }); + if (data && typeof (data) === 'string') { + req.write(data, 'utf8'); + } + if (data && typeof (data) !== 'string') { + data.on('close', function () { + req.end(); + }); + data.pipe(req); + } + else { + req.end(); + } + } + /** + * Gets an http agent. This function is useful when you need an http agent that handles + * routing through a proxy server - depending upon the url and proxy environment variables. + * @param serverUrl The server URL where the request will be sent. For example, https://api.github.com + */ + getAgent(serverUrl) { + let parsedUrl = url.parse(serverUrl); + return this._getAgent(parsedUrl); + } + _prepareRequest(method, requestUrl, headers) { + const info = {}; + info.parsedUrl = requestUrl; + const usingSsl = info.parsedUrl.protocol === 'https:'; + info.httpModule = usingSsl ? https : http; + const defaultPort = usingSsl ? 443 : 80; + info.options = {}; + info.options.host = info.parsedUrl.hostname; + info.options.port = info.parsedUrl.port ? parseInt(info.parsedUrl.port) : defaultPort; + info.options.path = (info.parsedUrl.pathname || '') + (info.parsedUrl.search || ''); + info.options.method = method; + info.options.headers = this._mergeHeaders(headers); + if (this.userAgent != null) { + info.options.headers["user-agent"] = this.userAgent; + } + info.options.agent = this._getAgent(info.parsedUrl); + // gives handlers an opportunity to participate + if (this.handlers) { + this.handlers.forEach((handler) => { + handler.prepareRequest(info.options); + }); + } + return info; + } + _mergeHeaders(headers) { + const lowercaseKeys = obj => Object.keys(obj).reduce((c, k) => (c[k.toLowerCase()] = obj[k], c), {}); + if (this.requestOptions && this.requestOptions.headers) { + return Object.assign({}, lowercaseKeys(this.requestOptions.headers), lowercaseKeys(headers)); + } + return lowercaseKeys(headers || {}); + } + _getExistingOrDefaultHeader(additionalHeaders, header, _default) { + const lowercaseKeys = obj => Object.keys(obj).reduce((c, k) => (c[k.toLowerCase()] = obj[k], c), {}); + let clientHeader; + if (this.requestOptions && this.requestOptions.headers) { + clientHeader = lowercaseKeys(this.requestOptions.headers)[header]; + } + return additionalHeaders[header] || clientHeader || _default; + } + _getAgent(parsedUrl) { + let agent; + let proxyUrl = pm.getProxyUrl(parsedUrl); + let useProxy = proxyUrl && proxyUrl.hostname; + if (this._keepAlive && useProxy) { + agent = this._proxyAgent; + } + if (this._keepAlive && !useProxy) { + agent = this._agent; + } + // if agent is already assigned use that agent. + if (!!agent) { + return agent; + } + const usingSsl = parsedUrl.protocol === 'https:'; + let maxSockets = 100; + if (!!this.requestOptions) { + maxSockets = this.requestOptions.maxSockets || http.globalAgent.maxSockets; + } + if (useProxy) { + // If using proxy, need tunnel + if (!tunnel) { + tunnel = __webpack_require__(856); + } + const agentOptions = { + maxSockets: maxSockets, + keepAlive: this._keepAlive, + proxy: { + proxyAuth: proxyUrl.auth, + host: proxyUrl.hostname, + port: proxyUrl.port + }, + }; + let tunnelAgent; + const overHttps = proxyUrl.protocol === 'https:'; + if (usingSsl) { + tunnelAgent = overHttps ? tunnel.httpsOverHttps : tunnel.httpsOverHttp; + } + else { + tunnelAgent = overHttps ? tunnel.httpOverHttps : tunnel.httpOverHttp; + } + agent = tunnelAgent(agentOptions); + this._proxyAgent = agent; + } + // if reusing agent across request and tunneling agent isn't assigned create a new agent + if (this._keepAlive && !agent) { + const options = { keepAlive: this._keepAlive, maxSockets: maxSockets }; + agent = usingSsl ? new https.Agent(options) : new http.Agent(options); + this._agent = agent; + } + // if not using private agent and tunnel agent isn't setup then use global agent + if (!agent) { + agent = usingSsl ? https.globalAgent : http.globalAgent; + } + if (usingSsl && this._ignoreSslError) { + // we don't want to set NODE_TLS_REJECT_UNAUTHORIZED=0 since that will affect request for entire process + // http.RequestOptions doesn't expose a way to modify RequestOptions.agent.options + // we have to cast it to any and change it directly + agent.options = Object.assign(agent.options || {}, { rejectUnauthorized: false }); + } + return agent; + } + _performExponentialBackoff(retryNumber) { + retryNumber = Math.min(ExponentialBackoffCeiling, retryNumber); + const ms = ExponentialBackoffTimeSlice * Math.pow(2, retryNumber); + return new Promise(resolve => setTimeout(() => resolve(), ms)); + } + static dateTimeDeserializer(key, value) { + if (typeof value === 'string') { + let a = new Date(value); + if (!isNaN(a.valueOf())) { + return a; + } + } + return value; + } + async _processResponse(res, options) { + return new Promise(async (resolve, reject) => { + const statusCode = res.message.statusCode; + const response = { + statusCode: statusCode, + result: null, + headers: {} + }; + // not found leads to null obj returned + if (statusCode == HttpCodes.NotFound) { + resolve(response); + } + let obj; + let contents; + // get the result from the body + try { + contents = await res.readBody(); + if (contents && contents.length > 0) { + if (options && options.deserializeDates) { + obj = JSON.parse(contents, HttpClient.dateTimeDeserializer); + } + else { + obj = JSON.parse(contents); + } + response.result = obj; + } + response.headers = res.message.headers; + } + catch (err) { + // Invalid resource (contents not json); leaving result obj null + } + // note that 3xx redirects are handled by the http layer. + if (statusCode > 299) { + let msg; + // if exception/error in body, attempt to get better error + if (obj && obj.message) { + msg = obj.message; + } + else if (contents && contents.length > 0) { + // it may be the case that the exception is in the body message as string + msg = contents; + } + else { + msg = "Failed request: (" + statusCode + ")"; + } + let err = new Error(msg); + // attach statusCode and body obj (if available) to the error object + err['statusCode'] = statusCode; + if (response.result) { + err['result'] = response.result; + } + reject(err); + } + else { + resolve(response); + } + }); + } +} +exports.HttpClient = HttpClient; + + +/***/ }), + +/***/ 550: +/***/ (function(module, __unusedexports, __webpack_require__) { + +module.exports = getNextPage + +const getPage = __webpack_require__(265) + +function getNextPage (octokit, link, headers) { + return getPage(octokit, link, 'next', headers) +} + + +/***/ }), + +/***/ 556: +/***/ (function(module) { + +"use strict"; +// YAML error class. http://stackoverflow.com/questions/8458984 +// + + +function YAMLException(reason, mark) { + // Super constructor + Error.call(this); + + this.name = 'YAMLException'; + this.reason = reason; + this.mark = mark; + this.message = (this.reason || '(unknown reason)') + (this.mark ? ' ' + this.mark.toString() : ''); + + // Include stack trace in error object + if (Error.captureStackTrace) { + // Chrome and NodeJS + Error.captureStackTrace(this, this.constructor); + } else { + // FF, IE 10+ and Safari 6+. Fallback for others + this.stack = (new Error()).stack || ''; + } +} + + +// Inherit from Error +YAMLException.prototype = Object.create(Error.prototype); +YAMLException.prototype.constructor = YAMLException; + + +YAMLException.prototype.toString = function toString(compact) { + var result = this.name + ': '; + + result += this.reason || '(unknown reason)'; + + if (!compact && this.mark) { + result += ' ' + this.mark.toString(); + } + + return result; +}; + + +module.exports = YAMLException; + + +/***/ }), + +/***/ 558: +/***/ (function(module, __unusedexports, __webpack_require__) { + +module.exports = hasPreviousPage + +const deprecate = __webpack_require__(370) +const getPageLinks = __webpack_require__(577) + +function hasPreviousPage (link) { + deprecate(`octokit.hasPreviousPage() – You can use octokit.paginate or async iterators instead: https://github.com/octokit/rest.js#pagination.`) + return getPageLinks(link).prev +} + + +/***/ }), + +/***/ 562: +/***/ (function(__unusedmodule, exports, __webpack_require__) { + +"use strict"; + + +Object.defineProperty(exports, '__esModule', { value: true }); + +function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; } + +var osName = _interopDefault(__webpack_require__(2)); + +function getUserAgent() { + try { + return `Node.js/${process.version.substr(1)} (${osName()}; ${process.arch})`; + } catch (error) { + if (/wmic os get Caption/.test(error.message)) { + return "Windows "; + } + + return ""; + } +} + +exports.getUserAgent = getUserAgent; +//# sourceMappingURL=index.js.map + + +/***/ }), + +/***/ 563: +/***/ (function(module, __unusedexports, __webpack_require__) { + +module.exports = getPreviousPage + +const getPage = __webpack_require__(265) + +function getPreviousPage (octokit, link, headers) { + return getPage(octokit, link, 'prev', headers) +} + + +/***/ }), + +/***/ 568: +/***/ (function(module, __unusedexports, __webpack_require__) { + +"use strict"; + + +const path = __webpack_require__(622); +const niceTry = __webpack_require__(948); +const resolveCommand = __webpack_require__(489); +const escape = __webpack_require__(462); +const readShebang = __webpack_require__(389); +const semver = __webpack_require__(280); + +const isWin = process.platform === 'win32'; +const isExecutableRegExp = /\.(?:com|exe)$/i; +const isCmdShimRegExp = /node_modules[\\/].bin[\\/][^\\/]+\.cmd$/i; + +// `options.shell` is supported in Node ^4.8.0, ^5.7.0 and >= 6.0.0 +const supportsShellOption = niceTry(() => semver.satisfies(process.version, '^4.8.0 || ^5.7.0 || >= 6.0.0', true)) || false; + +function detectShebang(parsed) { + parsed.file = resolveCommand(parsed); + + const shebang = parsed.file && readShebang(parsed.file); + + if (shebang) { + parsed.args.unshift(parsed.file); + parsed.command = shebang; + + return resolveCommand(parsed); + } + + return parsed.file; +} + +function parseNonShell(parsed) { + if (!isWin) { + return parsed; + } + + // Detect & add support for shebangs + const commandFile = detectShebang(parsed); + + // We don't need a shell if the command filename is an executable + const needsShell = !isExecutableRegExp.test(commandFile); + + // If a shell is required, use cmd.exe and take care of escaping everything correctly + // Note that `forceShell` is an hidden option used only in tests + if (parsed.options.forceShell || needsShell) { + // Need to double escape meta chars if the command is a cmd-shim located in `node_modules/.bin/` + // The cmd-shim simply calls execute the package bin file with NodeJS, proxying any argument + // Because the escape of metachars with ^ gets interpreted when the cmd.exe is first called, + // we need to double escape them + const needsDoubleEscapeMetaChars = isCmdShimRegExp.test(commandFile); + + // Normalize posix paths into OS compatible paths (e.g.: foo/bar -> foo\bar) + // This is necessary otherwise it will always fail with ENOENT in those cases + parsed.command = path.normalize(parsed.command); + + // Escape command & arguments + parsed.command = escape.command(parsed.command); + parsed.args = parsed.args.map((arg) => escape.argument(arg, needsDoubleEscapeMetaChars)); + + const shellCommand = [parsed.command].concat(parsed.args).join(' '); + + parsed.args = ['/d', '/s', '/c', `"${shellCommand}"`]; + parsed.command = process.env.comspec || 'cmd.exe'; + parsed.options.windowsVerbatimArguments = true; // Tell node's spawn that the arguments are already escaped + } + + return parsed; +} + +function parseShell(parsed) { + // If node supports the shell option, there's no need to mimic its behavior + if (supportsShellOption) { + return parsed; + } + + // Mimic node shell option + // See https://github.com/nodejs/node/blob/b9f6a2dc059a1062776133f3d4fd848c4da7d150/lib/child_process.js#L335 + const shellCommand = [parsed.command].concat(parsed.args).join(' '); + + if (isWin) { + parsed.command = typeof parsed.options.shell === 'string' ? parsed.options.shell : process.env.comspec || 'cmd.exe'; + parsed.args = ['/d', '/s', '/c', `"${shellCommand}"`]; + parsed.options.windowsVerbatimArguments = true; // Tell node's spawn that the arguments are already escaped + } else { + if (typeof parsed.options.shell === 'string') { + parsed.command = parsed.options.shell; + } else if (process.platform === 'android') { + parsed.command = '/system/bin/sh'; + } else { + parsed.command = '/bin/sh'; + } + + parsed.args = ['-c', shellCommand]; + } + + return parsed; +} + +function parse(command, args, options) { + // Normalize arguments, similar to nodejs + if (args && !Array.isArray(args)) { + options = args; + args = null; + } + + args = args ? args.slice(0) : []; // Clone array to avoid changing the original + options = Object.assign({}, options); // Clone object to avoid changing the original + + // Build our parsed object + const parsed = { + command, + args, + options, + file: undefined, + original: { + command, + args, + }, + }; + + // Delegate further parsing to shell or non-shell + return options.shell ? parseShell(parsed) : parseNonShell(parsed); +} + +module.exports = parse; + + +/***/ }), + +/***/ 574: +/***/ (function(module, __unusedexports, __webpack_require__) { + +"use strict"; + + +var Type = __webpack_require__(945); + +module.exports = new Type('tag:yaml.org,2002:str', { + kind: 'scalar', + construct: function (data) { return data !== null ? data : ''; } +}); + + +/***/ }), + +/***/ 577: +/***/ (function(module) { + +module.exports = getPageLinks + +function getPageLinks (link) { + link = link.link || link.headers.link || '' + + const links = {} + + // link format: + // '; rel="next", ; rel="last"' + link.replace(/<([^>]*)>;\s*rel="([\w]*)"/g, (m, uri, type) => { + links[type] = uri + }) + + return links +} + + +/***/ }), + +/***/ 581: +/***/ (function(module, __unusedexports, __webpack_require__) { + +"use strict"; +// Standard YAML's Failsafe schema. +// http://www.yaml.org/spec/1.2/spec.html#id2802346 + + + + + +var Schema = __webpack_require__(43); + + +module.exports = new Schema({ + explicit: [ + __webpack_require__(574), + __webpack_require__(921), + __webpack_require__(988) + ] +}); + + +/***/ }), + +/***/ 605: +/***/ (function(module) { + +module.exports = require("http"); + +/***/ }), + +/***/ 611: +/***/ (function(module, __unusedexports, __webpack_require__) { + +"use strict"; +// Standard YAML's Core schema. +// http://www.yaml.org/spec/1.2/spec.html#id2804923 +// +// NOTE: JS-YAML does not support schema-specific tag resolution restrictions. +// So, Core schema has no distinctions from JSON schema is JS-YAML. + + + + + +var Schema = __webpack_require__(43); + + +module.exports = new Schema({ + include: [ + __webpack_require__(23) + ] +}); + + +/***/ }), + +/***/ 614: +/***/ (function(module) { + +module.exports = require("events"); + +/***/ }), + +/***/ 621: +/***/ (function(module, __unusedexports, __webpack_require__) { + +"use strict"; + +const path = __webpack_require__(622); +const pathKey = __webpack_require__(39); + +module.exports = opts => { + opts = Object.assign({ + cwd: process.cwd(), + path: process.env[pathKey()] + }, opts); + + let prev; + let pth = path.resolve(opts.cwd); + const ret = []; + + while (prev !== pth) { + ret.push(path.join(pth, 'node_modules/.bin')); + prev = pth; + pth = path.resolve(pth, '..'); + } + + // ensure the running `node` binary is used + ret.push(path.dirname(process.execPath)); + + return ret.concat(opts.path).join(path.delimiter); +}; + +module.exports.env = opts => { + opts = Object.assign({ + env: process.env + }, opts); + + const env = Object.assign({}, opts.env); + const path = pathKey({env}); + + opts.path = env[path]; + env[path] = module.exports(opts); + + return env; +}; + + +/***/ }), + +/***/ 622: +/***/ (function(module) { + +module.exports = require("path"); + +/***/ }), + +/***/ 629: +/***/ (function(module) { + +!function(t,n){ true?module.exports=n():undefined}(this,function(){"use strict";var t="millisecond",n="second",e="minute",r="hour",i="day",s="week",u="month",o="quarter",a="year",h=/^(\d{4})-?(\d{1,2})-?(\d{0,2})[^0-9]*(\d{1,2})?:?(\d{1,2})?:?(\d{1,2})?.?(\d{1,3})?$/,f=/\[([^\]]+)]|Y{2,4}|M{1,4}|D{1,2}|d{1,4}|H{1,2}|h{1,2}|a|A|m{1,2}|s{1,2}|Z{1,2}|SSS/g,c=function(t,n,e){var r=String(t);return!r||r.length>=n?t:""+Array(n+1-r.length).join(e)+t},d={s:c,z:function(t){var n=-t.utcOffset(),e=Math.abs(n),r=Math.floor(e/60),i=e%60;return(n<=0?"+":"-")+c(r,2,"0")+":"+c(i,2,"0")},m:function(t,n){var e=12*(n.year()-t.year())+(n.month()-t.month()),r=t.clone().add(e,u),i=n-r<0,s=t.clone().add(e+(i?-1:1),u);return Number(-(e+(n-r)/(i?r-s:s-r))||0)},a:function(t){return t<0?Math.ceil(t)||0:Math.floor(t)},p:function(h){return{M:u,y:a,w:s,d:i,D:"date",h:r,m:e,s:n,ms:t,Q:o}[h]||String(h||"").toLowerCase().replace(/s$/,"")},u:function(t){return void 0===t}},$={name:"en",weekdays:"Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday".split("_"),months:"January_February_March_April_May_June_July_August_September_October_November_December".split("_")},l="en",m={};m[l]=$;var y=function(t){return t instanceof v},M=function(t,n,e){var r;if(!t)return l;if("string"==typeof t)m[t]&&(r=t),n&&(m[t]=n,r=t);else{var i=t.name;m[i]=t,r=i}return!e&&r&&(l=r),r||!e&&l},g=function(t,n,e){if(y(t))return t.clone();var r=n?"string"==typeof n?{format:n,pl:e}:n:{};return r.date=t,new v(r)},D=d;D.l=M,D.i=y,D.w=function(t,n){return g(t,{locale:n.$L,utc:n.$u,$offset:n.$offset})};var v=function(){function c(t){this.$L=this.$L||M(t.locale,null,!0),this.parse(t)}var d=c.prototype;return d.parse=function(t){this.$d=function(t){var n=t.date,e=t.utc;if(null===n)return new Date(NaN);if(D.u(n))return new Date;if(n instanceof Date)return new Date(n);if("string"==typeof n&&!/Z$/i.test(n)){var r=n.match(h);if(r)return e?new Date(Date.UTC(r[1],r[2]-1,r[3]||1,r[4]||0,r[5]||0,r[6]||0,r[7]||0)):new Date(r[1],r[2]-1,r[3]||1,r[4]||0,r[5]||0,r[6]||0,r[7]||0)}return new Date(n)}(t),this.init()},d.init=function(){var t=this.$d;this.$y=t.getFullYear(),this.$M=t.getMonth(),this.$D=t.getDate(),this.$W=t.getDay(),this.$H=t.getHours(),this.$m=t.getMinutes(),this.$s=t.getSeconds(),this.$ms=t.getMilliseconds()},d.$utils=function(){return D},d.isValid=function(){return!("Invalid Date"===this.$d.toString())},d.isSame=function(t,n){var e=g(t);return this.startOf(n)<=e&&e<=this.endOf(n)},d.isAfter=function(t,n){return g(t) log.warn(deprecation)); + +function authenticate(state, options) { + deprecateAuthenticate( + state.octokit.log, + new Deprecation( + '[@octokit/rest] octokit.authenticate() is deprecated. Use "auth" constructor option instead.' + ) + ); + + if (!options) { + state.auth = false; + return; + } + + switch (options.type) { + case "basic": + if (!options.username || !options.password) { + throw new Error( + "Basic authentication requires both a username and password to be set" + ); + } + break; + + case "oauth": + if (!options.token && !(options.key && options.secret)) { + throw new Error( + "OAuth2 authentication requires a token or key & secret to be set" + ); + } + break; + + case "token": + case "app": + if (!options.token) { + throw new Error("Token authentication requires a token to be set"); + } + break; + + default: + throw new Error( + "Invalid authentication type, must be 'basic', 'oauth', 'token' or 'app'" + ); + } + + state.auth = options; +} + + +/***/ }), + +/***/ 675: +/***/ (function(module) { + +module.exports = function btoa(str) { + return new Buffer(str).toString('base64') +} + + +/***/ }), + +/***/ 685: +/***/ (function(module, __unusedexports, __webpack_require__) { + +"use strict"; + + +/*eslint-disable no-use-before-define*/ + +var common = __webpack_require__(740); +var YAMLException = __webpack_require__(556); +var DEFAULT_FULL_SCHEMA = __webpack_require__(910); +var DEFAULT_SAFE_SCHEMA = __webpack_require__(723); + +var _toString = Object.prototype.toString; +var _hasOwnProperty = Object.prototype.hasOwnProperty; + +var CHAR_TAB = 0x09; /* Tab */ +var CHAR_LINE_FEED = 0x0A; /* LF */ +var CHAR_SPACE = 0x20; /* Space */ +var CHAR_EXCLAMATION = 0x21; /* ! */ +var CHAR_DOUBLE_QUOTE = 0x22; /* " */ +var CHAR_SHARP = 0x23; /* # */ +var CHAR_PERCENT = 0x25; /* % */ +var CHAR_AMPERSAND = 0x26; /* & */ +var CHAR_SINGLE_QUOTE = 0x27; /* ' */ +var CHAR_ASTERISK = 0x2A; /* * */ +var CHAR_COMMA = 0x2C; /* , */ +var CHAR_MINUS = 0x2D; /* - */ +var CHAR_COLON = 0x3A; /* : */ +var CHAR_GREATER_THAN = 0x3E; /* > */ +var CHAR_QUESTION = 0x3F; /* ? */ +var CHAR_COMMERCIAL_AT = 0x40; /* @ */ +var CHAR_LEFT_SQUARE_BRACKET = 0x5B; /* [ */ +var CHAR_RIGHT_SQUARE_BRACKET = 0x5D; /* ] */ +var CHAR_GRAVE_ACCENT = 0x60; /* ` */ +var CHAR_LEFT_CURLY_BRACKET = 0x7B; /* { */ +var CHAR_VERTICAL_LINE = 0x7C; /* | */ +var CHAR_RIGHT_CURLY_BRACKET = 0x7D; /* } */ + +var ESCAPE_SEQUENCES = {}; + +ESCAPE_SEQUENCES[0x00] = '\\0'; +ESCAPE_SEQUENCES[0x07] = '\\a'; +ESCAPE_SEQUENCES[0x08] = '\\b'; +ESCAPE_SEQUENCES[0x09] = '\\t'; +ESCAPE_SEQUENCES[0x0A] = '\\n'; +ESCAPE_SEQUENCES[0x0B] = '\\v'; +ESCAPE_SEQUENCES[0x0C] = '\\f'; +ESCAPE_SEQUENCES[0x0D] = '\\r'; +ESCAPE_SEQUENCES[0x1B] = '\\e'; +ESCAPE_SEQUENCES[0x22] = '\\"'; +ESCAPE_SEQUENCES[0x5C] = '\\\\'; +ESCAPE_SEQUENCES[0x85] = '\\N'; +ESCAPE_SEQUENCES[0xA0] = '\\_'; +ESCAPE_SEQUENCES[0x2028] = '\\L'; +ESCAPE_SEQUENCES[0x2029] = '\\P'; + +var DEPRECATED_BOOLEANS_SYNTAX = [ + 'y', 'Y', 'yes', 'Yes', 'YES', 'on', 'On', 'ON', + 'n', 'N', 'no', 'No', 'NO', 'off', 'Off', 'OFF' +]; + +function compileStyleMap(schema, map) { + var result, keys, index, length, tag, style, type; + + if (map === null) return {}; + + result = {}; + keys = Object.keys(map); + + for (index = 0, length = keys.length; index < length; index += 1) { + tag = keys[index]; + style = String(map[tag]); + + if (tag.slice(0, 2) === '!!') { + tag = 'tag:yaml.org,2002:' + tag.slice(2); + } + type = schema.compiledTypeMap['fallback'][tag]; + + if (type && _hasOwnProperty.call(type.styleAliases, style)) { + style = type.styleAliases[style]; + } + + result[tag] = style; + } + + return result; +} + +function encodeHex(character) { + var string, handle, length; + + string = character.toString(16).toUpperCase(); + + if (character <= 0xFF) { + handle = 'x'; + length = 2; + } else if (character <= 0xFFFF) { + handle = 'u'; + length = 4; + } else if (character <= 0xFFFFFFFF) { + handle = 'U'; + length = 8; + } else { + throw new YAMLException('code point within a string may not be greater than 0xFFFFFFFF'); + } + + return '\\' + handle + common.repeat('0', length - string.length) + string; +} + +function State(options) { + this.schema = options['schema'] || DEFAULT_FULL_SCHEMA; + this.indent = Math.max(1, (options['indent'] || 2)); + this.noArrayIndent = options['noArrayIndent'] || false; + this.skipInvalid = options['skipInvalid'] || false; + this.flowLevel = (common.isNothing(options['flowLevel']) ? -1 : options['flowLevel']); + this.styleMap = compileStyleMap(this.schema, options['styles'] || null); + this.sortKeys = options['sortKeys'] || false; + this.lineWidth = options['lineWidth'] || 80; + this.noRefs = options['noRefs'] || false; + this.noCompatMode = options['noCompatMode'] || false; + this.condenseFlow = options['condenseFlow'] || false; + + this.implicitTypes = this.schema.compiledImplicit; + this.explicitTypes = this.schema.compiledExplicit; + + this.tag = null; + this.result = ''; + + this.duplicates = []; + this.usedDuplicates = null; +} + +// Indents every line in a string. Empty lines (\n only) are not indented. +function indentString(string, spaces) { + var ind = common.repeat(' ', spaces), + position = 0, + next = -1, + result = '', + line, + length = string.length; + + while (position < length) { + next = string.indexOf('\n', position); + if (next === -1) { + line = string.slice(position); + position = length; + } else { + line = string.slice(position, next + 1); + position = next + 1; + } + + if (line.length && line !== '\n') result += ind; + + result += line; + } + + return result; +} + +function generateNextLine(state, level) { + return '\n' + common.repeat(' ', state.indent * level); +} + +function testImplicitResolving(state, str) { + var index, length, type; + + for (index = 0, length = state.implicitTypes.length; index < length; index += 1) { + type = state.implicitTypes[index]; + + if (type.resolve(str)) { + return true; + } + } + + return false; +} + +// [33] s-white ::= s-space | s-tab +function isWhitespace(c) { + return c === CHAR_SPACE || c === CHAR_TAB; +} + +// Returns true if the character can be printed without escaping. +// From YAML 1.2: "any allowed characters known to be non-printable +// should also be escaped. [However,] This isn’t mandatory" +// Derived from nb-char - \t - #x85 - #xA0 - #x2028 - #x2029. +function isPrintable(c) { + return (0x00020 <= c && c <= 0x00007E) + || ((0x000A1 <= c && c <= 0x00D7FF) && c !== 0x2028 && c !== 0x2029) + || ((0x0E000 <= c && c <= 0x00FFFD) && c !== 0xFEFF /* BOM */) + || (0x10000 <= c && c <= 0x10FFFF); +} + +// Simplified test for values allowed after the first character in plain style. +function isPlainSafe(c) { + // Uses a subset of nb-char - c-flow-indicator - ":" - "#" + // where nb-char ::= c-printable - b-char - c-byte-order-mark. + return isPrintable(c) && c !== 0xFEFF + // - c-flow-indicator + && c !== CHAR_COMMA + && c !== CHAR_LEFT_SQUARE_BRACKET + && c !== CHAR_RIGHT_SQUARE_BRACKET + && c !== CHAR_LEFT_CURLY_BRACKET + && c !== CHAR_RIGHT_CURLY_BRACKET + // - ":" - "#" + && c !== CHAR_COLON + && c !== CHAR_SHARP; +} + +// Simplified test for values allowed as the first character in plain style. +function isPlainSafeFirst(c) { + // Uses a subset of ns-char - c-indicator + // where ns-char = nb-char - s-white. + return isPrintable(c) && c !== 0xFEFF + && !isWhitespace(c) // - s-white + // - (c-indicator ::= + // “-” | “?” | “:” | “,” | “[” | “]” | “{” | “}” + && c !== CHAR_MINUS + && c !== CHAR_QUESTION + && c !== CHAR_COLON + && c !== CHAR_COMMA + && c !== CHAR_LEFT_SQUARE_BRACKET + && c !== CHAR_RIGHT_SQUARE_BRACKET + && c !== CHAR_LEFT_CURLY_BRACKET + && c !== CHAR_RIGHT_CURLY_BRACKET + // | “#” | “&” | “*” | “!” | “|” | “>” | “'” | “"” + && c !== CHAR_SHARP + && c !== CHAR_AMPERSAND + && c !== CHAR_ASTERISK + && c !== CHAR_EXCLAMATION + && c !== CHAR_VERTICAL_LINE + && c !== CHAR_GREATER_THAN + && c !== CHAR_SINGLE_QUOTE + && c !== CHAR_DOUBLE_QUOTE + // | “%” | “@” | “`”) + && c !== CHAR_PERCENT + && c !== CHAR_COMMERCIAL_AT + && c !== CHAR_GRAVE_ACCENT; +} + +// Determines whether block indentation indicator is required. +function needIndentIndicator(string) { + var leadingSpaceRe = /^\n* /; + return leadingSpaceRe.test(string); +} + +var STYLE_PLAIN = 1, + STYLE_SINGLE = 2, + STYLE_LITERAL = 3, + STYLE_FOLDED = 4, + STYLE_DOUBLE = 5; + +// Determines which scalar styles are possible and returns the preferred style. +// lineWidth = -1 => no limit. +// Pre-conditions: str.length > 0. +// Post-conditions: +// STYLE_PLAIN or STYLE_SINGLE => no \n are in the string. +// STYLE_LITERAL => no lines are suitable for folding (or lineWidth is -1). +// STYLE_FOLDED => a line > lineWidth and can be folded (and lineWidth != -1). +function chooseScalarStyle(string, singleLineOnly, indentPerLevel, lineWidth, testAmbiguousType) { + var i; + var char; + var hasLineBreak = false; + var hasFoldableLine = false; // only checked if shouldTrackWidth + var shouldTrackWidth = lineWidth !== -1; + var previousLineBreak = -1; // count the first line correctly + var plain = isPlainSafeFirst(string.charCodeAt(0)) + && !isWhitespace(string.charCodeAt(string.length - 1)); + + if (singleLineOnly) { + // Case: no block styles. + // Check for disallowed characters to rule out plain and single. + for (i = 0; i < string.length; i++) { + char = string.charCodeAt(i); + if (!isPrintable(char)) { + return STYLE_DOUBLE; + } + plain = plain && isPlainSafe(char); + } + } else { + // Case: block styles permitted. + for (i = 0; i < string.length; i++) { + char = string.charCodeAt(i); + if (char === CHAR_LINE_FEED) { + hasLineBreak = true; + // Check if any line can be folded. + if (shouldTrackWidth) { + hasFoldableLine = hasFoldableLine || + // Foldable line = too long, and not more-indented. + (i - previousLineBreak - 1 > lineWidth && + string[previousLineBreak + 1] !== ' '); + previousLineBreak = i; + } + } else if (!isPrintable(char)) { + return STYLE_DOUBLE; + } + plain = plain && isPlainSafe(char); + } + // in case the end is missing a \n + hasFoldableLine = hasFoldableLine || (shouldTrackWidth && + (i - previousLineBreak - 1 > lineWidth && + string[previousLineBreak + 1] !== ' ')); + } + // Although every style can represent \n without escaping, prefer block styles + // for multiline, since they're more readable and they don't add empty lines. + // Also prefer folding a super-long line. + if (!hasLineBreak && !hasFoldableLine) { + // Strings interpretable as another type have to be quoted; + // e.g. the string 'true' vs. the boolean true. + return plain && !testAmbiguousType(string) + ? STYLE_PLAIN : STYLE_SINGLE; + } + // Edge case: block indentation indicator can only have one digit. + if (indentPerLevel > 9 && needIndentIndicator(string)) { + return STYLE_DOUBLE; + } + // At this point we know block styles are valid. + // Prefer literal style unless we want to fold. + return hasFoldableLine ? STYLE_FOLDED : STYLE_LITERAL; +} + +// Note: line breaking/folding is implemented for only the folded style. +// NB. We drop the last trailing newline (if any) of a returned block scalar +// since the dumper adds its own newline. This always works: +// • No ending newline => unaffected; already using strip "-" chomping. +// • Ending newline => removed then restored. +// Importantly, this keeps the "+" chomp indicator from gaining an extra line. +function writeScalar(state, string, level, iskey) { + state.dump = (function () { + if (string.length === 0) { + return "''"; + } + if (!state.noCompatMode && + DEPRECATED_BOOLEANS_SYNTAX.indexOf(string) !== -1) { + return "'" + string + "'"; + } + + var indent = state.indent * Math.max(1, level); // no 0-indent scalars + // As indentation gets deeper, let the width decrease monotonically + // to the lower bound min(state.lineWidth, 40). + // Note that this implies + // state.lineWidth ≤ 40 + state.indent: width is fixed at the lower bound. + // state.lineWidth > 40 + state.indent: width decreases until the lower bound. + // This behaves better than a constant minimum width which disallows narrower options, + // or an indent threshold which causes the width to suddenly increase. + var lineWidth = state.lineWidth === -1 + ? -1 : Math.max(Math.min(state.lineWidth, 40), state.lineWidth - indent); + + // Without knowing if keys are implicit/explicit, assume implicit for safety. + var singleLineOnly = iskey + // No block styles in flow mode. + || (state.flowLevel > -1 && level >= state.flowLevel); + function testAmbiguity(string) { + return testImplicitResolving(state, string); + } + + switch (chooseScalarStyle(string, singleLineOnly, state.indent, lineWidth, testAmbiguity)) { + case STYLE_PLAIN: + return string; + case STYLE_SINGLE: + return "'" + string.replace(/'/g, "''") + "'"; + case STYLE_LITERAL: + return '|' + blockHeader(string, state.indent) + + dropEndingNewline(indentString(string, indent)); + case STYLE_FOLDED: + return '>' + blockHeader(string, state.indent) + + dropEndingNewline(indentString(foldString(string, lineWidth), indent)); + case STYLE_DOUBLE: + return '"' + escapeString(string, lineWidth) + '"'; + default: + throw new YAMLException('impossible error: invalid scalar style'); + } + }()); +} + +// Pre-conditions: string is valid for a block scalar, 1 <= indentPerLevel <= 9. +function blockHeader(string, indentPerLevel) { + var indentIndicator = needIndentIndicator(string) ? String(indentPerLevel) : ''; + + // note the special case: the string '\n' counts as a "trailing" empty line. + var clip = string[string.length - 1] === '\n'; + var keep = clip && (string[string.length - 2] === '\n' || string === '\n'); + var chomp = keep ? '+' : (clip ? '' : '-'); + + return indentIndicator + chomp + '\n'; +} + +// (See the note for writeScalar.) +function dropEndingNewline(string) { + return string[string.length - 1] === '\n' ? string.slice(0, -1) : string; +} + +// Note: a long line without a suitable break point will exceed the width limit. +// Pre-conditions: every char in str isPrintable, str.length > 0, width > 0. +function foldString(string, width) { + // In folded style, $k$ consecutive newlines output as $k+1$ newlines— + // unless they're before or after a more-indented line, or at the very + // beginning or end, in which case $k$ maps to $k$. + // Therefore, parse each chunk as newline(s) followed by a content line. + var lineRe = /(\n+)([^\n]*)/g; + + // first line (possibly an empty line) + var result = (function () { + var nextLF = string.indexOf('\n'); + nextLF = nextLF !== -1 ? nextLF : string.length; + lineRe.lastIndex = nextLF; + return foldLine(string.slice(0, nextLF), width); + }()); + // If we haven't reached the first content line yet, don't add an extra \n. + var prevMoreIndented = string[0] === '\n' || string[0] === ' '; + var moreIndented; + + // rest of the lines + var match; + while ((match = lineRe.exec(string))) { + var prefix = match[1], line = match[2]; + moreIndented = (line[0] === ' '); + result += prefix + + (!prevMoreIndented && !moreIndented && line !== '' + ? '\n' : '') + + foldLine(line, width); + prevMoreIndented = moreIndented; + } + + return result; +} + +// Greedy line breaking. +// Picks the longest line under the limit each time, +// otherwise settles for the shortest line over the limit. +// NB. More-indented lines *cannot* be folded, as that would add an extra \n. +function foldLine(line, width) { + if (line === '' || line[0] === ' ') return line; + + // Since a more-indented line adds a \n, breaks can't be followed by a space. + var breakRe = / [^ ]/g; // note: the match index will always be <= length-2. + var match; + // start is an inclusive index. end, curr, and next are exclusive. + var start = 0, end, curr = 0, next = 0; + var result = ''; + + // Invariants: 0 <= start <= length-1. + // 0 <= curr <= next <= max(0, length-2). curr - start <= width. + // Inside the loop: + // A match implies length >= 2, so curr and next are <= length-2. + while ((match = breakRe.exec(line))) { + next = match.index; + // maintain invariant: curr - start <= width + if (next - start > width) { + end = (curr > start) ? curr : next; // derive end <= length-2 + result += '\n' + line.slice(start, end); + // skip the space that was output as \n + start = end + 1; // derive start <= length-1 + } + curr = next; + } + + // By the invariants, start <= length-1, so there is something left over. + // It is either the whole string or a part starting from non-whitespace. + result += '\n'; + // Insert a break if the remainder is too long and there is a break available. + if (line.length - start > width && curr > start) { + result += line.slice(start, curr) + '\n' + line.slice(curr + 1); + } else { + result += line.slice(start); + } + + return result.slice(1); // drop extra \n joiner +} + +// Escapes a double-quoted string. +function escapeString(string) { + var result = ''; + var char, nextChar; + var escapeSeq; + + for (var i = 0; i < string.length; i++) { + char = string.charCodeAt(i); + // Check for surrogate pairs (reference Unicode 3.0 section "3.7 Surrogates"). + if (char >= 0xD800 && char <= 0xDBFF/* high surrogate */) { + nextChar = string.charCodeAt(i + 1); + if (nextChar >= 0xDC00 && nextChar <= 0xDFFF/* low surrogate */) { + // Combine the surrogate pair and store it escaped. + result += encodeHex((char - 0xD800) * 0x400 + nextChar - 0xDC00 + 0x10000); + // Advance index one extra since we already used that char here. + i++; continue; + } + } + escapeSeq = ESCAPE_SEQUENCES[char]; + result += !escapeSeq && isPrintable(char) + ? string[i] + : escapeSeq || encodeHex(char); + } + + return result; +} + +function writeFlowSequence(state, level, object) { + var _result = '', + _tag = state.tag, + index, + length; + + for (index = 0, length = object.length; index < length; index += 1) { + // Write only valid elements. + if (writeNode(state, level, object[index], false, false)) { + if (index !== 0) _result += ',' + (!state.condenseFlow ? ' ' : ''); + _result += state.dump; + } + } + + state.tag = _tag; + state.dump = '[' + _result + ']'; +} + +function writeBlockSequence(state, level, object, compact) { + var _result = '', + _tag = state.tag, + index, + length; + + for (index = 0, length = object.length; index < length; index += 1) { + // Write only valid elements. + if (writeNode(state, level + 1, object[index], true, true)) { + if (!compact || index !== 0) { + _result += generateNextLine(state, level); + } + + if (state.dump && CHAR_LINE_FEED === state.dump.charCodeAt(0)) { + _result += '-'; + } else { + _result += '- '; + } + + _result += state.dump; + } + } + + state.tag = _tag; + state.dump = _result || '[]'; // Empty sequence if no valid values. +} + +function writeFlowMapping(state, level, object) { + var _result = '', + _tag = state.tag, + objectKeyList = Object.keys(object), + index, + length, + objectKey, + objectValue, + pairBuffer; + + for (index = 0, length = objectKeyList.length; index < length; index += 1) { + pairBuffer = state.condenseFlow ? '"' : ''; + + if (index !== 0) pairBuffer += ', '; + + objectKey = objectKeyList[index]; + objectValue = object[objectKey]; + + if (!writeNode(state, level, objectKey, false, false)) { + continue; // Skip this pair because of invalid key; + } + + if (state.dump.length > 1024) pairBuffer += '? '; + + pairBuffer += state.dump + (state.condenseFlow ? '"' : '') + ':' + (state.condenseFlow ? '' : ' '); + + if (!writeNode(state, level, objectValue, false, false)) { + continue; // Skip this pair because of invalid value. + } + + pairBuffer += state.dump; + + // Both key and value are valid. + _result += pairBuffer; + } + + state.tag = _tag; + state.dump = '{' + _result + '}'; +} + +function writeBlockMapping(state, level, object, compact) { + var _result = '', + _tag = state.tag, + objectKeyList = Object.keys(object), + index, + length, + objectKey, + objectValue, + explicitPair, + pairBuffer; + + // Allow sorting keys so that the output file is deterministic + if (state.sortKeys === true) { + // Default sorting + objectKeyList.sort(); + } else if (typeof state.sortKeys === 'function') { + // Custom sort function + objectKeyList.sort(state.sortKeys); + } else if (state.sortKeys) { + // Something is wrong + throw new YAMLException('sortKeys must be a boolean or a function'); + } + + for (index = 0, length = objectKeyList.length; index < length; index += 1) { + pairBuffer = ''; + + if (!compact || index !== 0) { + pairBuffer += generateNextLine(state, level); + } + + objectKey = objectKeyList[index]; + objectValue = object[objectKey]; + + if (!writeNode(state, level + 1, objectKey, true, true, true)) { + continue; // Skip this pair because of invalid key. + } + + explicitPair = (state.tag !== null && state.tag !== '?') || + (state.dump && state.dump.length > 1024); + + if (explicitPair) { + if (state.dump && CHAR_LINE_FEED === state.dump.charCodeAt(0)) { + pairBuffer += '?'; + } else { + pairBuffer += '? '; + } + } + + pairBuffer += state.dump; + + if (explicitPair) { + pairBuffer += generateNextLine(state, level); + } + + if (!writeNode(state, level + 1, objectValue, true, explicitPair)) { + continue; // Skip this pair because of invalid value. + } + + if (state.dump && CHAR_LINE_FEED === state.dump.charCodeAt(0)) { + pairBuffer += ':'; + } else { + pairBuffer += ': '; + } + + pairBuffer += state.dump; + + // Both key and value are valid. + _result += pairBuffer; + } + + state.tag = _tag; + state.dump = _result || '{}'; // Empty mapping if no valid pairs. +} + +function detectType(state, object, explicit) { + var _result, typeList, index, length, type, style; + + typeList = explicit ? state.explicitTypes : state.implicitTypes; + + for (index = 0, length = typeList.length; index < length; index += 1) { + type = typeList[index]; + + if ((type.instanceOf || type.predicate) && + (!type.instanceOf || ((typeof object === 'object') && (object instanceof type.instanceOf))) && + (!type.predicate || type.predicate(object))) { + + state.tag = explicit ? type.tag : '?'; + + if (type.represent) { + style = state.styleMap[type.tag] || type.defaultStyle; + + if (_toString.call(type.represent) === '[object Function]') { + _result = type.represent(object, style); + } else if (_hasOwnProperty.call(type.represent, style)) { + _result = type.represent[style](object, style); + } else { + throw new YAMLException('!<' + type.tag + '> tag resolver accepts not "' + style + '" style'); + } + + state.dump = _result; + } + + return true; + } + } + + return false; +} + +// Serializes `object` and writes it to global `result`. +// Returns true on success, or false on invalid object. +// +function writeNode(state, level, object, block, compact, iskey) { + state.tag = null; + state.dump = object; + + if (!detectType(state, object, false)) { + detectType(state, object, true); + } + + var type = _toString.call(state.dump); + + if (block) { + block = (state.flowLevel < 0 || state.flowLevel > level); + } + + var objectOrArray = type === '[object Object]' || type === '[object Array]', + duplicateIndex, + duplicate; + + if (objectOrArray) { + duplicateIndex = state.duplicates.indexOf(object); + duplicate = duplicateIndex !== -1; + } + + if ((state.tag !== null && state.tag !== '?') || duplicate || (state.indent !== 2 && level > 0)) { + compact = false; + } + + if (duplicate && state.usedDuplicates[duplicateIndex]) { + state.dump = '*ref_' + duplicateIndex; + } else { + if (objectOrArray && duplicate && !state.usedDuplicates[duplicateIndex]) { + state.usedDuplicates[duplicateIndex] = true; + } + if (type === '[object Object]') { + if (block && (Object.keys(state.dump).length !== 0)) { + writeBlockMapping(state, level, state.dump, compact); + if (duplicate) { + state.dump = '&ref_' + duplicateIndex + state.dump; + } + } else { + writeFlowMapping(state, level, state.dump); + if (duplicate) { + state.dump = '&ref_' + duplicateIndex + ' ' + state.dump; + } + } + } else if (type === '[object Array]') { + var arrayLevel = (state.noArrayIndent && (level > 0)) ? level - 1 : level; + if (block && (state.dump.length !== 0)) { + writeBlockSequence(state, arrayLevel, state.dump, compact); + if (duplicate) { + state.dump = '&ref_' + duplicateIndex + state.dump; + } + } else { + writeFlowSequence(state, arrayLevel, state.dump); + if (duplicate) { + state.dump = '&ref_' + duplicateIndex + ' ' + state.dump; + } + } + } else if (type === '[object String]') { + if (state.tag !== '?') { + writeScalar(state, state.dump, level, iskey); + } + } else { + if (state.skipInvalid) return false; + throw new YAMLException('unacceptable kind of an object to dump ' + type); + } + + if (state.tag !== null && state.tag !== '?') { + state.dump = '!<' + state.tag + '> ' + state.dump; + } + } + + return true; +} + +function getDuplicateReferences(object, state) { + var objects = [], + duplicatesIndexes = [], + index, + length; + + inspectNode(object, objects, duplicatesIndexes); + + for (index = 0, length = duplicatesIndexes.length; index < length; index += 1) { + state.duplicates.push(objects[duplicatesIndexes[index]]); + } + state.usedDuplicates = new Array(length); +} + +function inspectNode(object, objects, duplicatesIndexes) { + var objectKeyList, + index, + length; + + if (object !== null && typeof object === 'object') { + index = objects.indexOf(object); + if (index !== -1) { + if (duplicatesIndexes.indexOf(index) === -1) { + duplicatesIndexes.push(index); + } + } else { + objects.push(object); + + if (Array.isArray(object)) { + for (index = 0, length = object.length; index < length; index += 1) { + inspectNode(object[index], objects, duplicatesIndexes); + } + } else { + objectKeyList = Object.keys(object); + + for (index = 0, length = objectKeyList.length; index < length; index += 1) { + inspectNode(object[objectKeyList[index]], objects, duplicatesIndexes); + } + } + } + } +} + +function dump(input, options) { + options = options || {}; + + var state = new State(options); + + if (!state.noRefs) getDuplicateReferences(input, state); + + if (writeNode(state, 0, input, true, true)) return state.dump + '\n'; + + return ''; +} + +function safeDump(input, options) { + return dump(input, common.extend({ schema: DEFAULT_SAFE_SCHEMA }, options)); +} + +module.exports.dump = dump; +module.exports.safeDump = safeDump; + + +/***/ }), + +/***/ 692: +/***/ (function(__unusedmodule, exports) { + +"use strict"; + + +Object.defineProperty(exports, '__esModule', { value: true }); + +class Deprecation extends Error { + constructor(message) { + super(message); // Maintains proper stack trace (only available on V8) + + /* istanbul ignore next */ + + if (Error.captureStackTrace) { + Error.captureStackTrace(this, this.constructor); + } + + this.name = 'Deprecation'; + } + +} + +exports.Deprecation = Deprecation; + + +/***/ }), + +/***/ 696: +/***/ (function(module) { + +"use strict"; + + +/*! + * isobject + * + * Copyright (c) 2014-2017, Jon Schlinkert. + * Released under the MIT License. + */ + +function isObject(val) { + return val != null && typeof val === 'object' && Array.isArray(val) === false; +} + +/*! + * is-plain-object + * + * Copyright (c) 2014-2017, Jon Schlinkert. + * Released under the MIT License. + */ + +function isObjectObject(o) { + return isObject(o) === true + && Object.prototype.toString.call(o) === '[object Object]'; +} + +function isPlainObject(o) { + var ctor,prot; + + if (isObjectObject(o) === false) return false; + + // If has modified constructor + ctor = o.constructor; + if (typeof ctor !== 'function') return false; + + // If has modified prototype + prot = ctor.prototype; + if (isObjectObject(prot) === false) return false; + + // If constructor does not have an Object-specific method + if (prot.hasOwnProperty('isPrototypeOf') === false) { + return false; + } + + // Most likely a plain Object + return true; +} + +module.exports = isPlainObject; + + +/***/ }), + +/***/ 697: +/***/ (function(module) { + +"use strict"; + +module.exports = (promise, onFinally) => { + onFinally = onFinally || (() => {}); + + return promise.then( + val => new Promise(resolve => { + resolve(onFinally()); + }).then(() => val), + err => new Promise(resolve => { + resolve(onFinally()); + }).then(() => { + throw err; + }) + ); +}; + + +/***/ }), + +/***/ 723: +/***/ (function(module, __unusedexports, __webpack_require__) { + +"use strict"; +// JS-YAML's default schema for `safeLoad` function. +// It is not described in the YAML specification. +// +// This schema is based on standard YAML's Core schema and includes most of +// extra types described at YAML tag repository. (http://yaml.org/type/) + + + + + +var Schema = __webpack_require__(43); + + +module.exports = new Schema({ + include: [ + __webpack_require__(611) + ], + implicit: [ + __webpack_require__(82), + __webpack_require__(633) + ], + explicit: [ + __webpack_require__(913), + __webpack_require__(181), + __webpack_require__(947), + __webpack_require__(100) + ] +}); + + +/***/ }), + +/***/ 740: +/***/ (function(module) { + +"use strict"; + + + +function isNothing(subject) { + return (typeof subject === 'undefined') || (subject === null); +} + + +function isObject(subject) { + return (typeof subject === 'object') && (subject !== null); +} + + +function toArray(sequence) { + if (Array.isArray(sequence)) return sequence; + else if (isNothing(sequence)) return []; + + return [ sequence ]; +} + + +function extend(target, source) { + var index, length, key, sourceKeys; + + if (source) { + sourceKeys = Object.keys(source); + + for (index = 0, length = sourceKeys.length; index < length; index += 1) { + key = sourceKeys[index]; + target[key] = source[key]; + } + } + + return target; +} + + +function repeat(string, count) { + var result = '', cycle; + + for (cycle = 0; cycle < count; cycle += 1) { + result += string; + } + + return result; +} + + +function isNegativeZero(number) { + return (number === 0) && (Number.NEGATIVE_INFINITY === 1 / number); +} + + +module.exports.isNothing = isNothing; +module.exports.isObject = isObject; +module.exports.toArray = toArray; +module.exports.repeat = repeat; +module.exports.isNegativeZero = isNegativeZero; +module.exports.extend = extend; + + +/***/ }), + +/***/ 742: +/***/ (function(module, __unusedexports, __webpack_require__) { + +var fs = __webpack_require__(747) +var core +if (process.platform === 'win32' || global.TESTING_WINDOWS) { + core = __webpack_require__(818) +} else { + core = __webpack_require__(197) +} + +module.exports = isexe +isexe.sync = sync + +function isexe (path, options, cb) { + if (typeof options === 'function') { + cb = options + options = {} + } + + if (!cb) { + if (typeof Promise !== 'function') { + throw new TypeError('callback not provided') + } + + return new Promise(function (resolve, reject) { + isexe(path, options || {}, function (er, is) { + if (er) { + reject(er) + } else { + resolve(is) + } + }) + }) + } + + core(path, options || {}, function (er, is) { + // ignore EACCES because that just means we aren't allowed to run it + if (er) { + if (er.code === 'EACCES' || options && options.ignoreErrors) { + er = null + is = false + } + } + cb(er, is) + }) +} + +function sync (path, options) { + // my kingdom for a filtered catch + try { + return core.sync(path, options || {}) + } catch (er) { + if (options && options.ignoreErrors || er.code === 'EACCES') { + return false + } else { + throw er + } + } +} + + +/***/ }), + +/***/ 747: +/***/ (function(module) { + +module.exports = require("fs"); + +/***/ }), + +/***/ 753: +/***/ (function(__unusedmodule, exports, __webpack_require__) { + +"use strict"; + + +Object.defineProperty(exports, '__esModule', { value: true }); + +function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; } + +var endpoint = __webpack_require__(385); +var universalUserAgent = __webpack_require__(211); +var isPlainObject = _interopDefault(__webpack_require__(696)); +var nodeFetch = _interopDefault(__webpack_require__(454)); +var requestError = __webpack_require__(463); + +const VERSION = "5.3.4"; + +function getBufferResponse(response) { + return response.arrayBuffer(); +} + +function fetchWrapper(requestOptions) { + if (isPlainObject(requestOptions.body) || Array.isArray(requestOptions.body)) { + requestOptions.body = JSON.stringify(requestOptions.body); + } + + let headers = {}; + let status; + let url; + const fetch = requestOptions.request && requestOptions.request.fetch || nodeFetch; + return fetch(requestOptions.url, Object.assign({ + method: requestOptions.method, + body: requestOptions.body, + headers: requestOptions.headers, + redirect: requestOptions.redirect + }, requestOptions.request)).then(response => { + url = response.url; + status = response.status; + + for (const keyAndValue of response.headers) { + headers[keyAndValue[0]] = keyAndValue[1]; + } + + if (status === 204 || status === 205) { + return; + } // GitHub API returns 200 for HEAD requests + + + if (requestOptions.method === "HEAD") { + if (status < 400) { + return; + } + + throw new requestError.RequestError(response.statusText, status, { + headers, + request: requestOptions + }); + } + + if (status === 304) { + throw new requestError.RequestError("Not modified", status, { + headers, + request: requestOptions + }); + } + + if (status >= 400) { + return response.text().then(message => { + const error = new requestError.RequestError(message, status, { + headers, + request: requestOptions + }); + + try { + let responseBody = JSON.parse(error.message); + Object.assign(error, responseBody); + let errors = responseBody.errors; // Assumption `errors` would always be in Array format + + error.message = error.message + ": " + errors.map(JSON.stringify).join(", "); + } catch (e) {// ignore, see octokit/rest.js#684 + } + + throw error; + }); + } + + const contentType = response.headers.get("content-type"); + + if (/application\/json/.test(contentType)) { + return response.json(); + } + + if (!contentType || /^text\/|charset=utf-8$/.test(contentType)) { + return response.text(); + } + + return getBufferResponse(response); + }).then(data => { + return { + status, + url, + headers, + data + }; + }).catch(error => { + if (error instanceof requestError.RequestError) { + throw error; + } + + throw new requestError.RequestError(error.message, 500, { + headers, + request: requestOptions + }); + }); +} + +function withDefaults(oldEndpoint, newDefaults) { + const endpoint = oldEndpoint.defaults(newDefaults); + + const newApi = function (route, parameters) { + const endpointOptions = endpoint.merge(route, parameters); + + if (!endpointOptions.request || !endpointOptions.request.hook) { + return fetchWrapper(endpoint.parse(endpointOptions)); + } + + const request = (route, parameters) => { + return fetchWrapper(endpoint.parse(endpoint.merge(route, parameters))); + }; + + Object.assign(request, { + endpoint, + defaults: withDefaults.bind(null, endpoint) + }); + return endpointOptions.request.hook(request, endpointOptions); + }; + + return Object.assign(newApi, { + endpoint, + defaults: withDefaults.bind(null, endpoint) + }); +} + +const request = withDefaults(endpoint.endpoint, { + headers: { + "user-agent": `octokit-request.js/${VERSION} ${universalUserAgent.getUserAgent()}` + } +}); + +exports.request = request; +//# sourceMappingURL=index.js.map + + +/***/ }), + +/***/ 761: +/***/ (function(module) { + +module.exports = require("zlib"); + +/***/ }), + +/***/ 763: +/***/ (function(module) { + +module.exports = removeHook + +function removeHook (state, name, method) { + if (!state.registry[name]) { + return + } + + var index = state.registry[name] + .map(function (registered) { return registered.orig }) + .indexOf(method) + + if (index === -1) { + return + } + + state.registry[name].splice(index, 1) +} + + +/***/ }), + +/***/ 768: +/***/ (function(module) { + +"use strict"; + +module.exports = function (x) { + var lf = typeof x === 'string' ? '\n' : '\n'.charCodeAt(); + var cr = typeof x === 'string' ? '\r' : '\r'.charCodeAt(); + + if (x[x.length - 1] === lf) { + x = x.slice(0, x.length - 1); + } + + if (x[x.length - 1] === cr) { + x = x.slice(0, x.length - 1); + } + + return x; +}; + + +/***/ }), + +/***/ 777: +/***/ (function(module, __unusedexports, __webpack_require__) { + +module.exports = getFirstPage + +const getPage = __webpack_require__(265) + +function getFirstPage (octokit, link, headers) { + return getPage(octokit, link, 'first', headers) +} + + +/***/ }), + +/***/ 796: +/***/ (function(__unusedmodule, exports, __webpack_require__) { + +"use strict"; + + +Object.defineProperty(exports, '__esModule', { value: true }); + +function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; } + +var osName = _interopDefault(__webpack_require__(2)); + +function getUserAgent() { + try { + return `Node.js/${process.version.substr(1)} (${osName()}; ${process.arch})`; + } catch (error) { + if (/wmic os get Caption/.test(error.message)) { + return "Windows "; + } + + throw error; + } +} + +exports.getUserAgent = getUserAgent; +//# sourceMappingURL=index.js.map + + +/***/ }), + +/***/ 809: +/***/ (function(module, __unusedexports, __webpack_require__) { + +"use strict"; + + +var Type = __webpack_require__(945); + +function resolveYamlNull(data) { + if (data === null) return true; + + var max = data.length; + + return (max === 1 && data === '~') || + (max === 4 && (data === 'null' || data === 'Null' || data === 'NULL')); +} + +function constructYamlNull() { + return null; +} + +function isNull(object) { + return object === null; +} + +module.exports = new Type('tag:yaml.org,2002:null', { + kind: 'scalar', + resolve: resolveYamlNull, + construct: constructYamlNull, + predicate: isNull, + represent: { + canonical: function () { return '~'; }, + lowercase: function () { return 'null'; }, + uppercase: function () { return 'NULL'; }, + camelcase: function () { return 'Null'; } + }, + defaultStyle: 'lowercase' +}); + + +/***/ }), + +/***/ 813: +/***/ (function(__unusedmodule, exports) { + +"use strict"; + + +Object.defineProperty(exports, '__esModule', { value: true }); + +async function auth(token) { + const tokenType = token.split(/\./).length === 3 ? "app" : /^v\d+\./.test(token) ? "installation" : "oauth"; + return { + type: "token", + token: token, + tokenType + }; +} + +/** + * Prefix token for usage in the Authorization header + * + * @param token OAuth token or JSON Web Token + */ +function withAuthorizationPrefix(token) { + if (token.split(/\./).length === 3) { + return `bearer ${token}`; + } + + return `token ${token}`; +} + +async function hook(token, request, route, parameters) { + const endpoint = request.endpoint.merge(route, parameters); + endpoint.headers.authorization = withAuthorizationPrefix(token); + return request(endpoint); +} + +const createTokenAuth = function createTokenAuth(token) { + if (!token) { + throw new Error("[@octokit/auth-token] No token passed to createTokenAuth"); + } + + if (typeof token !== "string") { + throw new Error("[@octokit/auth-token] Token passed to createTokenAuth is not a string"); + } + + token = token.replace(/^(token|bearer) +/i, ""); + return Object.assign(auth.bind(null, token), { + hook: hook.bind(null, token) + }); +}; + +exports.createTokenAuth = createTokenAuth; +//# sourceMappingURL=index.js.map + + +/***/ }), + +/***/ 814: +/***/ (function(module, __unusedexports, __webpack_require__) { + +module.exports = which +which.sync = whichSync + +var isWindows = process.platform === 'win32' || + process.env.OSTYPE === 'cygwin' || + process.env.OSTYPE === 'msys' + +var path = __webpack_require__(622) +var COLON = isWindows ? ';' : ':' +var isexe = __webpack_require__(742) + +function getNotFoundError (cmd) { + var er = new Error('not found: ' + cmd) + er.code = 'ENOENT' + + return er +} + +function getPathInfo (cmd, opt) { + var colon = opt.colon || COLON + var pathEnv = opt.path || process.env.PATH || '' + var pathExt = [''] + + pathEnv = pathEnv.split(colon) + + var pathExtExe = '' + if (isWindows) { + pathEnv.unshift(process.cwd()) + pathExtExe = (opt.pathExt || process.env.PATHEXT || '.EXE;.CMD;.BAT;.COM') + pathExt = pathExtExe.split(colon) + + + // Always test the cmd itself first. isexe will check to make sure + // it's found in the pathExt set. + if (cmd.indexOf('.') !== -1 && pathExt[0] !== '') + pathExt.unshift('') + } + + // If it has a slash, then we don't bother searching the pathenv. + // just check the file itself, and that's it. + if (cmd.match(/\//) || isWindows && cmd.match(/\\/)) + pathEnv = [''] + + return { + env: pathEnv, + ext: pathExt, + extExe: pathExtExe + } +} + +function which (cmd, opt, cb) { + if (typeof opt === 'function') { + cb = opt + opt = {} + } + + var info = getPathInfo(cmd, opt) + var pathEnv = info.env + var pathExt = info.ext + var pathExtExe = info.extExe + var found = [] + + ;(function F (i, l) { + if (i === l) { + if (opt.all && found.length) + return cb(null, found) + else + return cb(getNotFoundError(cmd)) + } + + var pathPart = pathEnv[i] + if (pathPart.charAt(0) === '"' && pathPart.slice(-1) === '"') + pathPart = pathPart.slice(1, -1) + + var p = path.join(pathPart, cmd) + if (!pathPart && (/^\.[\\\/]/).test(cmd)) { + p = cmd.slice(0, 2) + p + } + ;(function E (ii, ll) { + if (ii === ll) return F(i + 1, l) + var ext = pathExt[ii] + isexe(p + ext, { pathExt: pathExtExe }, function (er, is) { + if (!er && is) { + if (opt.all) + found.push(p + ext) + else + return cb(null, p + ext) + } + return E(ii + 1, ll) + }) + })(0, pathExt.length) + })(0, pathEnv.length) +} + +function whichSync (cmd, opt) { + opt = opt || {} + + var info = getPathInfo(cmd, opt) + var pathEnv = info.env + var pathExt = info.ext + var pathExtExe = info.extExe + var found = [] + + for (var i = 0, l = pathEnv.length; i < l; i ++) { + var pathPart = pathEnv[i] + if (pathPart.charAt(0) === '"' && pathPart.slice(-1) === '"') + pathPart = pathPart.slice(1, -1) + + var p = path.join(pathPart, cmd) + if (!pathPart && /^\.[\\\/]/.test(cmd)) { + p = cmd.slice(0, 2) + p + } + for (var j = 0, ll = pathExt.length; j < ll; j ++) { + var cur = p + pathExt[j] + var is + try { + is = isexe.sync(cur, { pathExt: pathExtExe }) + if (is) { + if (opt.all) + found.push(cur) + else + return cur + } + } catch (ex) {} + } + } + + if (opt.all && found.length) + return found + + if (opt.nothrow) + return null + + throw getNotFoundError(cmd) +} + + +/***/ }), + +/***/ 816: +/***/ (function(module) { + +"use strict"; + +module.exports = /^#!.*/; + + +/***/ }), + +/***/ 818: +/***/ (function(module, __unusedexports, __webpack_require__) { + +module.exports = isexe +isexe.sync = sync + +var fs = __webpack_require__(747) + +function checkPathExt (path, options) { + var pathext = options.pathExt !== undefined ? + options.pathExt : process.env.PATHEXT + + if (!pathext) { + return true + } + + pathext = pathext.split(';') + if (pathext.indexOf('') !== -1) { + return true + } + for (var i = 0; i < pathext.length; i++) { + var p = pathext[i].toLowerCase() + if (p && path.substr(-p.length).toLowerCase() === p) { + return true + } + } + return false +} + +function checkStat (stat, path, options) { + if (!stat.isSymbolicLink() && !stat.isFile()) { + return false + } + return checkPathExt(path, options) +} + +function isexe (path, options, cb) { + fs.stat(path, function (er, stat) { + cb(er, er ? false : checkStat(stat, path, options)) + }) +} + +function sync (path, options) { + return checkStat(fs.statSync(path), path, options) +} + + +/***/ }), + +/***/ 819: +/***/ (function(module, __unusedexports, __webpack_require__) { + +"use strict"; + + + +var loader = __webpack_require__(457); +var dumper = __webpack_require__(685); + + +function deprecated(name) { + return function () { + throw new Error('Function ' + name + ' is deprecated and cannot be used.'); + }; +} + + +module.exports.Type = __webpack_require__(945); +module.exports.Schema = __webpack_require__(43); +module.exports.FAILSAFE_SCHEMA = __webpack_require__(581); +module.exports.JSON_SCHEMA = __webpack_require__(23); +module.exports.CORE_SCHEMA = __webpack_require__(611); +module.exports.DEFAULT_SAFE_SCHEMA = __webpack_require__(723); +module.exports.DEFAULT_FULL_SCHEMA = __webpack_require__(910); +module.exports.load = loader.load; +module.exports.loadAll = loader.loadAll; +module.exports.safeLoad = loader.safeLoad; +module.exports.safeLoadAll = loader.safeLoadAll; +module.exports.dump = dumper.dump; +module.exports.safeDump = dumper.safeDump; +module.exports.YAMLException = __webpack_require__(556); + +// Deprecated schema names from JS-YAML 2.0.x +module.exports.MINIMAL_SCHEMA = __webpack_require__(581); +module.exports.SAFE_SCHEMA = __webpack_require__(723); +module.exports.DEFAULT_SCHEMA = __webpack_require__(910); + +// Deprecated functions from JS-YAML 1.x.x +module.exports.scan = deprecated('scan'); +module.exports.parse = deprecated('parse'); +module.exports.compose = deprecated('compose'); +module.exports.addConstructor = deprecated('addConstructor'); + + +/***/ }), + +/***/ 835: +/***/ (function(module) { + +module.exports = require("url"); + +/***/ }), + +/***/ 842: +/***/ (function(__unusedmodule, exports, __webpack_require__) { + +"use strict"; + + +Object.defineProperty(exports, '__esModule', { value: true }); + +var deprecation = __webpack_require__(692); + +var endpointsByScope = { + actions: { + cancelWorkflowRun: { + method: "POST", + params: { + owner: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + }, + run_id: { + required: true, + type: "integer" + } + }, + url: "/repos/:owner/:repo/actions/runs/:run_id/cancel" + }, + createOrUpdateSecretForRepo: { + method: "PUT", + params: { + encrypted_value: { + type: "string" + }, + key_id: { + type: "string" + }, + name: { + required: true, + type: "string" + }, + owner: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/actions/secrets/:name" + }, + createRegistrationToken: { + method: "POST", + params: { + owner: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/actions/runners/registration-token" + }, + createRemoveToken: { + method: "POST", + params: { + owner: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/actions/runners/remove-token" + }, + deleteArtifact: { + method: "DELETE", + params: { + artifact_id: { + required: true, + type: "integer" + }, + owner: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/actions/artifacts/:artifact_id" + }, + deleteSecretFromRepo: { + method: "DELETE", + params: { + name: { + required: true, + type: "string" + }, + owner: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/actions/secrets/:name" + }, + downloadArtifact: { + method: "GET", + params: { + archive_format: { + required: true, + type: "string" + }, + artifact_id: { + required: true, + type: "integer" + }, + owner: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/actions/artifacts/:artifact_id/:archive_format" + }, + getArtifact: { + method: "GET", + params: { + artifact_id: { + required: true, + type: "integer" + }, + owner: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/actions/artifacts/:artifact_id" + }, + getPublicKey: { + method: "GET", + params: { + owner: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/actions/secrets/public-key" + }, + getSecret: { + method: "GET", + params: { + name: { + required: true, + type: "string" + }, + owner: { + required: true, + type: "string" + }, + page: { + type: "integer" + }, + per_page: { + type: "integer" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/actions/secrets/:name" + }, + getSelfHostedRunner: { + method: "GET", + params: { + owner: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + }, + runner_id: { + required: true, + type: "integer" + } + }, + url: "/repos/:owner/:repo/actions/runners/:runner_id" + }, + getWorkflow: { + method: "GET", + params: { + owner: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + }, + workflow_id: { + required: true, + type: "integer" + } + }, + url: "/repos/:owner/:repo/actions/workflows/:workflow_id" + }, + getWorkflowJob: { + method: "GET", + params: { + job_id: { + required: true, + type: "integer" + }, + owner: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/actions/jobs/:job_id" + }, + getWorkflowRun: { + method: "GET", + params: { + owner: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + }, + run_id: { + required: true, + type: "integer" + } + }, + url: "/repos/:owner/:repo/actions/runs/:run_id" + }, + listDownloadsForSelfHostedRunnerApplication: { + method: "GET", + params: { + owner: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/actions/runners/downloads" + }, + listJobsForWorkflowRun: { + method: "GET", + params: { + owner: { + required: true, + type: "string" + }, + page: { + type: "integer" + }, + per_page: { + type: "integer" + }, + repo: { + required: true, + type: "string" + }, + run_id: { + required: true, + type: "integer" + } + }, + url: "/repos/:owner/:repo/actions/runs/:run_id/jobs" + }, + listRepoWorkflowRuns: { + method: "GET", + params: { + actor: { + type: "string" + }, + branch: { + type: "string" + }, + event: { + type: "string" + }, + owner: { + required: true, + type: "string" + }, + page: { + type: "integer" + }, + per_page: { + type: "integer" + }, + repo: { + required: true, + type: "string" + }, + status: { + enum: ["completed", "status", "conclusion"], + type: "string" + } + }, + url: "/repos/:owner/:repo/actions/runs" + }, + listRepoWorkflows: { + method: "GET", + params: { + owner: { + required: true, + type: "string" + }, + page: { + type: "integer" + }, + per_page: { + type: "integer" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/actions/workflows" + }, + listSecretsForRepo: { + method: "GET", + params: { + owner: { + required: true, + type: "string" + }, + page: { + type: "integer" + }, + per_page: { + type: "integer" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/actions/secrets" + }, + listSelfHostedRunnersForRepo: { + method: "GET", + params: { + owner: { + required: true, + type: "string" + }, + page: { + type: "integer" + }, + per_page: { + type: "integer" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/actions/runners" + }, + listWorkflowJobLogs: { + method: "GET", + params: { + job_id: { + required: true, + type: "integer" + }, + owner: { + required: true, + type: "string" + }, + page: { + type: "integer" + }, + per_page: { + type: "integer" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/actions/jobs/:job_id/logs" + }, + listWorkflowRunArtifacts: { + method: "GET", + params: { + owner: { + required: true, + type: "string" + }, + page: { + type: "integer" + }, + per_page: { + type: "integer" + }, + repo: { + required: true, + type: "string" + }, + run_id: { + required: true, + type: "integer" + } + }, + url: "/repos/:owner/:repo/actions/runs/:run_id/artifacts" + }, + listWorkflowRunLogs: { + method: "GET", + params: { + owner: { + required: true, + type: "string" + }, + page: { + type: "integer" + }, + per_page: { + type: "integer" + }, + repo: { + required: true, + type: "string" + }, + run_id: { + required: true, + type: "integer" + } + }, + url: "/repos/:owner/:repo/actions/runs/:run_id/logs" + }, + listWorkflowRuns: { + method: "GET", + params: { + actor: { + type: "string" + }, + branch: { + type: "string" + }, + event: { + type: "string" + }, + owner: { + required: true, + type: "string" + }, + page: { + type: "integer" + }, + per_page: { + type: "integer" + }, + repo: { + required: true, + type: "string" + }, + status: { + enum: ["completed", "status", "conclusion"], + type: "string" + }, + workflow_id: { + required: true, + type: "integer" + } + }, + url: "/repos/:owner/:repo/actions/workflows/:workflow_id/runs" + }, + reRunWorkflow: { + method: "POST", + params: { + owner: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + }, + run_id: { + required: true, + type: "integer" + } + }, + url: "/repos/:owner/:repo/actions/runs/:run_id/rerun" + }, + removeSelfHostedRunner: { + method: "DELETE", + params: { + owner: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + }, + runner_id: { + required: true, + type: "integer" + } + }, + url: "/repos/:owner/:repo/actions/runners/:runner_id" + } + }, + activity: { + checkStarringRepo: { + method: "GET", + params: { + owner: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/user/starred/:owner/:repo" + }, + deleteRepoSubscription: { + method: "DELETE", + params: { + owner: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/subscription" + }, + deleteThreadSubscription: { + method: "DELETE", + params: { + thread_id: { + required: true, + type: "integer" + } + }, + url: "/notifications/threads/:thread_id/subscription" + }, + getRepoSubscription: { + method: "GET", + params: { + owner: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/subscription" + }, + getThread: { + method: "GET", + params: { + thread_id: { + required: true, + type: "integer" + } + }, + url: "/notifications/threads/:thread_id" + }, + getThreadSubscription: { + method: "GET", + params: { + thread_id: { + required: true, + type: "integer" + } + }, + url: "/notifications/threads/:thread_id/subscription" + }, + listEventsForOrg: { + method: "GET", + params: { + org: { + required: true, + type: "string" + }, + page: { + type: "integer" + }, + per_page: { + type: "integer" + }, + username: { + required: true, + type: "string" + } + }, + url: "/users/:username/events/orgs/:org" + }, + listEventsForUser: { + method: "GET", + params: { + page: { + type: "integer" + }, + per_page: { + type: "integer" + }, + username: { + required: true, + type: "string" + } + }, + url: "/users/:username/events" + }, + listFeeds: { + method: "GET", + params: {}, + url: "/feeds" + }, + listNotifications: { + method: "GET", + params: { + all: { + type: "boolean" + }, + before: { + type: "string" + }, + page: { + type: "integer" + }, + participating: { + type: "boolean" + }, + per_page: { + type: "integer" + }, + since: { + type: "string" + } + }, + url: "/notifications" + }, + listNotificationsForRepo: { + method: "GET", + params: { + all: { + type: "boolean" + }, + before: { + type: "string" + }, + owner: { + required: true, + type: "string" + }, + page: { + type: "integer" + }, + participating: { + type: "boolean" + }, + per_page: { + type: "integer" + }, + repo: { + required: true, + type: "string" + }, + since: { + type: "string" + } + }, + url: "/repos/:owner/:repo/notifications" + }, + listPublicEvents: { + method: "GET", + params: { + page: { + type: "integer" + }, + per_page: { + type: "integer" + } + }, + url: "/events" + }, + listPublicEventsForOrg: { + method: "GET", + params: { + org: { + required: true, + type: "string" + }, + page: { + type: "integer" + }, + per_page: { + type: "integer" + } + }, + url: "/orgs/:org/events" + }, + listPublicEventsForRepoNetwork: { + method: "GET", + params: { + owner: { + required: true, + type: "string" + }, + page: { + type: "integer" + }, + per_page: { + type: "integer" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/networks/:owner/:repo/events" + }, + listPublicEventsForUser: { + method: "GET", + params: { + page: { + type: "integer" + }, + per_page: { + type: "integer" + }, + username: { + required: true, + type: "string" + } + }, + url: "/users/:username/events/public" + }, + listReceivedEventsForUser: { + method: "GET", + params: { + page: { + type: "integer" + }, + per_page: { + type: "integer" + }, + username: { + required: true, + type: "string" + } + }, + url: "/users/:username/received_events" + }, + listReceivedPublicEventsForUser: { + method: "GET", + params: { + page: { + type: "integer" + }, + per_page: { + type: "integer" + }, + username: { + required: true, + type: "string" + } + }, + url: "/users/:username/received_events/public" + }, + listRepoEvents: { + method: "GET", + params: { + owner: { + required: true, + type: "string" + }, + page: { + type: "integer" + }, + per_page: { + type: "integer" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/events" + }, + listReposStarredByAuthenticatedUser: { + method: "GET", + params: { + direction: { + enum: ["asc", "desc"], + type: "string" + }, + page: { + type: "integer" + }, + per_page: { + type: "integer" + }, + sort: { + enum: ["created", "updated"], + type: "string" + } + }, + url: "/user/starred" + }, + listReposStarredByUser: { + method: "GET", + params: { + direction: { + enum: ["asc", "desc"], + type: "string" + }, + page: { + type: "integer" + }, + per_page: { + type: "integer" + }, + sort: { + enum: ["created", "updated"], + type: "string" + }, + username: { + required: true, + type: "string" + } + }, + url: "/users/:username/starred" + }, + listReposWatchedByUser: { + method: "GET", + params: { + page: { + type: "integer" + }, + per_page: { + type: "integer" + }, + username: { + required: true, + type: "string" + } + }, + url: "/users/:username/subscriptions" + }, + listStargazersForRepo: { + method: "GET", + params: { + owner: { + required: true, + type: "string" + }, + page: { + type: "integer" + }, + per_page: { + type: "integer" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/stargazers" + }, + listWatchedReposForAuthenticatedUser: { + method: "GET", + params: { + page: { + type: "integer" + }, + per_page: { + type: "integer" + } + }, + url: "/user/subscriptions" + }, + listWatchersForRepo: { + method: "GET", + params: { + owner: { + required: true, + type: "string" + }, + page: { + type: "integer" + }, + per_page: { + type: "integer" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/subscribers" + }, + markAsRead: { + method: "PUT", + params: { + last_read_at: { + type: "string" + } + }, + url: "/notifications" + }, + markNotificationsAsReadForRepo: { + method: "PUT", + params: { + last_read_at: { + type: "string" + }, + owner: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/notifications" + }, + markThreadAsRead: { + method: "PATCH", + params: { + thread_id: { + required: true, + type: "integer" + } + }, + url: "/notifications/threads/:thread_id" + }, + setRepoSubscription: { + method: "PUT", + params: { + ignored: { + type: "boolean" + }, + owner: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + }, + subscribed: { + type: "boolean" + } + }, + url: "/repos/:owner/:repo/subscription" + }, + setThreadSubscription: { + method: "PUT", + params: { + ignored: { + type: "boolean" + }, + thread_id: { + required: true, + type: "integer" + } + }, + url: "/notifications/threads/:thread_id/subscription" + }, + starRepo: { + method: "PUT", + params: { + owner: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/user/starred/:owner/:repo" + }, + unstarRepo: { + method: "DELETE", + params: { + owner: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/user/starred/:owner/:repo" + } + }, + apps: { + addRepoToInstallation: { + headers: { + accept: "application/vnd.github.machine-man-preview+json" + }, + method: "PUT", + params: { + installation_id: { + required: true, + type: "integer" + }, + repository_id: { + required: true, + type: "integer" + } + }, + url: "/user/installations/:installation_id/repositories/:repository_id" + }, + checkAccountIsAssociatedWithAny: { + method: "GET", + params: { + account_id: { + required: true, + type: "integer" + } + }, + url: "/marketplace_listing/accounts/:account_id" + }, + checkAccountIsAssociatedWithAnyStubbed: { + method: "GET", + params: { + account_id: { + required: true, + type: "integer" + } + }, + url: "/marketplace_listing/stubbed/accounts/:account_id" + }, + checkAuthorization: { + deprecated: "octokit.apps.checkAuthorization() is deprecated, see https://developer.github.com/v3/apps/oauth_applications/#check-an-authorization", + method: "GET", + params: { + access_token: { + required: true, + type: "string" + }, + client_id: { + required: true, + type: "string" + } + }, + url: "/applications/:client_id/tokens/:access_token" + }, + checkToken: { + headers: { + accept: "application/vnd.github.doctor-strange-preview+json" + }, + method: "POST", + params: { + access_token: { + type: "string" + }, + client_id: { + required: true, + type: "string" + } + }, + url: "/applications/:client_id/token" + }, + createContentAttachment: { + headers: { + accept: "application/vnd.github.corsair-preview+json" + }, + method: "POST", + params: { + body: { + required: true, + type: "string" + }, + content_reference_id: { + required: true, + type: "integer" + }, + title: { + required: true, + type: "string" + } + }, + url: "/content_references/:content_reference_id/attachments" + }, + createFromManifest: { + headers: { + accept: "application/vnd.github.fury-preview+json" + }, + method: "POST", + params: { + code: { + required: true, + type: "string" + } + }, + url: "/app-manifests/:code/conversions" + }, + createInstallationToken: { + headers: { + accept: "application/vnd.github.machine-man-preview+json" + }, + method: "POST", + params: { + installation_id: { + required: true, + type: "integer" + }, + permissions: { + type: "object" + }, + repository_ids: { + type: "integer[]" + } + }, + url: "/app/installations/:installation_id/access_tokens" + }, + deleteAuthorization: { + headers: { + accept: "application/vnd.github.doctor-strange-preview+json" + }, + method: "DELETE", + params: { + access_token: { + type: "string" + }, + client_id: { + required: true, + type: "string" + } + }, + url: "/applications/:client_id/grant" + }, + deleteInstallation: { + headers: { + accept: "application/vnd.github.gambit-preview+json,application/vnd.github.machine-man-preview+json" + }, + method: "DELETE", + params: { + installation_id: { + required: true, + type: "integer" + } + }, + url: "/app/installations/:installation_id" + }, + deleteToken: { + headers: { + accept: "application/vnd.github.doctor-strange-preview+json" + }, + method: "DELETE", + params: { + access_token: { + type: "string" + }, + client_id: { + required: true, + type: "string" + } + }, + url: "/applications/:client_id/token" + }, + findOrgInstallation: { + deprecated: "octokit.apps.findOrgInstallation() has been renamed to octokit.apps.getOrgInstallation() (2019-04-10)", + headers: { + accept: "application/vnd.github.machine-man-preview+json" + }, + method: "GET", + params: { + org: { + required: true, + type: "string" + } + }, + url: "/orgs/:org/installation" + }, + findRepoInstallation: { + deprecated: "octokit.apps.findRepoInstallation() has been renamed to octokit.apps.getRepoInstallation() (2019-04-10)", + headers: { + accept: "application/vnd.github.machine-man-preview+json" + }, + method: "GET", + params: { + owner: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/installation" + }, + findUserInstallation: { + deprecated: "octokit.apps.findUserInstallation() has been renamed to octokit.apps.getUserInstallation() (2019-04-10)", + headers: { + accept: "application/vnd.github.machine-man-preview+json" + }, + method: "GET", + params: { + username: { + required: true, + type: "string" + } + }, + url: "/users/:username/installation" + }, + getAuthenticated: { + headers: { + accept: "application/vnd.github.machine-man-preview+json" + }, + method: "GET", + params: {}, + url: "/app" + }, + getBySlug: { + headers: { + accept: "application/vnd.github.machine-man-preview+json" + }, + method: "GET", + params: { + app_slug: { + required: true, + type: "string" + } + }, + url: "/apps/:app_slug" + }, + getInstallation: { + headers: { + accept: "application/vnd.github.machine-man-preview+json" + }, + method: "GET", + params: { + installation_id: { + required: true, + type: "integer" + } + }, + url: "/app/installations/:installation_id" + }, + getOrgInstallation: { + headers: { + accept: "application/vnd.github.machine-man-preview+json" + }, + method: "GET", + params: { + org: { + required: true, + type: "string" + } + }, + url: "/orgs/:org/installation" + }, + getRepoInstallation: { + headers: { + accept: "application/vnd.github.machine-man-preview+json" + }, + method: "GET", + params: { + owner: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/installation" + }, + getUserInstallation: { + headers: { + accept: "application/vnd.github.machine-man-preview+json" + }, + method: "GET", + params: { + username: { + required: true, + type: "string" + } + }, + url: "/users/:username/installation" + }, + listAccountsUserOrOrgOnPlan: { + method: "GET", + params: { + direction: { + enum: ["asc", "desc"], + type: "string" + }, + page: { + type: "integer" + }, + per_page: { + type: "integer" + }, + plan_id: { + required: true, + type: "integer" + }, + sort: { + enum: ["created", "updated"], + type: "string" + } + }, + url: "/marketplace_listing/plans/:plan_id/accounts" + }, + listAccountsUserOrOrgOnPlanStubbed: { + method: "GET", + params: { + direction: { + enum: ["asc", "desc"], + type: "string" + }, + page: { + type: "integer" + }, + per_page: { + type: "integer" + }, + plan_id: { + required: true, + type: "integer" + }, + sort: { + enum: ["created", "updated"], + type: "string" + } + }, + url: "/marketplace_listing/stubbed/plans/:plan_id/accounts" + }, + listInstallationReposForAuthenticatedUser: { + headers: { + accept: "application/vnd.github.machine-man-preview+json" + }, + method: "GET", + params: { + installation_id: { + required: true, + type: "integer" + }, + page: { + type: "integer" + }, + per_page: { + type: "integer" + } + }, + url: "/user/installations/:installation_id/repositories" + }, + listInstallations: { + headers: { + accept: "application/vnd.github.machine-man-preview+json" + }, + method: "GET", + params: { + page: { + type: "integer" + }, + per_page: { + type: "integer" + } + }, + url: "/app/installations" + }, + listInstallationsForAuthenticatedUser: { + headers: { + accept: "application/vnd.github.machine-man-preview+json" + }, + method: "GET", + params: { + page: { + type: "integer" + }, + per_page: { + type: "integer" + } + }, + url: "/user/installations" + }, + listMarketplacePurchasesForAuthenticatedUser: { + method: "GET", + params: { + page: { + type: "integer" + }, + per_page: { + type: "integer" + } + }, + url: "/user/marketplace_purchases" + }, + listMarketplacePurchasesForAuthenticatedUserStubbed: { + method: "GET", + params: { + page: { + type: "integer" + }, + per_page: { + type: "integer" + } + }, + url: "/user/marketplace_purchases/stubbed" + }, + listPlans: { + method: "GET", + params: { + page: { + type: "integer" + }, + per_page: { + type: "integer" + } + }, + url: "/marketplace_listing/plans" + }, + listPlansStubbed: { + method: "GET", + params: { + page: { + type: "integer" + }, + per_page: { + type: "integer" + } + }, + url: "/marketplace_listing/stubbed/plans" + }, + listRepos: { + headers: { + accept: "application/vnd.github.machine-man-preview+json" + }, + method: "GET", + params: { + page: { + type: "integer" + }, + per_page: { + type: "integer" + } + }, + url: "/installation/repositories" + }, + removeRepoFromInstallation: { + headers: { + accept: "application/vnd.github.machine-man-preview+json" + }, + method: "DELETE", + params: { + installation_id: { + required: true, + type: "integer" + }, + repository_id: { + required: true, + type: "integer" + } + }, + url: "/user/installations/:installation_id/repositories/:repository_id" + }, + resetAuthorization: { + deprecated: "octokit.apps.resetAuthorization() is deprecated, see https://developer.github.com/v3/apps/oauth_applications/#reset-an-authorization", + method: "POST", + params: { + access_token: { + required: true, + type: "string" + }, + client_id: { + required: true, + type: "string" + } + }, + url: "/applications/:client_id/tokens/:access_token" + }, + resetToken: { + headers: { + accept: "application/vnd.github.doctor-strange-preview+json" + }, + method: "PATCH", + params: { + access_token: { + type: "string" + }, + client_id: { + required: true, + type: "string" + } + }, + url: "/applications/:client_id/token" + }, + revokeAuthorizationForApplication: { + deprecated: "octokit.apps.revokeAuthorizationForApplication() is deprecated, see https://developer.github.com/v3/apps/oauth_applications/#revoke-an-authorization-for-an-application", + method: "DELETE", + params: { + access_token: { + required: true, + type: "string" + }, + client_id: { + required: true, + type: "string" + } + }, + url: "/applications/:client_id/tokens/:access_token" + }, + revokeGrantForApplication: { + deprecated: "octokit.apps.revokeGrantForApplication() is deprecated, see https://developer.github.com/v3/apps/oauth_applications/#revoke-a-grant-for-an-application", + method: "DELETE", + params: { + access_token: { + required: true, + type: "string" + }, + client_id: { + required: true, + type: "string" + } + }, + url: "/applications/:client_id/grants/:access_token" + }, + revokeInstallationToken: { + headers: { + accept: "application/vnd.github.gambit-preview+json" + }, + method: "DELETE", + params: {}, + url: "/installation/token" + } + }, + checks: { + create: { + headers: { + accept: "application/vnd.github.antiope-preview+json" + }, + method: "POST", + params: { + actions: { + type: "object[]" + }, + "actions[].description": { + required: true, + type: "string" + }, + "actions[].identifier": { + required: true, + type: "string" + }, + "actions[].label": { + required: true, + type: "string" + }, + completed_at: { + type: "string" + }, + conclusion: { + enum: ["success", "failure", "neutral", "cancelled", "timed_out", "action_required"], + type: "string" + }, + details_url: { + type: "string" + }, + external_id: { + type: "string" + }, + head_sha: { + required: true, + type: "string" + }, + name: { + required: true, + type: "string" + }, + output: { + type: "object" + }, + "output.annotations": { + type: "object[]" + }, + "output.annotations[].annotation_level": { + enum: ["notice", "warning", "failure"], + required: true, + type: "string" + }, + "output.annotations[].end_column": { + type: "integer" + }, + "output.annotations[].end_line": { + required: true, + type: "integer" + }, + "output.annotations[].message": { + required: true, + type: "string" + }, + "output.annotations[].path": { + required: true, + type: "string" + }, + "output.annotations[].raw_details": { + type: "string" + }, + "output.annotations[].start_column": { + type: "integer" + }, + "output.annotations[].start_line": { + required: true, + type: "integer" + }, + "output.annotations[].title": { + type: "string" + }, + "output.images": { + type: "object[]" + }, + "output.images[].alt": { + required: true, + type: "string" + }, + "output.images[].caption": { + type: "string" + }, + "output.images[].image_url": { + required: true, + type: "string" + }, + "output.summary": { + required: true, + type: "string" + }, + "output.text": { + type: "string" + }, + "output.title": { + required: true, + type: "string" + }, + owner: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + }, + started_at: { + type: "string" + }, + status: { + enum: ["queued", "in_progress", "completed"], + type: "string" + } + }, + url: "/repos/:owner/:repo/check-runs" + }, + createSuite: { + headers: { + accept: "application/vnd.github.antiope-preview+json" + }, + method: "POST", + params: { + head_sha: { + required: true, + type: "string" + }, + owner: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/check-suites" + }, + get: { + headers: { + accept: "application/vnd.github.antiope-preview+json" + }, + method: "GET", + params: { + check_run_id: { + required: true, + type: "integer" + }, + owner: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/check-runs/:check_run_id" + }, + getSuite: { + headers: { + accept: "application/vnd.github.antiope-preview+json" + }, + method: "GET", + params: { + check_suite_id: { + required: true, + type: "integer" + }, + owner: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/check-suites/:check_suite_id" + }, + listAnnotations: { + headers: { + accept: "application/vnd.github.antiope-preview+json" + }, + method: "GET", + params: { + check_run_id: { + required: true, + type: "integer" + }, + owner: { + required: true, + type: "string" + }, + page: { + type: "integer" + }, + per_page: { + type: "integer" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/check-runs/:check_run_id/annotations" + }, + listForRef: { + headers: { + accept: "application/vnd.github.antiope-preview+json" + }, + method: "GET", + params: { + check_name: { + type: "string" + }, + filter: { + enum: ["latest", "all"], + type: "string" + }, + owner: { + required: true, + type: "string" + }, + page: { + type: "integer" + }, + per_page: { + type: "integer" + }, + ref: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + }, + status: { + enum: ["queued", "in_progress", "completed"], + type: "string" + } + }, + url: "/repos/:owner/:repo/commits/:ref/check-runs" + }, + listForSuite: { + headers: { + accept: "application/vnd.github.antiope-preview+json" + }, + method: "GET", + params: { + check_name: { + type: "string" + }, + check_suite_id: { + required: true, + type: "integer" + }, + filter: { + enum: ["latest", "all"], + type: "string" + }, + owner: { + required: true, + type: "string" + }, + page: { + type: "integer" + }, + per_page: { + type: "integer" + }, + repo: { + required: true, + type: "string" + }, + status: { + enum: ["queued", "in_progress", "completed"], + type: "string" + } + }, + url: "/repos/:owner/:repo/check-suites/:check_suite_id/check-runs" + }, + listSuitesForRef: { + headers: { + accept: "application/vnd.github.antiope-preview+json" + }, + method: "GET", + params: { + app_id: { + type: "integer" + }, + check_name: { + type: "string" + }, + owner: { + required: true, + type: "string" + }, + page: { + type: "integer" + }, + per_page: { + type: "integer" + }, + ref: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/commits/:ref/check-suites" + }, + rerequestSuite: { + headers: { + accept: "application/vnd.github.antiope-preview+json" + }, + method: "POST", + params: { + check_suite_id: { + required: true, + type: "integer" + }, + owner: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/check-suites/:check_suite_id/rerequest" + }, + setSuitesPreferences: { + headers: { + accept: "application/vnd.github.antiope-preview+json" + }, + method: "PATCH", + params: { + auto_trigger_checks: { + type: "object[]" + }, + "auto_trigger_checks[].app_id": { + required: true, + type: "integer" + }, + "auto_trigger_checks[].setting": { + required: true, + type: "boolean" + }, + owner: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/check-suites/preferences" + }, + update: { + headers: { + accept: "application/vnd.github.antiope-preview+json" + }, + method: "PATCH", + params: { + actions: { + type: "object[]" + }, + "actions[].description": { + required: true, + type: "string" + }, + "actions[].identifier": { + required: true, + type: "string" + }, + "actions[].label": { + required: true, + type: "string" + }, + check_run_id: { + required: true, + type: "integer" + }, + completed_at: { + type: "string" + }, + conclusion: { + enum: ["success", "failure", "neutral", "cancelled", "timed_out", "action_required"], + type: "string" + }, + details_url: { + type: "string" + }, + external_id: { + type: "string" + }, + name: { + type: "string" + }, + output: { + type: "object" + }, + "output.annotations": { + type: "object[]" + }, + "output.annotations[].annotation_level": { + enum: ["notice", "warning", "failure"], + required: true, + type: "string" + }, + "output.annotations[].end_column": { + type: "integer" + }, + "output.annotations[].end_line": { + required: true, + type: "integer" + }, + "output.annotations[].message": { + required: true, + type: "string" + }, + "output.annotations[].path": { + required: true, + type: "string" + }, + "output.annotations[].raw_details": { + type: "string" + }, + "output.annotations[].start_column": { + type: "integer" + }, + "output.annotations[].start_line": { + required: true, + type: "integer" + }, + "output.annotations[].title": { + type: "string" + }, + "output.images": { + type: "object[]" + }, + "output.images[].alt": { + required: true, + type: "string" + }, + "output.images[].caption": { + type: "string" + }, + "output.images[].image_url": { + required: true, + type: "string" + }, + "output.summary": { + required: true, + type: "string" + }, + "output.text": { + type: "string" + }, + "output.title": { + type: "string" + }, + owner: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + }, + started_at: { + type: "string" + }, + status: { + enum: ["queued", "in_progress", "completed"], + type: "string" + } + }, + url: "/repos/:owner/:repo/check-runs/:check_run_id" + } + }, + codesOfConduct: { + getConductCode: { + headers: { + accept: "application/vnd.github.scarlet-witch-preview+json" + }, + method: "GET", + params: { + key: { + required: true, + type: "string" + } + }, + url: "/codes_of_conduct/:key" + }, + getForRepo: { + headers: { + accept: "application/vnd.github.scarlet-witch-preview+json" + }, + method: "GET", + params: { + owner: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/community/code_of_conduct" + }, + listConductCodes: { + headers: { + accept: "application/vnd.github.scarlet-witch-preview+json" + }, + method: "GET", + params: {}, + url: "/codes_of_conduct" + } + }, + emojis: { + get: { + method: "GET", + params: {}, + url: "/emojis" + } + }, + gists: { + checkIsStarred: { + method: "GET", + params: { + gist_id: { + required: true, + type: "string" + } + }, + url: "/gists/:gist_id/star" + }, + create: { + method: "POST", + params: { + description: { + type: "string" + }, + files: { + required: true, + type: "object" + }, + "files.content": { + type: "string" + }, + public: { + type: "boolean" + } + }, + url: "/gists" + }, + createComment: { + method: "POST", + params: { + body: { + required: true, + type: "string" + }, + gist_id: { + required: true, + type: "string" + } + }, + url: "/gists/:gist_id/comments" + }, + delete: { + method: "DELETE", + params: { + gist_id: { + required: true, + type: "string" + } + }, + url: "/gists/:gist_id" + }, + deleteComment: { + method: "DELETE", + params: { + comment_id: { + required: true, + type: "integer" + }, + gist_id: { + required: true, + type: "string" + } + }, + url: "/gists/:gist_id/comments/:comment_id" + }, + fork: { + method: "POST", + params: { + gist_id: { + required: true, + type: "string" + } + }, + url: "/gists/:gist_id/forks" + }, + get: { + method: "GET", + params: { + gist_id: { + required: true, + type: "string" + } + }, + url: "/gists/:gist_id" + }, + getComment: { + method: "GET", + params: { + comment_id: { + required: true, + type: "integer" + }, + gist_id: { + required: true, + type: "string" + } + }, + url: "/gists/:gist_id/comments/:comment_id" + }, + getRevision: { + method: "GET", + params: { + gist_id: { + required: true, + type: "string" + }, + sha: { + required: true, + type: "string" + } + }, + url: "/gists/:gist_id/:sha" + }, + list: { + method: "GET", + params: { + page: { + type: "integer" + }, + per_page: { + type: "integer" + }, + since: { + type: "string" + } + }, + url: "/gists" + }, + listComments: { + method: "GET", + params: { + gist_id: { + required: true, + type: "string" + }, + page: { + type: "integer" + }, + per_page: { + type: "integer" + } + }, + url: "/gists/:gist_id/comments" + }, + listCommits: { + method: "GET", + params: { + gist_id: { + required: true, + type: "string" + }, + page: { + type: "integer" + }, + per_page: { + type: "integer" + } + }, + url: "/gists/:gist_id/commits" + }, + listForks: { + method: "GET", + params: { + gist_id: { + required: true, + type: "string" + }, + page: { + type: "integer" + }, + per_page: { + type: "integer" + } + }, + url: "/gists/:gist_id/forks" + }, + listPublic: { + method: "GET", + params: { + page: { + type: "integer" + }, + per_page: { + type: "integer" + }, + since: { + type: "string" + } + }, + url: "/gists/public" + }, + listPublicForUser: { + method: "GET", + params: { + page: { + type: "integer" + }, + per_page: { + type: "integer" + }, + since: { + type: "string" + }, + username: { + required: true, + type: "string" + } + }, + url: "/users/:username/gists" + }, + listStarred: { + method: "GET", + params: { + page: { + type: "integer" + }, + per_page: { + type: "integer" + }, + since: { + type: "string" + } + }, + url: "/gists/starred" + }, + star: { + method: "PUT", + params: { + gist_id: { + required: true, + type: "string" + } + }, + url: "/gists/:gist_id/star" + }, + unstar: { + method: "DELETE", + params: { + gist_id: { + required: true, + type: "string" + } + }, + url: "/gists/:gist_id/star" + }, + update: { + method: "PATCH", + params: { + description: { + type: "string" + }, + files: { + type: "object" + }, + "files.content": { + type: "string" + }, + "files.filename": { + type: "string" + }, + gist_id: { + required: true, + type: "string" + } + }, + url: "/gists/:gist_id" + }, + updateComment: { + method: "PATCH", + params: { + body: { + required: true, + type: "string" + }, + comment_id: { + required: true, + type: "integer" + }, + gist_id: { + required: true, + type: "string" + } + }, + url: "/gists/:gist_id/comments/:comment_id" + } + }, + git: { + createBlob: { + method: "POST", + params: { + content: { + required: true, + type: "string" + }, + encoding: { + type: "string" + }, + owner: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/git/blobs" + }, + createCommit: { + method: "POST", + params: { + author: { + type: "object" + }, + "author.date": { + type: "string" + }, + "author.email": { + type: "string" + }, + "author.name": { + type: "string" + }, + committer: { + type: "object" + }, + "committer.date": { + type: "string" + }, + "committer.email": { + type: "string" + }, + "committer.name": { + type: "string" + }, + message: { + required: true, + type: "string" + }, + owner: { + required: true, + type: "string" + }, + parents: { + required: true, + type: "string[]" + }, + repo: { + required: true, + type: "string" + }, + signature: { + type: "string" + }, + tree: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/git/commits" + }, + createRef: { + method: "POST", + params: { + owner: { + required: true, + type: "string" + }, + ref: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + }, + sha: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/git/refs" + }, + createTag: { + method: "POST", + params: { + message: { + required: true, + type: "string" + }, + object: { + required: true, + type: "string" + }, + owner: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + }, + tag: { + required: true, + type: "string" + }, + tagger: { + type: "object" + }, + "tagger.date": { + type: "string" + }, + "tagger.email": { + type: "string" + }, + "tagger.name": { + type: "string" + }, + type: { + enum: ["commit", "tree", "blob"], + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/git/tags" + }, + createTree: { + method: "POST", + params: { + base_tree: { + type: "string" + }, + owner: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + }, + tree: { + required: true, + type: "object[]" + }, + "tree[].content": { + type: "string" + }, + "tree[].mode": { + enum: ["100644", "100755", "040000", "160000", "120000"], + type: "string" + }, + "tree[].path": { + type: "string" + }, + "tree[].sha": { + allowNull: true, + type: "string" + }, + "tree[].type": { + enum: ["blob", "tree", "commit"], + type: "string" + } + }, + url: "/repos/:owner/:repo/git/trees" + }, + deleteRef: { + method: "DELETE", + params: { + owner: { + required: true, + type: "string" + }, + ref: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/git/refs/:ref" + }, + getBlob: { + method: "GET", + params: { + file_sha: { + required: true, + type: "string" + }, + owner: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/git/blobs/:file_sha" + }, + getCommit: { + method: "GET", + params: { + commit_sha: { + required: true, + type: "string" + }, + owner: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/git/commits/:commit_sha" + }, + getRef: { + method: "GET", + params: { + owner: { + required: true, + type: "string" + }, + ref: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/git/ref/:ref" + }, + getTag: { + method: "GET", + params: { + owner: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + }, + tag_sha: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/git/tags/:tag_sha" + }, + getTree: { + method: "GET", + params: { + owner: { + required: true, + type: "string" + }, + recursive: { + enum: ["1"], + type: "integer" + }, + repo: { + required: true, + type: "string" + }, + tree_sha: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/git/trees/:tree_sha" + }, + listMatchingRefs: { + method: "GET", + params: { + owner: { + required: true, + type: "string" + }, + page: { + type: "integer" + }, + per_page: { + type: "integer" + }, + ref: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/git/matching-refs/:ref" + }, + listRefs: { + method: "GET", + params: { + namespace: { + type: "string" + }, + owner: { + required: true, + type: "string" + }, + page: { + type: "integer" + }, + per_page: { + type: "integer" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/git/refs/:namespace" + }, + updateRef: { + method: "PATCH", + params: { + force: { + type: "boolean" + }, + owner: { + required: true, + type: "string" + }, + ref: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + }, + sha: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/git/refs/:ref" + } + }, + gitignore: { + getTemplate: { + method: "GET", + params: { + name: { + required: true, + type: "string" + } + }, + url: "/gitignore/templates/:name" + }, + listTemplates: { + method: "GET", + params: {}, + url: "/gitignore/templates" + } + }, + interactions: { + addOrUpdateRestrictionsForOrg: { + headers: { + accept: "application/vnd.github.sombra-preview+json" + }, + method: "PUT", + params: { + limit: { + enum: ["existing_users", "contributors_only", "collaborators_only"], + required: true, + type: "string" + }, + org: { + required: true, + type: "string" + } + }, + url: "/orgs/:org/interaction-limits" + }, + addOrUpdateRestrictionsForRepo: { + headers: { + accept: "application/vnd.github.sombra-preview+json" + }, + method: "PUT", + params: { + limit: { + enum: ["existing_users", "contributors_only", "collaborators_only"], + required: true, + type: "string" + }, + owner: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/interaction-limits" + }, + getRestrictionsForOrg: { + headers: { + accept: "application/vnd.github.sombra-preview+json" + }, + method: "GET", + params: { + org: { + required: true, + type: "string" + } + }, + url: "/orgs/:org/interaction-limits" + }, + getRestrictionsForRepo: { + headers: { + accept: "application/vnd.github.sombra-preview+json" + }, + method: "GET", + params: { + owner: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/interaction-limits" + }, + removeRestrictionsForOrg: { + headers: { + accept: "application/vnd.github.sombra-preview+json" + }, + method: "DELETE", + params: { + org: { + required: true, + type: "string" + } + }, + url: "/orgs/:org/interaction-limits" + }, + removeRestrictionsForRepo: { + headers: { + accept: "application/vnd.github.sombra-preview+json" + }, + method: "DELETE", + params: { + owner: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/interaction-limits" + } + }, + issues: { + addAssignees: { + method: "POST", + params: { + assignees: { + type: "string[]" + }, + issue_number: { + required: true, + type: "integer" + }, + number: { + alias: "issue_number", + deprecated: true, + type: "integer" + }, + owner: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/issues/:issue_number/assignees" + }, + addLabels: { + method: "POST", + params: { + issue_number: { + required: true, + type: "integer" + }, + labels: { + required: true, + type: "string[]" + }, + number: { + alias: "issue_number", + deprecated: true, + type: "integer" + }, + owner: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/issues/:issue_number/labels" + }, + checkAssignee: { + method: "GET", + params: { + assignee: { + required: true, + type: "string" + }, + owner: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/assignees/:assignee" + }, + create: { + method: "POST", + params: { + assignee: { + type: "string" + }, + assignees: { + type: "string[]" + }, + body: { + type: "string" + }, + labels: { + type: "string[]" + }, + milestone: { + type: "integer" + }, + owner: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + }, + title: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/issues" + }, + createComment: { + method: "POST", + params: { + body: { + required: true, + type: "string" + }, + issue_number: { + required: true, + type: "integer" + }, + number: { + alias: "issue_number", + deprecated: true, + type: "integer" + }, + owner: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/issues/:issue_number/comments" + }, + createLabel: { + method: "POST", + params: { + color: { + required: true, + type: "string" + }, + description: { + type: "string" + }, + name: { + required: true, + type: "string" + }, + owner: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/labels" + }, + createMilestone: { + method: "POST", + params: { + description: { + type: "string" + }, + due_on: { + type: "string" + }, + owner: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + }, + state: { + enum: ["open", "closed"], + type: "string" + }, + title: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/milestones" + }, + deleteComment: { + method: "DELETE", + params: { + comment_id: { + required: true, + type: "integer" + }, + owner: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/issues/comments/:comment_id" + }, + deleteLabel: { + method: "DELETE", + params: { + name: { + required: true, + type: "string" + }, + owner: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/labels/:name" + }, + deleteMilestone: { + method: "DELETE", + params: { + milestone_number: { + required: true, + type: "integer" + }, + number: { + alias: "milestone_number", + deprecated: true, + type: "integer" + }, + owner: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/milestones/:milestone_number" + }, + get: { + method: "GET", + params: { + issue_number: { + required: true, + type: "integer" + }, + number: { + alias: "issue_number", + deprecated: true, + type: "integer" + }, + owner: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/issues/:issue_number" + }, + getComment: { + method: "GET", + params: { + comment_id: { + required: true, + type: "integer" + }, + owner: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/issues/comments/:comment_id" + }, + getEvent: { + method: "GET", + params: { + event_id: { + required: true, + type: "integer" + }, + owner: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/issues/events/:event_id" + }, + getLabel: { + method: "GET", + params: { + name: { + required: true, + type: "string" + }, + owner: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/labels/:name" + }, + getMilestone: { + method: "GET", + params: { + milestone_number: { + required: true, + type: "integer" + }, + number: { + alias: "milestone_number", + deprecated: true, + type: "integer" + }, + owner: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/milestones/:milestone_number" + }, + list: { + method: "GET", + params: { + direction: { + enum: ["asc", "desc"], + type: "string" + }, + filter: { + enum: ["assigned", "created", "mentioned", "subscribed", "all"], + type: "string" + }, + labels: { + type: "string" + }, + page: { + type: "integer" + }, + per_page: { + type: "integer" + }, + since: { + type: "string" + }, + sort: { + enum: ["created", "updated", "comments"], + type: "string" + }, + state: { + enum: ["open", "closed", "all"], + type: "string" + } + }, + url: "/issues" + }, + listAssignees: { + method: "GET", + params: { + owner: { + required: true, + type: "string" + }, + page: { + type: "integer" + }, + per_page: { + type: "integer" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/assignees" + }, + listComments: { + method: "GET", + params: { + issue_number: { + required: true, + type: "integer" + }, + number: { + alias: "issue_number", + deprecated: true, + type: "integer" + }, + owner: { + required: true, + type: "string" + }, + page: { + type: "integer" + }, + per_page: { + type: "integer" + }, + repo: { + required: true, + type: "string" + }, + since: { + type: "string" + } + }, + url: "/repos/:owner/:repo/issues/:issue_number/comments" + }, + listCommentsForRepo: { + method: "GET", + params: { + direction: { + enum: ["asc", "desc"], + type: "string" + }, + owner: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + }, + since: { + type: "string" + }, + sort: { + enum: ["created", "updated"], + type: "string" + } + }, + url: "/repos/:owner/:repo/issues/comments" + }, + listEvents: { + method: "GET", + params: { + issue_number: { + required: true, + type: "integer" + }, + number: { + alias: "issue_number", + deprecated: true, + type: "integer" + }, + owner: { + required: true, + type: "string" + }, + page: { + type: "integer" + }, + per_page: { + type: "integer" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/issues/:issue_number/events" + }, + listEventsForRepo: { + method: "GET", + params: { + owner: { + required: true, + type: "string" + }, + page: { + type: "integer" + }, + per_page: { + type: "integer" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/issues/events" + }, + listEventsForTimeline: { + headers: { + accept: "application/vnd.github.mockingbird-preview+json" + }, + method: "GET", + params: { + issue_number: { + required: true, + type: "integer" + }, + number: { + alias: "issue_number", + deprecated: true, + type: "integer" + }, + owner: { + required: true, + type: "string" + }, + page: { + type: "integer" + }, + per_page: { + type: "integer" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/issues/:issue_number/timeline" + }, + listForAuthenticatedUser: { + method: "GET", + params: { + direction: { + enum: ["asc", "desc"], + type: "string" + }, + filter: { + enum: ["assigned", "created", "mentioned", "subscribed", "all"], + type: "string" + }, + labels: { + type: "string" + }, + page: { + type: "integer" + }, + per_page: { + type: "integer" + }, + since: { + type: "string" + }, + sort: { + enum: ["created", "updated", "comments"], + type: "string" + }, + state: { + enum: ["open", "closed", "all"], + type: "string" + } + }, + url: "/user/issues" + }, + listForOrg: { + method: "GET", + params: { + direction: { + enum: ["asc", "desc"], + type: "string" + }, + filter: { + enum: ["assigned", "created", "mentioned", "subscribed", "all"], + type: "string" + }, + labels: { + type: "string" + }, + org: { + required: true, + type: "string" + }, + page: { + type: "integer" + }, + per_page: { + type: "integer" + }, + since: { + type: "string" + }, + sort: { + enum: ["created", "updated", "comments"], + type: "string" + }, + state: { + enum: ["open", "closed", "all"], + type: "string" + } + }, + url: "/orgs/:org/issues" + }, + listForRepo: { + method: "GET", + params: { + assignee: { + type: "string" + }, + creator: { + type: "string" + }, + direction: { + enum: ["asc", "desc"], + type: "string" + }, + labels: { + type: "string" + }, + mentioned: { + type: "string" + }, + milestone: { + type: "string" + }, + owner: { + required: true, + type: "string" + }, + page: { + type: "integer" + }, + per_page: { + type: "integer" + }, + repo: { + required: true, + type: "string" + }, + since: { + type: "string" + }, + sort: { + enum: ["created", "updated", "comments"], + type: "string" + }, + state: { + enum: ["open", "closed", "all"], + type: "string" + } + }, + url: "/repos/:owner/:repo/issues" + }, + listLabelsForMilestone: { + method: "GET", + params: { + milestone_number: { + required: true, + type: "integer" + }, + number: { + alias: "milestone_number", + deprecated: true, + type: "integer" + }, + owner: { + required: true, + type: "string" + }, + page: { + type: "integer" + }, + per_page: { + type: "integer" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/milestones/:milestone_number/labels" + }, + listLabelsForRepo: { + method: "GET", + params: { + owner: { + required: true, + type: "string" + }, + page: { + type: "integer" + }, + per_page: { + type: "integer" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/labels" + }, + listLabelsOnIssue: { + method: "GET", + params: { + issue_number: { + required: true, + type: "integer" + }, + number: { + alias: "issue_number", + deprecated: true, + type: "integer" + }, + owner: { + required: true, + type: "string" + }, + page: { + type: "integer" + }, + per_page: { + type: "integer" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/issues/:issue_number/labels" + }, + listMilestonesForRepo: { + method: "GET", + params: { + direction: { + enum: ["asc", "desc"], + type: "string" + }, + owner: { + required: true, + type: "string" + }, + page: { + type: "integer" + }, + per_page: { + type: "integer" + }, + repo: { + required: true, + type: "string" + }, + sort: { + enum: ["due_on", "completeness"], + type: "string" + }, + state: { + enum: ["open", "closed", "all"], + type: "string" + } + }, + url: "/repos/:owner/:repo/milestones" + }, + lock: { + method: "PUT", + params: { + issue_number: { + required: true, + type: "integer" + }, + lock_reason: { + enum: ["off-topic", "too heated", "resolved", "spam"], + type: "string" + }, + number: { + alias: "issue_number", + deprecated: true, + type: "integer" + }, + owner: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/issues/:issue_number/lock" + }, + removeAssignees: { + method: "DELETE", + params: { + assignees: { + type: "string[]" + }, + issue_number: { + required: true, + type: "integer" + }, + number: { + alias: "issue_number", + deprecated: true, + type: "integer" + }, + owner: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/issues/:issue_number/assignees" + }, + removeLabel: { + method: "DELETE", + params: { + issue_number: { + required: true, + type: "integer" + }, + name: { + required: true, + type: "string" + }, + number: { + alias: "issue_number", + deprecated: true, + type: "integer" + }, + owner: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/issues/:issue_number/labels/:name" + }, + removeLabels: { + method: "DELETE", + params: { + issue_number: { + required: true, + type: "integer" + }, + number: { + alias: "issue_number", + deprecated: true, + type: "integer" + }, + owner: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/issues/:issue_number/labels" + }, + replaceLabels: { + method: "PUT", + params: { + issue_number: { + required: true, + type: "integer" + }, + labels: { + type: "string[]" + }, + number: { + alias: "issue_number", + deprecated: true, + type: "integer" + }, + owner: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/issues/:issue_number/labels" + }, + unlock: { + method: "DELETE", + params: { + issue_number: { + required: true, + type: "integer" + }, + number: { + alias: "issue_number", + deprecated: true, + type: "integer" + }, + owner: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/issues/:issue_number/lock" + }, + update: { + method: "PATCH", + params: { + assignee: { + type: "string" + }, + assignees: { + type: "string[]" + }, + body: { + type: "string" + }, + issue_number: { + required: true, + type: "integer" + }, + labels: { + type: "string[]" + }, + milestone: { + allowNull: true, + type: "integer" + }, + number: { + alias: "issue_number", + deprecated: true, + type: "integer" + }, + owner: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + }, + state: { + enum: ["open", "closed"], + type: "string" + }, + title: { + type: "string" + } + }, + url: "/repos/:owner/:repo/issues/:issue_number" + }, + updateComment: { + method: "PATCH", + params: { + body: { + required: true, + type: "string" + }, + comment_id: { + required: true, + type: "integer" + }, + owner: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/issues/comments/:comment_id" + }, + updateLabel: { + method: "PATCH", + params: { + color: { + type: "string" + }, + current_name: { + required: true, + type: "string" + }, + description: { + type: "string" + }, + name: { + type: "string" + }, + owner: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/labels/:current_name" + }, + updateMilestone: { + method: "PATCH", + params: { + description: { + type: "string" + }, + due_on: { + type: "string" + }, + milestone_number: { + required: true, + type: "integer" + }, + number: { + alias: "milestone_number", + deprecated: true, + type: "integer" + }, + owner: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + }, + state: { + enum: ["open", "closed"], + type: "string" + }, + title: { + type: "string" + } + }, + url: "/repos/:owner/:repo/milestones/:milestone_number" + } + }, + licenses: { + get: { + method: "GET", + params: { + license: { + required: true, + type: "string" + } + }, + url: "/licenses/:license" + }, + getForRepo: { + method: "GET", + params: { + owner: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/license" + }, + list: { + deprecated: "octokit.licenses.list() has been renamed to octokit.licenses.listCommonlyUsed() (2019-03-05)", + method: "GET", + params: {}, + url: "/licenses" + }, + listCommonlyUsed: { + method: "GET", + params: {}, + url: "/licenses" + } + }, + markdown: { + render: { + method: "POST", + params: { + context: { + type: "string" + }, + mode: { + enum: ["markdown", "gfm"], + type: "string" + }, + text: { + required: true, + type: "string" + } + }, + url: "/markdown" + }, + renderRaw: { + headers: { + "content-type": "text/plain; charset=utf-8" + }, + method: "POST", + params: { + data: { + mapTo: "data", + required: true, + type: "string" + } + }, + url: "/markdown/raw" + } + }, + meta: { + get: { + method: "GET", + params: {}, + url: "/meta" + } + }, + migrations: { + cancelImport: { + method: "DELETE", + params: { + owner: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/import" + }, + deleteArchiveForAuthenticatedUser: { + headers: { + accept: "application/vnd.github.wyandotte-preview+json" + }, + method: "DELETE", + params: { + migration_id: { + required: true, + type: "integer" + } + }, + url: "/user/migrations/:migration_id/archive" + }, + deleteArchiveForOrg: { + headers: { + accept: "application/vnd.github.wyandotte-preview+json" + }, + method: "DELETE", + params: { + migration_id: { + required: true, + type: "integer" + }, + org: { + required: true, + type: "string" + } + }, + url: "/orgs/:org/migrations/:migration_id/archive" + }, + downloadArchiveForOrg: { + headers: { + accept: "application/vnd.github.wyandotte-preview+json" + }, + method: "GET", + params: { + migration_id: { + required: true, + type: "integer" + }, + org: { + required: true, + type: "string" + } + }, + url: "/orgs/:org/migrations/:migration_id/archive" + }, + getArchiveForAuthenticatedUser: { + headers: { + accept: "application/vnd.github.wyandotte-preview+json" + }, + method: "GET", + params: { + migration_id: { + required: true, + type: "integer" + } + }, + url: "/user/migrations/:migration_id/archive" + }, + getArchiveForOrg: { + deprecated: "octokit.migrations.getArchiveForOrg() has been renamed to octokit.migrations.downloadArchiveForOrg() (2020-01-27)", + headers: { + accept: "application/vnd.github.wyandotte-preview+json" + }, + method: "GET", + params: { + migration_id: { + required: true, + type: "integer" + }, + org: { + required: true, + type: "string" + } + }, + url: "/orgs/:org/migrations/:migration_id/archive" + }, + getCommitAuthors: { + method: "GET", + params: { + owner: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + }, + since: { + type: "string" + } + }, + url: "/repos/:owner/:repo/import/authors" + }, + getImportProgress: { + method: "GET", + params: { + owner: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/import" + }, + getLargeFiles: { + method: "GET", + params: { + owner: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/import/large_files" + }, + getStatusForAuthenticatedUser: { + headers: { + accept: "application/vnd.github.wyandotte-preview+json" + }, + method: "GET", + params: { + migration_id: { + required: true, + type: "integer" + } + }, + url: "/user/migrations/:migration_id" + }, + getStatusForOrg: { + headers: { + accept: "application/vnd.github.wyandotte-preview+json" + }, + method: "GET", + params: { + migration_id: { + required: true, + type: "integer" + }, + org: { + required: true, + type: "string" + } + }, + url: "/orgs/:org/migrations/:migration_id" + }, + listForAuthenticatedUser: { + headers: { + accept: "application/vnd.github.wyandotte-preview+json" + }, + method: "GET", + params: { + page: { + type: "integer" + }, + per_page: { + type: "integer" + } + }, + url: "/user/migrations" + }, + listForOrg: { + headers: { + accept: "application/vnd.github.wyandotte-preview+json" + }, + method: "GET", + params: { + org: { + required: true, + type: "string" + }, + page: { + type: "integer" + }, + per_page: { + type: "integer" + } + }, + url: "/orgs/:org/migrations" + }, + listReposForOrg: { + headers: { + accept: "application/vnd.github.wyandotte-preview+json" + }, + method: "GET", + params: { + migration_id: { + required: true, + type: "integer" + }, + org: { + required: true, + type: "string" + }, + page: { + type: "integer" + }, + per_page: { + type: "integer" + } + }, + url: "/orgs/:org/migrations/:migration_id/repositories" + }, + listReposForUser: { + headers: { + accept: "application/vnd.github.wyandotte-preview+json" + }, + method: "GET", + params: { + migration_id: { + required: true, + type: "integer" + }, + page: { + type: "integer" + }, + per_page: { + type: "integer" + } + }, + url: "/user/:migration_id/repositories" + }, + mapCommitAuthor: { + method: "PATCH", + params: { + author_id: { + required: true, + type: "integer" + }, + email: { + type: "string" + }, + name: { + type: "string" + }, + owner: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/import/authors/:author_id" + }, + setLfsPreference: { + method: "PATCH", + params: { + owner: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + }, + use_lfs: { + enum: ["opt_in", "opt_out"], + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/import/lfs" + }, + startForAuthenticatedUser: { + method: "POST", + params: { + exclude_attachments: { + type: "boolean" + }, + lock_repositories: { + type: "boolean" + }, + repositories: { + required: true, + type: "string[]" + } + }, + url: "/user/migrations" + }, + startForOrg: { + method: "POST", + params: { + exclude_attachments: { + type: "boolean" + }, + lock_repositories: { + type: "boolean" + }, + org: { + required: true, + type: "string" + }, + repositories: { + required: true, + type: "string[]" + } + }, + url: "/orgs/:org/migrations" + }, + startImport: { + method: "PUT", + params: { + owner: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + }, + tfvc_project: { + type: "string" + }, + vcs: { + enum: ["subversion", "git", "mercurial", "tfvc"], + type: "string" + }, + vcs_password: { + type: "string" + }, + vcs_url: { + required: true, + type: "string" + }, + vcs_username: { + type: "string" + } + }, + url: "/repos/:owner/:repo/import" + }, + unlockRepoForAuthenticatedUser: { + headers: { + accept: "application/vnd.github.wyandotte-preview+json" + }, + method: "DELETE", + params: { + migration_id: { + required: true, + type: "integer" + }, + repo_name: { + required: true, + type: "string" + } + }, + url: "/user/migrations/:migration_id/repos/:repo_name/lock" + }, + unlockRepoForOrg: { + headers: { + accept: "application/vnd.github.wyandotte-preview+json" + }, + method: "DELETE", + params: { + migration_id: { + required: true, + type: "integer" + }, + org: { + required: true, + type: "string" + }, + repo_name: { + required: true, + type: "string" + } + }, + url: "/orgs/:org/migrations/:migration_id/repos/:repo_name/lock" + }, + updateImport: { + method: "PATCH", + params: { + owner: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + }, + vcs_password: { + type: "string" + }, + vcs_username: { + type: "string" + } + }, + url: "/repos/:owner/:repo/import" + } + }, + oauthAuthorizations: { + checkAuthorization: { + deprecated: "octokit.oauthAuthorizations.checkAuthorization() has been renamed to octokit.apps.checkAuthorization() (2019-11-05)", + method: "GET", + params: { + access_token: { + required: true, + type: "string" + }, + client_id: { + required: true, + type: "string" + } + }, + url: "/applications/:client_id/tokens/:access_token" + }, + createAuthorization: { + deprecated: "octokit.oauthAuthorizations.createAuthorization() is deprecated, see https://developer.github.com/v3/oauth_authorizations/#create-a-new-authorization", + method: "POST", + params: { + client_id: { + type: "string" + }, + client_secret: { + type: "string" + }, + fingerprint: { + type: "string" + }, + note: { + required: true, + type: "string" + }, + note_url: { + type: "string" + }, + scopes: { + type: "string[]" + } + }, + url: "/authorizations" + }, + deleteAuthorization: { + deprecated: "octokit.oauthAuthorizations.deleteAuthorization() is deprecated, see https://developer.github.com/v3/oauth_authorizations/#delete-an-authorization", + method: "DELETE", + params: { + authorization_id: { + required: true, + type: "integer" + } + }, + url: "/authorizations/:authorization_id" + }, + deleteGrant: { + deprecated: "octokit.oauthAuthorizations.deleteGrant() is deprecated, see https://developer.github.com/v3/oauth_authorizations/#delete-a-grant", + method: "DELETE", + params: { + grant_id: { + required: true, + type: "integer" + } + }, + url: "/applications/grants/:grant_id" + }, + getAuthorization: { + deprecated: "octokit.oauthAuthorizations.getAuthorization() is deprecated, see https://developer.github.com/v3/oauth_authorizations/#get-a-single-authorization", + method: "GET", + params: { + authorization_id: { + required: true, + type: "integer" + } + }, + url: "/authorizations/:authorization_id" + }, + getGrant: { + deprecated: "octokit.oauthAuthorizations.getGrant() is deprecated, see https://developer.github.com/v3/oauth_authorizations/#get-a-single-grant", + method: "GET", + params: { + grant_id: { + required: true, + type: "integer" + } + }, + url: "/applications/grants/:grant_id" + }, + getOrCreateAuthorizationForApp: { + deprecated: "octokit.oauthAuthorizations.getOrCreateAuthorizationForApp() is deprecated, see https://developer.github.com/v3/oauth_authorizations/#get-or-create-an-authorization-for-a-specific-app", + method: "PUT", + params: { + client_id: { + required: true, + type: "string" + }, + client_secret: { + required: true, + type: "string" + }, + fingerprint: { + type: "string" + }, + note: { + type: "string" + }, + note_url: { + type: "string" + }, + scopes: { + type: "string[]" + } + }, + url: "/authorizations/clients/:client_id" + }, + getOrCreateAuthorizationForAppAndFingerprint: { + deprecated: "octokit.oauthAuthorizations.getOrCreateAuthorizationForAppAndFingerprint() is deprecated, see https://developer.github.com/v3/oauth_authorizations/#get-or-create-an-authorization-for-a-specific-app-and-fingerprint", + method: "PUT", + params: { + client_id: { + required: true, + type: "string" + }, + client_secret: { + required: true, + type: "string" + }, + fingerprint: { + required: true, + type: "string" + }, + note: { + type: "string" + }, + note_url: { + type: "string" + }, + scopes: { + type: "string[]" + } + }, + url: "/authorizations/clients/:client_id/:fingerprint" + }, + getOrCreateAuthorizationForAppFingerprint: { + deprecated: "octokit.oauthAuthorizations.getOrCreateAuthorizationForAppFingerprint() has been renamed to octokit.oauthAuthorizations.getOrCreateAuthorizationForAppAndFingerprint() (2018-12-27)", + method: "PUT", + params: { + client_id: { + required: true, + type: "string" + }, + client_secret: { + required: true, + type: "string" + }, + fingerprint: { + required: true, + type: "string" + }, + note: { + type: "string" + }, + note_url: { + type: "string" + }, + scopes: { + type: "string[]" + } + }, + url: "/authorizations/clients/:client_id/:fingerprint" + }, + listAuthorizations: { + deprecated: "octokit.oauthAuthorizations.listAuthorizations() is deprecated, see https://developer.github.com/v3/oauth_authorizations/#list-your-authorizations", + method: "GET", + params: { + page: { + type: "integer" + }, + per_page: { + type: "integer" + } + }, + url: "/authorizations" + }, + listGrants: { + deprecated: "octokit.oauthAuthorizations.listGrants() is deprecated, see https://developer.github.com/v3/oauth_authorizations/#list-your-grants", + method: "GET", + params: { + page: { + type: "integer" + }, + per_page: { + type: "integer" + } + }, + url: "/applications/grants" + }, + resetAuthorization: { + deprecated: "octokit.oauthAuthorizations.resetAuthorization() has been renamed to octokit.apps.resetAuthorization() (2019-11-05)", + method: "POST", + params: { + access_token: { + required: true, + type: "string" + }, + client_id: { + required: true, + type: "string" + } + }, + url: "/applications/:client_id/tokens/:access_token" + }, + revokeAuthorizationForApplication: { + deprecated: "octokit.oauthAuthorizations.revokeAuthorizationForApplication() has been renamed to octokit.apps.revokeAuthorizationForApplication() (2019-11-05)", + method: "DELETE", + params: { + access_token: { + required: true, + type: "string" + }, + client_id: { + required: true, + type: "string" + } + }, + url: "/applications/:client_id/tokens/:access_token" + }, + revokeGrantForApplication: { + deprecated: "octokit.oauthAuthorizations.revokeGrantForApplication() has been renamed to octokit.apps.revokeGrantForApplication() (2019-11-05)", + method: "DELETE", + params: { + access_token: { + required: true, + type: "string" + }, + client_id: { + required: true, + type: "string" + } + }, + url: "/applications/:client_id/grants/:access_token" + }, + updateAuthorization: { + deprecated: "octokit.oauthAuthorizations.updateAuthorization() is deprecated, see https://developer.github.com/v3/oauth_authorizations/#update-an-existing-authorization", + method: "PATCH", + params: { + add_scopes: { + type: "string[]" + }, + authorization_id: { + required: true, + type: "integer" + }, + fingerprint: { + type: "string" + }, + note: { + type: "string" + }, + note_url: { + type: "string" + }, + remove_scopes: { + type: "string[]" + }, + scopes: { + type: "string[]" + } + }, + url: "/authorizations/:authorization_id" + } + }, + orgs: { + addOrUpdateMembership: { + method: "PUT", + params: { + org: { + required: true, + type: "string" + }, + role: { + enum: ["admin", "member"], + type: "string" + }, + username: { + required: true, + type: "string" + } + }, + url: "/orgs/:org/memberships/:username" + }, + blockUser: { + method: "PUT", + params: { + org: { + required: true, + type: "string" + }, + username: { + required: true, + type: "string" + } + }, + url: "/orgs/:org/blocks/:username" + }, + checkBlockedUser: { + method: "GET", + params: { + org: { + required: true, + type: "string" + }, + username: { + required: true, + type: "string" + } + }, + url: "/orgs/:org/blocks/:username" + }, + checkMembership: { + method: "GET", + params: { + org: { + required: true, + type: "string" + }, + username: { + required: true, + type: "string" + } + }, + url: "/orgs/:org/members/:username" + }, + checkPublicMembership: { + method: "GET", + params: { + org: { + required: true, + type: "string" + }, + username: { + required: true, + type: "string" + } + }, + url: "/orgs/:org/public_members/:username" + }, + concealMembership: { + method: "DELETE", + params: { + org: { + required: true, + type: "string" + }, + username: { + required: true, + type: "string" + } + }, + url: "/orgs/:org/public_members/:username" + }, + convertMemberToOutsideCollaborator: { + method: "PUT", + params: { + org: { + required: true, + type: "string" + }, + username: { + required: true, + type: "string" + } + }, + url: "/orgs/:org/outside_collaborators/:username" + }, + createHook: { + method: "POST", + params: { + active: { + type: "boolean" + }, + config: { + required: true, + type: "object" + }, + "config.content_type": { + type: "string" + }, + "config.insecure_ssl": { + type: "string" + }, + "config.secret": { + type: "string" + }, + "config.url": { + required: true, + type: "string" + }, + events: { + type: "string[]" + }, + name: { + required: true, + type: "string" + }, + org: { + required: true, + type: "string" + } + }, + url: "/orgs/:org/hooks" + }, + createInvitation: { + method: "POST", + params: { + email: { + type: "string" + }, + invitee_id: { + type: "integer" + }, + org: { + required: true, + type: "string" + }, + role: { + enum: ["admin", "direct_member", "billing_manager"], + type: "string" + }, + team_ids: { + type: "integer[]" + } + }, + url: "/orgs/:org/invitations" + }, + deleteHook: { + method: "DELETE", + params: { + hook_id: { + required: true, + type: "integer" + }, + org: { + required: true, + type: "string" + } + }, + url: "/orgs/:org/hooks/:hook_id" + }, + get: { + method: "GET", + params: { + org: { + required: true, + type: "string" + } + }, + url: "/orgs/:org" + }, + getHook: { + method: "GET", + params: { + hook_id: { + required: true, + type: "integer" + }, + org: { + required: true, + type: "string" + } + }, + url: "/orgs/:org/hooks/:hook_id" + }, + getMembership: { + method: "GET", + params: { + org: { + required: true, + type: "string" + }, + username: { + required: true, + type: "string" + } + }, + url: "/orgs/:org/memberships/:username" + }, + getMembershipForAuthenticatedUser: { + method: "GET", + params: { + org: { + required: true, + type: "string" + } + }, + url: "/user/memberships/orgs/:org" + }, + list: { + method: "GET", + params: { + page: { + type: "integer" + }, + per_page: { + type: "integer" + }, + since: { + type: "integer" + } + }, + url: "/organizations" + }, + listBlockedUsers: { + method: "GET", + params: { + org: { + required: true, + type: "string" + } + }, + url: "/orgs/:org/blocks" + }, + listForAuthenticatedUser: { + method: "GET", + params: { + page: { + type: "integer" + }, + per_page: { + type: "integer" + } + }, + url: "/user/orgs" + }, + listForUser: { + method: "GET", + params: { + page: { + type: "integer" + }, + per_page: { + type: "integer" + }, + username: { + required: true, + type: "string" + } + }, + url: "/users/:username/orgs" + }, + listHooks: { + method: "GET", + params: { + org: { + required: true, + type: "string" + }, + page: { + type: "integer" + }, + per_page: { + type: "integer" + } + }, + url: "/orgs/:org/hooks" + }, + listInstallations: { + headers: { + accept: "application/vnd.github.machine-man-preview+json" + }, + method: "GET", + params: { + org: { + required: true, + type: "string" + }, + page: { + type: "integer" + }, + per_page: { + type: "integer" + } + }, + url: "/orgs/:org/installations" + }, + listInvitationTeams: { + method: "GET", + params: { + invitation_id: { + required: true, + type: "integer" + }, + org: { + required: true, + type: "string" + }, + page: { + type: "integer" + }, + per_page: { + type: "integer" + } + }, + url: "/orgs/:org/invitations/:invitation_id/teams" + }, + listMembers: { + method: "GET", + params: { + filter: { + enum: ["2fa_disabled", "all"], + type: "string" + }, + org: { + required: true, + type: "string" + }, + page: { + type: "integer" + }, + per_page: { + type: "integer" + }, + role: { + enum: ["all", "admin", "member"], + type: "string" + } + }, + url: "/orgs/:org/members" + }, + listMemberships: { + method: "GET", + params: { + page: { + type: "integer" + }, + per_page: { + type: "integer" + }, + state: { + enum: ["active", "pending"], + type: "string" + } + }, + url: "/user/memberships/orgs" + }, + listOutsideCollaborators: { + method: "GET", + params: { + filter: { + enum: ["2fa_disabled", "all"], + type: "string" + }, + org: { + required: true, + type: "string" + }, + page: { + type: "integer" + }, + per_page: { + type: "integer" + } + }, + url: "/orgs/:org/outside_collaborators" + }, + listPendingInvitations: { + method: "GET", + params: { + org: { + required: true, + type: "string" + }, + page: { + type: "integer" + }, + per_page: { + type: "integer" + } + }, + url: "/orgs/:org/invitations" + }, + listPublicMembers: { + method: "GET", + params: { + org: { + required: true, + type: "string" + }, + page: { + type: "integer" + }, + per_page: { + type: "integer" + } + }, + url: "/orgs/:org/public_members" + }, + pingHook: { + method: "POST", + params: { + hook_id: { + required: true, + type: "integer" + }, + org: { + required: true, + type: "string" + } + }, + url: "/orgs/:org/hooks/:hook_id/pings" + }, + publicizeMembership: { + method: "PUT", + params: { + org: { + required: true, + type: "string" + }, + username: { + required: true, + type: "string" + } + }, + url: "/orgs/:org/public_members/:username" + }, + removeMember: { + method: "DELETE", + params: { + org: { + required: true, + type: "string" + }, + username: { + required: true, + type: "string" + } + }, + url: "/orgs/:org/members/:username" + }, + removeMembership: { + method: "DELETE", + params: { + org: { + required: true, + type: "string" + }, + username: { + required: true, + type: "string" + } + }, + url: "/orgs/:org/memberships/:username" + }, + removeOutsideCollaborator: { + method: "DELETE", + params: { + org: { + required: true, + type: "string" + }, + username: { + required: true, + type: "string" + } + }, + url: "/orgs/:org/outside_collaborators/:username" + }, + unblockUser: { + method: "DELETE", + params: { + org: { + required: true, + type: "string" + }, + username: { + required: true, + type: "string" + } + }, + url: "/orgs/:org/blocks/:username" + }, + update: { + method: "PATCH", + params: { + billing_email: { + type: "string" + }, + company: { + type: "string" + }, + default_repository_permission: { + enum: ["read", "write", "admin", "none"], + type: "string" + }, + description: { + type: "string" + }, + email: { + type: "string" + }, + has_organization_projects: { + type: "boolean" + }, + has_repository_projects: { + type: "boolean" + }, + location: { + type: "string" + }, + members_allowed_repository_creation_type: { + enum: ["all", "private", "none"], + type: "string" + }, + members_can_create_internal_repositories: { + type: "boolean" + }, + members_can_create_private_repositories: { + type: "boolean" + }, + members_can_create_public_repositories: { + type: "boolean" + }, + members_can_create_repositories: { + type: "boolean" + }, + name: { + type: "string" + }, + org: { + required: true, + type: "string" + } + }, + url: "/orgs/:org" + }, + updateHook: { + method: "PATCH", + params: { + active: { + type: "boolean" + }, + config: { + type: "object" + }, + "config.content_type": { + type: "string" + }, + "config.insecure_ssl": { + type: "string" + }, + "config.secret": { + type: "string" + }, + "config.url": { + required: true, + type: "string" + }, + events: { + type: "string[]" + }, + hook_id: { + required: true, + type: "integer" + }, + org: { + required: true, + type: "string" + } + }, + url: "/orgs/:org/hooks/:hook_id" + }, + updateMembership: { + method: "PATCH", + params: { + org: { + required: true, + type: "string" + }, + state: { + enum: ["active"], + required: true, + type: "string" + } + }, + url: "/user/memberships/orgs/:org" + } + }, + projects: { + addCollaborator: { + headers: { + accept: "application/vnd.github.inertia-preview+json" + }, + method: "PUT", + params: { + permission: { + enum: ["read", "write", "admin"], + type: "string" + }, + project_id: { + required: true, + type: "integer" + }, + username: { + required: true, + type: "string" + } + }, + url: "/projects/:project_id/collaborators/:username" + }, + createCard: { + headers: { + accept: "application/vnd.github.inertia-preview+json" + }, + method: "POST", + params: { + column_id: { + required: true, + type: "integer" + }, + content_id: { + type: "integer" + }, + content_type: { + type: "string" + }, + note: { + type: "string" + } + }, + url: "/projects/columns/:column_id/cards" + }, + createColumn: { + headers: { + accept: "application/vnd.github.inertia-preview+json" + }, + method: "POST", + params: { + name: { + required: true, + type: "string" + }, + project_id: { + required: true, + type: "integer" + } + }, + url: "/projects/:project_id/columns" + }, + createForAuthenticatedUser: { + headers: { + accept: "application/vnd.github.inertia-preview+json" + }, + method: "POST", + params: { + body: { + type: "string" + }, + name: { + required: true, + type: "string" + } + }, + url: "/user/projects" + }, + createForOrg: { + headers: { + accept: "application/vnd.github.inertia-preview+json" + }, + method: "POST", + params: { + body: { + type: "string" + }, + name: { + required: true, + type: "string" + }, + org: { + required: true, + type: "string" + } + }, + url: "/orgs/:org/projects" + }, + createForRepo: { + headers: { + accept: "application/vnd.github.inertia-preview+json" + }, + method: "POST", + params: { + body: { + type: "string" + }, + name: { + required: true, + type: "string" + }, + owner: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/projects" + }, + delete: { + headers: { + accept: "application/vnd.github.inertia-preview+json" + }, + method: "DELETE", + params: { + project_id: { + required: true, + type: "integer" + } + }, + url: "/projects/:project_id" + }, + deleteCard: { + headers: { + accept: "application/vnd.github.inertia-preview+json" + }, + method: "DELETE", + params: { + card_id: { + required: true, + type: "integer" + } + }, + url: "/projects/columns/cards/:card_id" + }, + deleteColumn: { + headers: { + accept: "application/vnd.github.inertia-preview+json" + }, + method: "DELETE", + params: { + column_id: { + required: true, + type: "integer" + } + }, + url: "/projects/columns/:column_id" + }, + get: { + headers: { + accept: "application/vnd.github.inertia-preview+json" + }, + method: "GET", + params: { + project_id: { + required: true, + type: "integer" + } + }, + url: "/projects/:project_id" + }, + getCard: { + headers: { + accept: "application/vnd.github.inertia-preview+json" + }, + method: "GET", + params: { + card_id: { + required: true, + type: "integer" + } + }, + url: "/projects/columns/cards/:card_id" + }, + getColumn: { + headers: { + accept: "application/vnd.github.inertia-preview+json" + }, + method: "GET", + params: { + column_id: { + required: true, + type: "integer" + } + }, + url: "/projects/columns/:column_id" + }, + listCards: { + headers: { + accept: "application/vnd.github.inertia-preview+json" + }, + method: "GET", + params: { + archived_state: { + enum: ["all", "archived", "not_archived"], + type: "string" + }, + column_id: { + required: true, + type: "integer" + }, + page: { + type: "integer" + }, + per_page: { + type: "integer" + } + }, + url: "/projects/columns/:column_id/cards" + }, + listCollaborators: { + headers: { + accept: "application/vnd.github.inertia-preview+json" + }, + method: "GET", + params: { + affiliation: { + enum: ["outside", "direct", "all"], + type: "string" + }, + page: { + type: "integer" + }, + per_page: { + type: "integer" + }, + project_id: { + required: true, + type: "integer" + } + }, + url: "/projects/:project_id/collaborators" + }, + listColumns: { + headers: { + accept: "application/vnd.github.inertia-preview+json" + }, + method: "GET", + params: { + page: { + type: "integer" + }, + per_page: { + type: "integer" + }, + project_id: { + required: true, + type: "integer" + } + }, + url: "/projects/:project_id/columns" + }, + listForOrg: { + headers: { + accept: "application/vnd.github.inertia-preview+json" + }, + method: "GET", + params: { + org: { + required: true, + type: "string" + }, + page: { + type: "integer" + }, + per_page: { + type: "integer" + }, + state: { + enum: ["open", "closed", "all"], + type: "string" + } + }, + url: "/orgs/:org/projects" + }, + listForRepo: { + headers: { + accept: "application/vnd.github.inertia-preview+json" + }, + method: "GET", + params: { + owner: { + required: true, + type: "string" + }, + page: { + type: "integer" + }, + per_page: { + type: "integer" + }, + repo: { + required: true, + type: "string" + }, + state: { + enum: ["open", "closed", "all"], + type: "string" + } + }, + url: "/repos/:owner/:repo/projects" + }, + listForUser: { + headers: { + accept: "application/vnd.github.inertia-preview+json" + }, + method: "GET", + params: { + page: { + type: "integer" + }, + per_page: { + type: "integer" + }, + state: { + enum: ["open", "closed", "all"], + type: "string" + }, + username: { + required: true, + type: "string" + } + }, + url: "/users/:username/projects" + }, + moveCard: { + headers: { + accept: "application/vnd.github.inertia-preview+json" + }, + method: "POST", + params: { + card_id: { + required: true, + type: "integer" + }, + column_id: { + type: "integer" + }, + position: { + required: true, + type: "string", + validation: "^(top|bottom|after:\\d+)$" + } + }, + url: "/projects/columns/cards/:card_id/moves" + }, + moveColumn: { + headers: { + accept: "application/vnd.github.inertia-preview+json" + }, + method: "POST", + params: { + column_id: { + required: true, + type: "integer" + }, + position: { + required: true, + type: "string", + validation: "^(first|last|after:\\d+)$" + } + }, + url: "/projects/columns/:column_id/moves" + }, + removeCollaborator: { + headers: { + accept: "application/vnd.github.inertia-preview+json" + }, + method: "DELETE", + params: { + project_id: { + required: true, + type: "integer" + }, + username: { + required: true, + type: "string" + } + }, + url: "/projects/:project_id/collaborators/:username" + }, + reviewUserPermissionLevel: { + headers: { + accept: "application/vnd.github.inertia-preview+json" + }, + method: "GET", + params: { + project_id: { + required: true, + type: "integer" + }, + username: { + required: true, + type: "string" + } + }, + url: "/projects/:project_id/collaborators/:username/permission" + }, + update: { + headers: { + accept: "application/vnd.github.inertia-preview+json" + }, + method: "PATCH", + params: { + body: { + type: "string" + }, + name: { + type: "string" + }, + organization_permission: { + type: "string" + }, + private: { + type: "boolean" + }, + project_id: { + required: true, + type: "integer" + }, + state: { + enum: ["open", "closed"], + type: "string" + } + }, + url: "/projects/:project_id" + }, + updateCard: { + headers: { + accept: "application/vnd.github.inertia-preview+json" + }, + method: "PATCH", + params: { + archived: { + type: "boolean" + }, + card_id: { + required: true, + type: "integer" + }, + note: { + type: "string" + } + }, + url: "/projects/columns/cards/:card_id" + }, + updateColumn: { + headers: { + accept: "application/vnd.github.inertia-preview+json" + }, + method: "PATCH", + params: { + column_id: { + required: true, + type: "integer" + }, + name: { + required: true, + type: "string" + } + }, + url: "/projects/columns/:column_id" + } + }, + pulls: { + checkIfMerged: { + method: "GET", + params: { + number: { + alias: "pull_number", + deprecated: true, + type: "integer" + }, + owner: { + required: true, + type: "string" + }, + pull_number: { + required: true, + type: "integer" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/pulls/:pull_number/merge" + }, + create: { + method: "POST", + params: { + base: { + required: true, + type: "string" + }, + body: { + type: "string" + }, + draft: { + type: "boolean" + }, + head: { + required: true, + type: "string" + }, + maintainer_can_modify: { + type: "boolean" + }, + owner: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + }, + title: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/pulls" + }, + createComment: { + method: "POST", + params: { + body: { + required: true, + type: "string" + }, + commit_id: { + required: true, + type: "string" + }, + in_reply_to: { + deprecated: true, + description: "The comment ID to reply to. **Note**: This must be the ID of a top-level comment, not a reply to that comment. Replies to replies are not supported.", + type: "integer" + }, + line: { + type: "integer" + }, + number: { + alias: "pull_number", + deprecated: true, + type: "integer" + }, + owner: { + required: true, + type: "string" + }, + path: { + required: true, + type: "string" + }, + position: { + type: "integer" + }, + pull_number: { + required: true, + type: "integer" + }, + repo: { + required: true, + type: "string" + }, + side: { + enum: ["LEFT", "RIGHT"], + type: "string" + }, + start_line: { + type: "integer" + }, + start_side: { + enum: ["LEFT", "RIGHT", "side"], + type: "string" + } + }, + url: "/repos/:owner/:repo/pulls/:pull_number/comments" + }, + createCommentReply: { + deprecated: "octokit.pulls.createCommentReply() has been renamed to octokit.pulls.createComment() (2019-09-09)", + method: "POST", + params: { + body: { + required: true, + type: "string" + }, + commit_id: { + required: true, + type: "string" + }, + in_reply_to: { + deprecated: true, + description: "The comment ID to reply to. **Note**: This must be the ID of a top-level comment, not a reply to that comment. Replies to replies are not supported.", + type: "integer" + }, + line: { + type: "integer" + }, + number: { + alias: "pull_number", + deprecated: true, + type: "integer" + }, + owner: { + required: true, + type: "string" + }, + path: { + required: true, + type: "string" + }, + position: { + type: "integer" + }, + pull_number: { + required: true, + type: "integer" + }, + repo: { + required: true, + type: "string" + }, + side: { + enum: ["LEFT", "RIGHT"], + type: "string" + }, + start_line: { + type: "integer" + }, + start_side: { + enum: ["LEFT", "RIGHT", "side"], + type: "string" + } + }, + url: "/repos/:owner/:repo/pulls/:pull_number/comments" + }, + createFromIssue: { + deprecated: "octokit.pulls.createFromIssue() is deprecated, see https://developer.github.com/v3/pulls/#create-a-pull-request", + method: "POST", + params: { + base: { + required: true, + type: "string" + }, + draft: { + type: "boolean" + }, + head: { + required: true, + type: "string" + }, + issue: { + required: true, + type: "integer" + }, + maintainer_can_modify: { + type: "boolean" + }, + owner: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/pulls" + }, + createReview: { + method: "POST", + params: { + body: { + type: "string" + }, + comments: { + type: "object[]" + }, + "comments[].body": { + required: true, + type: "string" + }, + "comments[].path": { + required: true, + type: "string" + }, + "comments[].position": { + required: true, + type: "integer" + }, + commit_id: { + type: "string" + }, + event: { + enum: ["APPROVE", "REQUEST_CHANGES", "COMMENT"], + type: "string" + }, + number: { + alias: "pull_number", + deprecated: true, + type: "integer" + }, + owner: { + required: true, + type: "string" + }, + pull_number: { + required: true, + type: "integer" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/pulls/:pull_number/reviews" + }, + createReviewCommentReply: { + method: "POST", + params: { + body: { + required: true, + type: "string" + }, + comment_id: { + required: true, + type: "integer" + }, + owner: { + required: true, + type: "string" + }, + pull_number: { + required: true, + type: "integer" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/pulls/:pull_number/comments/:comment_id/replies" + }, + createReviewRequest: { + method: "POST", + params: { + number: { + alias: "pull_number", + deprecated: true, + type: "integer" + }, + owner: { + required: true, + type: "string" + }, + pull_number: { + required: true, + type: "integer" + }, + repo: { + required: true, + type: "string" + }, + reviewers: { + type: "string[]" + }, + team_reviewers: { + type: "string[]" + } + }, + url: "/repos/:owner/:repo/pulls/:pull_number/requested_reviewers" + }, + deleteComment: { + method: "DELETE", + params: { + comment_id: { + required: true, + type: "integer" + }, + owner: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/pulls/comments/:comment_id" + }, + deletePendingReview: { + method: "DELETE", + params: { + number: { + alias: "pull_number", + deprecated: true, + type: "integer" + }, + owner: { + required: true, + type: "string" + }, + pull_number: { + required: true, + type: "integer" + }, + repo: { + required: true, + type: "string" + }, + review_id: { + required: true, + type: "integer" + } + }, + url: "/repos/:owner/:repo/pulls/:pull_number/reviews/:review_id" + }, + deleteReviewRequest: { + method: "DELETE", + params: { + number: { + alias: "pull_number", + deprecated: true, + type: "integer" + }, + owner: { + required: true, + type: "string" + }, + pull_number: { + required: true, + type: "integer" + }, + repo: { + required: true, + type: "string" + }, + reviewers: { + type: "string[]" + }, + team_reviewers: { + type: "string[]" + } + }, + url: "/repos/:owner/:repo/pulls/:pull_number/requested_reviewers" + }, + dismissReview: { + method: "PUT", + params: { + message: { + required: true, + type: "string" + }, + number: { + alias: "pull_number", + deprecated: true, + type: "integer" + }, + owner: { + required: true, + type: "string" + }, + pull_number: { + required: true, + type: "integer" + }, + repo: { + required: true, + type: "string" + }, + review_id: { + required: true, + type: "integer" + } + }, + url: "/repos/:owner/:repo/pulls/:pull_number/reviews/:review_id/dismissals" + }, + get: { + method: "GET", + params: { + number: { + alias: "pull_number", + deprecated: true, + type: "integer" + }, + owner: { + required: true, + type: "string" + }, + pull_number: { + required: true, + type: "integer" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/pulls/:pull_number" + }, + getComment: { + method: "GET", + params: { + comment_id: { + required: true, + type: "integer" + }, + owner: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/pulls/comments/:comment_id" + }, + getCommentsForReview: { + method: "GET", + params: { + number: { + alias: "pull_number", + deprecated: true, + type: "integer" + }, + owner: { + required: true, + type: "string" + }, + page: { + type: "integer" + }, + per_page: { + type: "integer" + }, + pull_number: { + required: true, + type: "integer" + }, + repo: { + required: true, + type: "string" + }, + review_id: { + required: true, + type: "integer" + } + }, + url: "/repos/:owner/:repo/pulls/:pull_number/reviews/:review_id/comments" + }, + getReview: { + method: "GET", + params: { + number: { + alias: "pull_number", + deprecated: true, + type: "integer" + }, + owner: { + required: true, + type: "string" + }, + pull_number: { + required: true, + type: "integer" + }, + repo: { + required: true, + type: "string" + }, + review_id: { + required: true, + type: "integer" + } + }, + url: "/repos/:owner/:repo/pulls/:pull_number/reviews/:review_id" + }, + list: { + method: "GET", + params: { + base: { + type: "string" + }, + direction: { + enum: ["asc", "desc"], + type: "string" + }, + head: { + type: "string" + }, + owner: { + required: true, + type: "string" + }, + page: { + type: "integer" + }, + per_page: { + type: "integer" + }, + repo: { + required: true, + type: "string" + }, + sort: { + enum: ["created", "updated", "popularity", "long-running"], + type: "string" + }, + state: { + enum: ["open", "closed", "all"], + type: "string" + } + }, + url: "/repos/:owner/:repo/pulls" + }, + listComments: { + method: "GET", + params: { + direction: { + enum: ["asc", "desc"], + type: "string" + }, + number: { + alias: "pull_number", + deprecated: true, + type: "integer" + }, + owner: { + required: true, + type: "string" + }, + page: { + type: "integer" + }, + per_page: { + type: "integer" + }, + pull_number: { + required: true, + type: "integer" + }, + repo: { + required: true, + type: "string" + }, + since: { + type: "string" + }, + sort: { + enum: ["created", "updated"], + type: "string" + } + }, + url: "/repos/:owner/:repo/pulls/:pull_number/comments" + }, + listCommentsForRepo: { + method: "GET", + params: { + direction: { + enum: ["asc", "desc"], + type: "string" + }, + owner: { + required: true, + type: "string" + }, + page: { + type: "integer" + }, + per_page: { + type: "integer" + }, + repo: { + required: true, + type: "string" + }, + since: { + type: "string" + }, + sort: { + enum: ["created", "updated"], + type: "string" + } + }, + url: "/repos/:owner/:repo/pulls/comments" + }, + listCommits: { + method: "GET", + params: { + number: { + alias: "pull_number", + deprecated: true, + type: "integer" + }, + owner: { + required: true, + type: "string" + }, + page: { + type: "integer" + }, + per_page: { + type: "integer" + }, + pull_number: { + required: true, + type: "integer" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/pulls/:pull_number/commits" + }, + listFiles: { + method: "GET", + params: { + number: { + alias: "pull_number", + deprecated: true, + type: "integer" + }, + owner: { + required: true, + type: "string" + }, + page: { + type: "integer" + }, + per_page: { + type: "integer" + }, + pull_number: { + required: true, + type: "integer" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/pulls/:pull_number/files" + }, + listReviewRequests: { + method: "GET", + params: { + number: { + alias: "pull_number", + deprecated: true, + type: "integer" + }, + owner: { + required: true, + type: "string" + }, + page: { + type: "integer" + }, + per_page: { + type: "integer" + }, + pull_number: { + required: true, + type: "integer" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/pulls/:pull_number/requested_reviewers" + }, + listReviews: { + method: "GET", + params: { + number: { + alias: "pull_number", + deprecated: true, + type: "integer" + }, + owner: { + required: true, + type: "string" + }, + page: { + type: "integer" + }, + per_page: { + type: "integer" + }, + pull_number: { + required: true, + type: "integer" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/pulls/:pull_number/reviews" + }, + merge: { + method: "PUT", + params: { + commit_message: { + type: "string" + }, + commit_title: { + type: "string" + }, + merge_method: { + enum: ["merge", "squash", "rebase"], + type: "string" + }, + number: { + alias: "pull_number", + deprecated: true, + type: "integer" + }, + owner: { + required: true, + type: "string" + }, + pull_number: { + required: true, + type: "integer" + }, + repo: { + required: true, + type: "string" + }, + sha: { + type: "string" + } + }, + url: "/repos/:owner/:repo/pulls/:pull_number/merge" + }, + submitReview: { + method: "POST", + params: { + body: { + type: "string" + }, + event: { + enum: ["APPROVE", "REQUEST_CHANGES", "COMMENT"], + required: true, + type: "string" + }, + number: { + alias: "pull_number", + deprecated: true, + type: "integer" + }, + owner: { + required: true, + type: "string" + }, + pull_number: { + required: true, + type: "integer" + }, + repo: { + required: true, + type: "string" + }, + review_id: { + required: true, + type: "integer" + } + }, + url: "/repos/:owner/:repo/pulls/:pull_number/reviews/:review_id/events" + }, + update: { + method: "PATCH", + params: { + base: { + type: "string" + }, + body: { + type: "string" + }, + maintainer_can_modify: { + type: "boolean" + }, + number: { + alias: "pull_number", + deprecated: true, + type: "integer" + }, + owner: { + required: true, + type: "string" + }, + pull_number: { + required: true, + type: "integer" + }, + repo: { + required: true, + type: "string" + }, + state: { + enum: ["open", "closed"], + type: "string" + }, + title: { + type: "string" + } + }, + url: "/repos/:owner/:repo/pulls/:pull_number" + }, + updateBranch: { + headers: { + accept: "application/vnd.github.lydian-preview+json" + }, + method: "PUT", + params: { + expected_head_sha: { + type: "string" + }, + owner: { + required: true, + type: "string" + }, + pull_number: { + required: true, + type: "integer" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/pulls/:pull_number/update-branch" + }, + updateComment: { + method: "PATCH", + params: { + body: { + required: true, + type: "string" + }, + comment_id: { + required: true, + type: "integer" + }, + owner: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/pulls/comments/:comment_id" + }, + updateReview: { + method: "PUT", + params: { + body: { + required: true, + type: "string" + }, + number: { + alias: "pull_number", + deprecated: true, + type: "integer" + }, + owner: { + required: true, + type: "string" + }, + pull_number: { + required: true, + type: "integer" + }, + repo: { + required: true, + type: "string" + }, + review_id: { + required: true, + type: "integer" + } + }, + url: "/repos/:owner/:repo/pulls/:pull_number/reviews/:review_id" + } + }, + rateLimit: { + get: { + method: "GET", + params: {}, + url: "/rate_limit" + } + }, + reactions: { + createForCommitComment: { + headers: { + accept: "application/vnd.github.squirrel-girl-preview+json" + }, + method: "POST", + params: { + comment_id: { + required: true, + type: "integer" + }, + content: { + enum: ["+1", "-1", "laugh", "confused", "heart", "hooray", "rocket", "eyes"], + required: true, + type: "string" + }, + owner: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/comments/:comment_id/reactions" + }, + createForIssue: { + headers: { + accept: "application/vnd.github.squirrel-girl-preview+json" + }, + method: "POST", + params: { + content: { + enum: ["+1", "-1", "laugh", "confused", "heart", "hooray", "rocket", "eyes"], + required: true, + type: "string" + }, + issue_number: { + required: true, + type: "integer" + }, + number: { + alias: "issue_number", + deprecated: true, + type: "integer" + }, + owner: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/issues/:issue_number/reactions" + }, + createForIssueComment: { + headers: { + accept: "application/vnd.github.squirrel-girl-preview+json" + }, + method: "POST", + params: { + comment_id: { + required: true, + type: "integer" + }, + content: { + enum: ["+1", "-1", "laugh", "confused", "heart", "hooray", "rocket", "eyes"], + required: true, + type: "string" + }, + owner: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/issues/comments/:comment_id/reactions" + }, + createForPullRequestReviewComment: { + headers: { + accept: "application/vnd.github.squirrel-girl-preview+json" + }, + method: "POST", + params: { + comment_id: { + required: true, + type: "integer" + }, + content: { + enum: ["+1", "-1", "laugh", "confused", "heart", "hooray", "rocket", "eyes"], + required: true, + type: "string" + }, + owner: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/pulls/comments/:comment_id/reactions" + }, + createForTeamDiscussion: { + deprecated: "octokit.reactions.createForTeamDiscussion() has been renamed to octokit.reactions.createForTeamDiscussionLegacy() (2020-01-16)", + headers: { + accept: "application/vnd.github.squirrel-girl-preview+json" + }, + method: "POST", + params: { + content: { + enum: ["+1", "-1", "laugh", "confused", "heart", "hooray", "rocket", "eyes"], + required: true, + type: "string" + }, + discussion_number: { + required: true, + type: "integer" + }, + team_id: { + required: true, + type: "integer" + } + }, + url: "/teams/:team_id/discussions/:discussion_number/reactions" + }, + createForTeamDiscussionComment: { + deprecated: "octokit.reactions.createForTeamDiscussionComment() has been renamed to octokit.reactions.createForTeamDiscussionCommentLegacy() (2020-01-16)", + headers: { + accept: "application/vnd.github.squirrel-girl-preview+json" + }, + method: "POST", + params: { + comment_number: { + required: true, + type: "integer" + }, + content: { + enum: ["+1", "-1", "laugh", "confused", "heart", "hooray", "rocket", "eyes"], + required: true, + type: "string" + }, + discussion_number: { + required: true, + type: "integer" + }, + team_id: { + required: true, + type: "integer" + } + }, + url: "/teams/:team_id/discussions/:discussion_number/comments/:comment_number/reactions" + }, + createForTeamDiscussionCommentInOrg: { + headers: { + accept: "application/vnd.github.squirrel-girl-preview+json" + }, + method: "POST", + params: { + comment_number: { + required: true, + type: "integer" + }, + content: { + enum: ["+1", "-1", "laugh", "confused", "heart", "hooray", "rocket", "eyes"], + required: true, + type: "string" + }, + discussion_number: { + required: true, + type: "integer" + }, + org: { + required: true, + type: "string" + }, + team_slug: { + required: true, + type: "string" + } + }, + url: "/orgs/:org/teams/:team_slug/discussions/:discussion_number/comments/:comment_number/reactions" + }, + createForTeamDiscussionCommentLegacy: { + deprecated: "octokit.reactions.createForTeamDiscussionCommentLegacy() is deprecated, see https://developer.github.com/v3/reactions/#create-reaction-for-a-team-discussion-comment-legacy", + headers: { + accept: "application/vnd.github.squirrel-girl-preview+json" + }, + method: "POST", + params: { + comment_number: { + required: true, + type: "integer" + }, + content: { + enum: ["+1", "-1", "laugh", "confused", "heart", "hooray", "rocket", "eyes"], + required: true, + type: "string" + }, + discussion_number: { + required: true, + type: "integer" + }, + team_id: { + required: true, + type: "integer" + } + }, + url: "/teams/:team_id/discussions/:discussion_number/comments/:comment_number/reactions" + }, + createForTeamDiscussionInOrg: { + headers: { + accept: "application/vnd.github.squirrel-girl-preview+json" + }, + method: "POST", + params: { + content: { + enum: ["+1", "-1", "laugh", "confused", "heart", "hooray", "rocket", "eyes"], + required: true, + type: "string" + }, + discussion_number: { + required: true, + type: "integer" + }, + org: { + required: true, + type: "string" + }, + team_slug: { + required: true, + type: "string" + } + }, + url: "/orgs/:org/teams/:team_slug/discussions/:discussion_number/reactions" + }, + createForTeamDiscussionLegacy: { + deprecated: "octokit.reactions.createForTeamDiscussionLegacy() is deprecated, see https://developer.github.com/v3/reactions/#create-reaction-for-a-team-discussion-legacy", + headers: { + accept: "application/vnd.github.squirrel-girl-preview+json" + }, + method: "POST", + params: { + content: { + enum: ["+1", "-1", "laugh", "confused", "heart", "hooray", "rocket", "eyes"], + required: true, + type: "string" + }, + discussion_number: { + required: true, + type: "integer" + }, + team_id: { + required: true, + type: "integer" + } + }, + url: "/teams/:team_id/discussions/:discussion_number/reactions" + }, + delete: { + headers: { + accept: "application/vnd.github.squirrel-girl-preview+json" + }, + method: "DELETE", + params: { + reaction_id: { + required: true, + type: "integer" + } + }, + url: "/reactions/:reaction_id" + }, + listForCommitComment: { + headers: { + accept: "application/vnd.github.squirrel-girl-preview+json" + }, + method: "GET", + params: { + comment_id: { + required: true, + type: "integer" + }, + content: { + enum: ["+1", "-1", "laugh", "confused", "heart", "hooray", "rocket", "eyes"], + type: "string" + }, + owner: { + required: true, + type: "string" + }, + page: { + type: "integer" + }, + per_page: { + type: "integer" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/comments/:comment_id/reactions" + }, + listForIssue: { + headers: { + accept: "application/vnd.github.squirrel-girl-preview+json" + }, + method: "GET", + params: { + content: { + enum: ["+1", "-1", "laugh", "confused", "heart", "hooray", "rocket", "eyes"], + type: "string" + }, + issue_number: { + required: true, + type: "integer" + }, + number: { + alias: "issue_number", + deprecated: true, + type: "integer" + }, + owner: { + required: true, + type: "string" + }, + page: { + type: "integer" + }, + per_page: { + type: "integer" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/issues/:issue_number/reactions" + }, + listForIssueComment: { + headers: { + accept: "application/vnd.github.squirrel-girl-preview+json" + }, + method: "GET", + params: { + comment_id: { + required: true, + type: "integer" + }, + content: { + enum: ["+1", "-1", "laugh", "confused", "heart", "hooray", "rocket", "eyes"], + type: "string" + }, + owner: { + required: true, + type: "string" + }, + page: { + type: "integer" + }, + per_page: { + type: "integer" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/issues/comments/:comment_id/reactions" + }, + listForPullRequestReviewComment: { + headers: { + accept: "application/vnd.github.squirrel-girl-preview+json" + }, + method: "GET", + params: { + comment_id: { + required: true, + type: "integer" + }, + content: { + enum: ["+1", "-1", "laugh", "confused", "heart", "hooray", "rocket", "eyes"], + type: "string" + }, + owner: { + required: true, + type: "string" + }, + page: { + type: "integer" + }, + per_page: { + type: "integer" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/pulls/comments/:comment_id/reactions" + }, + listForTeamDiscussion: { + deprecated: "octokit.reactions.listForTeamDiscussion() has been renamed to octokit.reactions.listForTeamDiscussionLegacy() (2020-01-16)", + headers: { + accept: "application/vnd.github.squirrel-girl-preview+json" + }, + method: "GET", + params: { + content: { + enum: ["+1", "-1", "laugh", "confused", "heart", "hooray", "rocket", "eyes"], + type: "string" + }, + discussion_number: { + required: true, + type: "integer" + }, + page: { + type: "integer" + }, + per_page: { + type: "integer" + }, + team_id: { + required: true, + type: "integer" + } + }, + url: "/teams/:team_id/discussions/:discussion_number/reactions" + }, + listForTeamDiscussionComment: { + deprecated: "octokit.reactions.listForTeamDiscussionComment() has been renamed to octokit.reactions.listForTeamDiscussionCommentLegacy() (2020-01-16)", + headers: { + accept: "application/vnd.github.squirrel-girl-preview+json" + }, + method: "GET", + params: { + comment_number: { + required: true, + type: "integer" + }, + content: { + enum: ["+1", "-1", "laugh", "confused", "heart", "hooray", "rocket", "eyes"], + type: "string" + }, + discussion_number: { + required: true, + type: "integer" + }, + page: { + type: "integer" + }, + per_page: { + type: "integer" + }, + team_id: { + required: true, + type: "integer" + } + }, + url: "/teams/:team_id/discussions/:discussion_number/comments/:comment_number/reactions" + }, + listForTeamDiscussionCommentInOrg: { + headers: { + accept: "application/vnd.github.squirrel-girl-preview+json" + }, + method: "GET", + params: { + comment_number: { + required: true, + type: "integer" + }, + content: { + enum: ["+1", "-1", "laugh", "confused", "heart", "hooray", "rocket", "eyes"], + type: "string" + }, + discussion_number: { + required: true, + type: "integer" + }, + org: { + required: true, + type: "string" + }, + page: { + type: "integer" + }, + per_page: { + type: "integer" + }, + team_slug: { + required: true, + type: "string" + } + }, + url: "/orgs/:org/teams/:team_slug/discussions/:discussion_number/comments/:comment_number/reactions" + }, + listForTeamDiscussionCommentLegacy: { + deprecated: "octokit.reactions.listForTeamDiscussionCommentLegacy() is deprecated, see https://developer.github.com/v3/reactions/#list-reactions-for-a-team-discussion-comment-legacy", + headers: { + accept: "application/vnd.github.squirrel-girl-preview+json" + }, + method: "GET", + params: { + comment_number: { + required: true, + type: "integer" + }, + content: { + enum: ["+1", "-1", "laugh", "confused", "heart", "hooray", "rocket", "eyes"], + type: "string" + }, + discussion_number: { + required: true, + type: "integer" + }, + page: { + type: "integer" + }, + per_page: { + type: "integer" + }, + team_id: { + required: true, + type: "integer" + } + }, + url: "/teams/:team_id/discussions/:discussion_number/comments/:comment_number/reactions" + }, + listForTeamDiscussionInOrg: { + headers: { + accept: "application/vnd.github.squirrel-girl-preview+json" + }, + method: "GET", + params: { + content: { + enum: ["+1", "-1", "laugh", "confused", "heart", "hooray", "rocket", "eyes"], + type: "string" + }, + discussion_number: { + required: true, + type: "integer" + }, + org: { + required: true, + type: "string" + }, + page: { + type: "integer" + }, + per_page: { + type: "integer" + }, + team_slug: { + required: true, + type: "string" + } + }, + url: "/orgs/:org/teams/:team_slug/discussions/:discussion_number/reactions" + }, + listForTeamDiscussionLegacy: { + deprecated: "octokit.reactions.listForTeamDiscussionLegacy() is deprecated, see https://developer.github.com/v3/reactions/#list-reactions-for-a-team-discussion-legacy", + headers: { + accept: "application/vnd.github.squirrel-girl-preview+json" + }, + method: "GET", + params: { + content: { + enum: ["+1", "-1", "laugh", "confused", "heart", "hooray", "rocket", "eyes"], + type: "string" + }, + discussion_number: { + required: true, + type: "integer" + }, + page: { + type: "integer" + }, + per_page: { + type: "integer" + }, + team_id: { + required: true, + type: "integer" + } + }, + url: "/teams/:team_id/discussions/:discussion_number/reactions" + } + }, + repos: { + acceptInvitation: { + method: "PATCH", + params: { + invitation_id: { + required: true, + type: "integer" + } + }, + url: "/user/repository_invitations/:invitation_id" + }, + addCollaborator: { + method: "PUT", + params: { + owner: { + required: true, + type: "string" + }, + permission: { + enum: ["pull", "push", "admin"], + type: "string" + }, + repo: { + required: true, + type: "string" + }, + username: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/collaborators/:username" + }, + addDeployKey: { + method: "POST", + params: { + key: { + required: true, + type: "string" + }, + owner: { + required: true, + type: "string" + }, + read_only: { + type: "boolean" + }, + repo: { + required: true, + type: "string" + }, + title: { + type: "string" + } + }, + url: "/repos/:owner/:repo/keys" + }, + addProtectedBranchAdminEnforcement: { + method: "POST", + params: { + branch: { + required: true, + type: "string" + }, + owner: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/branches/:branch/protection/enforce_admins" + }, + addProtectedBranchAppRestrictions: { + method: "POST", + params: { + apps: { + mapTo: "data", + required: true, + type: "string[]" + }, + branch: { + required: true, + type: "string" + }, + owner: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/branches/:branch/protection/restrictions/apps" + }, + addProtectedBranchRequiredSignatures: { + headers: { + accept: "application/vnd.github.zzzax-preview+json" + }, + method: "POST", + params: { + branch: { + required: true, + type: "string" + }, + owner: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/branches/:branch/protection/required_signatures" + }, + addProtectedBranchRequiredStatusChecksContexts: { + method: "POST", + params: { + branch: { + required: true, + type: "string" + }, + contexts: { + mapTo: "data", + required: true, + type: "string[]" + }, + owner: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/branches/:branch/protection/required_status_checks/contexts" + }, + addProtectedBranchTeamRestrictions: { + method: "POST", + params: { + branch: { + required: true, + type: "string" + }, + owner: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + }, + teams: { + mapTo: "data", + required: true, + type: "string[]" + } + }, + url: "/repos/:owner/:repo/branches/:branch/protection/restrictions/teams" + }, + addProtectedBranchUserRestrictions: { + method: "POST", + params: { + branch: { + required: true, + type: "string" + }, + owner: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + }, + users: { + mapTo: "data", + required: true, + type: "string[]" + } + }, + url: "/repos/:owner/:repo/branches/:branch/protection/restrictions/users" + }, + checkCollaborator: { + method: "GET", + params: { + owner: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + }, + username: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/collaborators/:username" + }, + checkVulnerabilityAlerts: { + headers: { + accept: "application/vnd.github.dorian-preview+json" + }, + method: "GET", + params: { + owner: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/vulnerability-alerts" + }, + compareCommits: { + method: "GET", + params: { + base: { + required: true, + type: "string" + }, + head: { + required: true, + type: "string" + }, + owner: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/compare/:base...:head" + }, + createCommitComment: { + method: "POST", + params: { + body: { + required: true, + type: "string" + }, + commit_sha: { + required: true, + type: "string" + }, + line: { + type: "integer" + }, + owner: { + required: true, + type: "string" + }, + path: { + type: "string" + }, + position: { + type: "integer" + }, + repo: { + required: true, + type: "string" + }, + sha: { + alias: "commit_sha", + deprecated: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/commits/:commit_sha/comments" + }, + createDeployment: { + method: "POST", + params: { + auto_merge: { + type: "boolean" + }, + description: { + type: "string" + }, + environment: { + type: "string" + }, + owner: { + required: true, + type: "string" + }, + payload: { + type: "string" + }, + production_environment: { + type: "boolean" + }, + ref: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + }, + required_contexts: { + type: "string[]" + }, + task: { + type: "string" + }, + transient_environment: { + type: "boolean" + } + }, + url: "/repos/:owner/:repo/deployments" + }, + createDeploymentStatus: { + method: "POST", + params: { + auto_inactive: { + type: "boolean" + }, + deployment_id: { + required: true, + type: "integer" + }, + description: { + type: "string" + }, + environment: { + enum: ["production", "staging", "qa"], + type: "string" + }, + environment_url: { + type: "string" + }, + log_url: { + type: "string" + }, + owner: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + }, + state: { + enum: ["error", "failure", "inactive", "in_progress", "queued", "pending", "success"], + required: true, + type: "string" + }, + target_url: { + type: "string" + } + }, + url: "/repos/:owner/:repo/deployments/:deployment_id/statuses" + }, + createDispatchEvent: { + method: "POST", + params: { + client_payload: { + type: "object" + }, + event_type: { + type: "string" + }, + owner: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/dispatches" + }, + createFile: { + deprecated: "octokit.repos.createFile() has been renamed to octokit.repos.createOrUpdateFile() (2019-06-07)", + method: "PUT", + params: { + author: { + type: "object" + }, + "author.email": { + required: true, + type: "string" + }, + "author.name": { + required: true, + type: "string" + }, + branch: { + type: "string" + }, + committer: { + type: "object" + }, + "committer.email": { + required: true, + type: "string" + }, + "committer.name": { + required: true, + type: "string" + }, + content: { + required: true, + type: "string" + }, + message: { + required: true, + type: "string" + }, + owner: { + required: true, + type: "string" + }, + path: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + }, + sha: { + type: "string" + } + }, + url: "/repos/:owner/:repo/contents/:path" + }, + createForAuthenticatedUser: { + method: "POST", + params: { + allow_merge_commit: { + type: "boolean" + }, + allow_rebase_merge: { + type: "boolean" + }, + allow_squash_merge: { + type: "boolean" + }, + auto_init: { + type: "boolean" + }, + delete_branch_on_merge: { + type: "boolean" + }, + description: { + type: "string" + }, + gitignore_template: { + type: "string" + }, + has_issues: { + type: "boolean" + }, + has_projects: { + type: "boolean" + }, + has_wiki: { + type: "boolean" + }, + homepage: { + type: "string" + }, + is_template: { + type: "boolean" + }, + license_template: { + type: "string" + }, + name: { + required: true, + type: "string" + }, + private: { + type: "boolean" + }, + team_id: { + type: "integer" + }, + visibility: { + enum: ["public", "private", "visibility", "internal"], + type: "string" + } + }, + url: "/user/repos" + }, + createFork: { + method: "POST", + params: { + organization: { + type: "string" + }, + owner: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/forks" + }, + createHook: { + method: "POST", + params: { + active: { + type: "boolean" + }, + config: { + required: true, + type: "object" + }, + "config.content_type": { + type: "string" + }, + "config.insecure_ssl": { + type: "string" + }, + "config.secret": { + type: "string" + }, + "config.url": { + required: true, + type: "string" + }, + events: { + type: "string[]" + }, + name: { + type: "string" + }, + owner: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/hooks" + }, + createInOrg: { + method: "POST", + params: { + allow_merge_commit: { + type: "boolean" + }, + allow_rebase_merge: { + type: "boolean" + }, + allow_squash_merge: { + type: "boolean" + }, + auto_init: { + type: "boolean" + }, + delete_branch_on_merge: { + type: "boolean" + }, + description: { + type: "string" + }, + gitignore_template: { + type: "string" + }, + has_issues: { + type: "boolean" + }, + has_projects: { + type: "boolean" + }, + has_wiki: { + type: "boolean" + }, + homepage: { + type: "string" + }, + is_template: { + type: "boolean" + }, + license_template: { + type: "string" + }, + name: { + required: true, + type: "string" + }, + org: { + required: true, + type: "string" + }, + private: { + type: "boolean" + }, + team_id: { + type: "integer" + }, + visibility: { + enum: ["public", "private", "visibility", "internal"], + type: "string" + } + }, + url: "/orgs/:org/repos" + }, + createOrUpdateFile: { + method: "PUT", + params: { + author: { + type: "object" + }, + "author.email": { + required: true, + type: "string" + }, + "author.name": { + required: true, + type: "string" + }, + branch: { + type: "string" + }, + committer: { + type: "object" + }, + "committer.email": { + required: true, + type: "string" + }, + "committer.name": { + required: true, + type: "string" + }, + content: { + required: true, + type: "string" + }, + message: { + required: true, + type: "string" + }, + owner: { + required: true, + type: "string" + }, + path: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + }, + sha: { + type: "string" + } + }, + url: "/repos/:owner/:repo/contents/:path" + }, + createRelease: { + method: "POST", + params: { + body: { + type: "string" + }, + draft: { + type: "boolean" + }, + name: { + type: "string" + }, + owner: { + required: true, + type: "string" + }, + prerelease: { + type: "boolean" + }, + repo: { + required: true, + type: "string" + }, + tag_name: { + required: true, + type: "string" + }, + target_commitish: { + type: "string" + } + }, + url: "/repos/:owner/:repo/releases" + }, + createStatus: { + method: "POST", + params: { + context: { + type: "string" + }, + description: { + type: "string" + }, + owner: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + }, + sha: { + required: true, + type: "string" + }, + state: { + enum: ["error", "failure", "pending", "success"], + required: true, + type: "string" + }, + target_url: { + type: "string" + } + }, + url: "/repos/:owner/:repo/statuses/:sha" + }, + createUsingTemplate: { + headers: { + accept: "application/vnd.github.baptiste-preview+json" + }, + method: "POST", + params: { + description: { + type: "string" + }, + name: { + required: true, + type: "string" + }, + owner: { + type: "string" + }, + private: { + type: "boolean" + }, + template_owner: { + required: true, + type: "string" + }, + template_repo: { + required: true, + type: "string" + } + }, + url: "/repos/:template_owner/:template_repo/generate" + }, + declineInvitation: { + method: "DELETE", + params: { + invitation_id: { + required: true, + type: "integer" + } + }, + url: "/user/repository_invitations/:invitation_id" + }, + delete: { + method: "DELETE", + params: { + owner: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo" + }, + deleteCommitComment: { + method: "DELETE", + params: { + comment_id: { + required: true, + type: "integer" + }, + owner: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/comments/:comment_id" + }, + deleteDownload: { + method: "DELETE", + params: { + download_id: { + required: true, + type: "integer" + }, + owner: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/downloads/:download_id" + }, + deleteFile: { + method: "DELETE", + params: { + author: { + type: "object" + }, + "author.email": { + type: "string" + }, + "author.name": { + type: "string" + }, + branch: { + type: "string" + }, + committer: { + type: "object" + }, + "committer.email": { + type: "string" + }, + "committer.name": { + type: "string" + }, + message: { + required: true, + type: "string" + }, + owner: { + required: true, + type: "string" + }, + path: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + }, + sha: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/contents/:path" + }, + deleteHook: { + method: "DELETE", + params: { + hook_id: { + required: true, + type: "integer" + }, + owner: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/hooks/:hook_id" + }, + deleteInvitation: { + method: "DELETE", + params: { + invitation_id: { + required: true, + type: "integer" + }, + owner: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/invitations/:invitation_id" + }, + deleteRelease: { + method: "DELETE", + params: { + owner: { + required: true, + type: "string" + }, + release_id: { + required: true, + type: "integer" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/releases/:release_id" + }, + deleteReleaseAsset: { + method: "DELETE", + params: { + asset_id: { + required: true, + type: "integer" + }, + owner: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/releases/assets/:asset_id" + }, + disableAutomatedSecurityFixes: { + headers: { + accept: "application/vnd.github.london-preview+json" + }, + method: "DELETE", + params: { + owner: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/automated-security-fixes" + }, + disablePagesSite: { + headers: { + accept: "application/vnd.github.switcheroo-preview+json" + }, + method: "DELETE", + params: { + owner: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/pages" + }, + disableVulnerabilityAlerts: { + headers: { + accept: "application/vnd.github.dorian-preview+json" + }, + method: "DELETE", + params: { + owner: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/vulnerability-alerts" + }, + enableAutomatedSecurityFixes: { + headers: { + accept: "application/vnd.github.london-preview+json" + }, + method: "PUT", + params: { + owner: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/automated-security-fixes" + }, + enablePagesSite: { + headers: { + accept: "application/vnd.github.switcheroo-preview+json" + }, + method: "POST", + params: { + owner: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + }, + source: { + type: "object" + }, + "source.branch": { + enum: ["master", "gh-pages"], + type: "string" + }, + "source.path": { + type: "string" + } + }, + url: "/repos/:owner/:repo/pages" + }, + enableVulnerabilityAlerts: { + headers: { + accept: "application/vnd.github.dorian-preview+json" + }, + method: "PUT", + params: { + owner: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/vulnerability-alerts" + }, + get: { + method: "GET", + params: { + owner: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo" + }, + getAppsWithAccessToProtectedBranch: { + method: "GET", + params: { + branch: { + required: true, + type: "string" + }, + owner: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/branches/:branch/protection/restrictions/apps" + }, + getArchiveLink: { + method: "GET", + params: { + archive_format: { + required: true, + type: "string" + }, + owner: { + required: true, + type: "string" + }, + ref: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/:archive_format/:ref" + }, + getBranch: { + method: "GET", + params: { + branch: { + required: true, + type: "string" + }, + owner: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/branches/:branch" + }, + getBranchProtection: { + method: "GET", + params: { + branch: { + required: true, + type: "string" + }, + owner: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/branches/:branch/protection" + }, + getClones: { + method: "GET", + params: { + owner: { + required: true, + type: "string" + }, + per: { + enum: ["day", "week"], + type: "string" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/traffic/clones" + }, + getCodeFrequencyStats: { + method: "GET", + params: { + owner: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/stats/code_frequency" + }, + getCollaboratorPermissionLevel: { + method: "GET", + params: { + owner: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + }, + username: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/collaborators/:username/permission" + }, + getCombinedStatusForRef: { + method: "GET", + params: { + owner: { + required: true, + type: "string" + }, + ref: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/commits/:ref/status" + }, + getCommit: { + method: "GET", + params: { + commit_sha: { + alias: "ref", + deprecated: true, + type: "string" + }, + owner: { + required: true, + type: "string" + }, + ref: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + }, + sha: { + alias: "ref", + deprecated: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/commits/:ref" + }, + getCommitActivityStats: { + method: "GET", + params: { + owner: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/stats/commit_activity" + }, + getCommitComment: { + method: "GET", + params: { + comment_id: { + required: true, + type: "integer" + }, + owner: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/comments/:comment_id" + }, + getCommitRefSha: { + deprecated: "octokit.repos.getCommitRefSha() is deprecated, see https://developer.github.com/v3/repos/commits/#get-a-single-commit", + headers: { + accept: "application/vnd.github.v3.sha" + }, + method: "GET", + params: { + owner: { + required: true, + type: "string" + }, + ref: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/commits/:ref" + }, + getContents: { + method: "GET", + params: { + owner: { + required: true, + type: "string" + }, + path: { + required: true, + type: "string" + }, + ref: { + type: "string" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/contents/:path" + }, + getContributorsStats: { + method: "GET", + params: { + owner: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/stats/contributors" + }, + getDeployKey: { + method: "GET", + params: { + key_id: { + required: true, + type: "integer" + }, + owner: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/keys/:key_id" + }, + getDeployment: { + method: "GET", + params: { + deployment_id: { + required: true, + type: "integer" + }, + owner: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/deployments/:deployment_id" + }, + getDeploymentStatus: { + method: "GET", + params: { + deployment_id: { + required: true, + type: "integer" + }, + owner: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + }, + status_id: { + required: true, + type: "integer" + } + }, + url: "/repos/:owner/:repo/deployments/:deployment_id/statuses/:status_id" + }, + getDownload: { + method: "GET", + params: { + download_id: { + required: true, + type: "integer" + }, + owner: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/downloads/:download_id" + }, + getHook: { + method: "GET", + params: { + hook_id: { + required: true, + type: "integer" + }, + owner: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/hooks/:hook_id" + }, + getLatestPagesBuild: { + method: "GET", + params: { + owner: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/pages/builds/latest" + }, + getLatestRelease: { + method: "GET", + params: { + owner: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/releases/latest" + }, + getPages: { + method: "GET", + params: { + owner: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/pages" + }, + getPagesBuild: { + method: "GET", + params: { + build_id: { + required: true, + type: "integer" + }, + owner: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/pages/builds/:build_id" + }, + getParticipationStats: { + method: "GET", + params: { + owner: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/stats/participation" + }, + getProtectedBranchAdminEnforcement: { + method: "GET", + params: { + branch: { + required: true, + type: "string" + }, + owner: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/branches/:branch/protection/enforce_admins" + }, + getProtectedBranchPullRequestReviewEnforcement: { + method: "GET", + params: { + branch: { + required: true, + type: "string" + }, + owner: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/branches/:branch/protection/required_pull_request_reviews" + }, + getProtectedBranchRequiredSignatures: { + headers: { + accept: "application/vnd.github.zzzax-preview+json" + }, + method: "GET", + params: { + branch: { + required: true, + type: "string" + }, + owner: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/branches/:branch/protection/required_signatures" + }, + getProtectedBranchRequiredStatusChecks: { + method: "GET", + params: { + branch: { + required: true, + type: "string" + }, + owner: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/branches/:branch/protection/required_status_checks" + }, + getProtectedBranchRestrictions: { + method: "GET", + params: { + branch: { + required: true, + type: "string" + }, + owner: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/branches/:branch/protection/restrictions" + }, + getPunchCardStats: { + method: "GET", + params: { + owner: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/stats/punch_card" + }, + getReadme: { + method: "GET", + params: { + owner: { + required: true, + type: "string" + }, + ref: { + type: "string" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/readme" + }, + getRelease: { + method: "GET", + params: { + owner: { + required: true, + type: "string" + }, + release_id: { + required: true, + type: "integer" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/releases/:release_id" + }, + getReleaseAsset: { + method: "GET", + params: { + asset_id: { + required: true, + type: "integer" + }, + owner: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/releases/assets/:asset_id" + }, + getReleaseByTag: { + method: "GET", + params: { + owner: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + }, + tag: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/releases/tags/:tag" + }, + getTeamsWithAccessToProtectedBranch: { + method: "GET", + params: { + branch: { + required: true, + type: "string" + }, + owner: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/branches/:branch/protection/restrictions/teams" + }, + getTopPaths: { + method: "GET", + params: { + owner: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/traffic/popular/paths" + }, + getTopReferrers: { + method: "GET", + params: { + owner: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/traffic/popular/referrers" + }, + getUsersWithAccessToProtectedBranch: { + method: "GET", + params: { + branch: { + required: true, + type: "string" + }, + owner: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/branches/:branch/protection/restrictions/users" + }, + getViews: { + method: "GET", + params: { + owner: { + required: true, + type: "string" + }, + per: { + enum: ["day", "week"], + type: "string" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/traffic/views" + }, + list: { + method: "GET", + params: { + affiliation: { + type: "string" + }, + direction: { + enum: ["asc", "desc"], + type: "string" + }, + page: { + type: "integer" + }, + per_page: { + type: "integer" + }, + sort: { + enum: ["created", "updated", "pushed", "full_name"], + type: "string" + }, + type: { + enum: ["all", "owner", "public", "private", "member"], + type: "string" + }, + visibility: { + enum: ["all", "public", "private"], + type: "string" + } + }, + url: "/user/repos" + }, + listAppsWithAccessToProtectedBranch: { + deprecated: "octokit.repos.listAppsWithAccessToProtectedBranch() has been renamed to octokit.repos.getAppsWithAccessToProtectedBranch() (2019-09-13)", + method: "GET", + params: { + branch: { + required: true, + type: "string" + }, + owner: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/branches/:branch/protection/restrictions/apps" + }, + listAssetsForRelease: { + method: "GET", + params: { + owner: { + required: true, + type: "string" + }, + page: { + type: "integer" + }, + per_page: { + type: "integer" + }, + release_id: { + required: true, + type: "integer" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/releases/:release_id/assets" + }, + listBranches: { + method: "GET", + params: { + owner: { + required: true, + type: "string" + }, + page: { + type: "integer" + }, + per_page: { + type: "integer" + }, + protected: { + type: "boolean" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/branches" + }, + listBranchesForHeadCommit: { + headers: { + accept: "application/vnd.github.groot-preview+json" + }, + method: "GET", + params: { + commit_sha: { + required: true, + type: "string" + }, + owner: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/commits/:commit_sha/branches-where-head" + }, + listCollaborators: { + method: "GET", + params: { + affiliation: { + enum: ["outside", "direct", "all"], + type: "string" + }, + owner: { + required: true, + type: "string" + }, + page: { + type: "integer" + }, + per_page: { + type: "integer" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/collaborators" + }, + listCommentsForCommit: { + method: "GET", + params: { + commit_sha: { + required: true, + type: "string" + }, + owner: { + required: true, + type: "string" + }, + page: { + type: "integer" + }, + per_page: { + type: "integer" + }, + ref: { + alias: "commit_sha", + deprecated: true, + type: "string" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/commits/:commit_sha/comments" + }, + listCommitComments: { + method: "GET", + params: { + owner: { + required: true, + type: "string" + }, + page: { + type: "integer" + }, + per_page: { + type: "integer" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/comments" + }, + listCommits: { + method: "GET", + params: { + author: { + type: "string" + }, + owner: { + required: true, + type: "string" + }, + page: { + type: "integer" + }, + path: { + type: "string" + }, + per_page: { + type: "integer" + }, + repo: { + required: true, + type: "string" + }, + sha: { + type: "string" + }, + since: { + type: "string" + }, + until: { + type: "string" + } + }, + url: "/repos/:owner/:repo/commits" + }, + listContributors: { + method: "GET", + params: { + anon: { + type: "string" + }, + owner: { + required: true, + type: "string" + }, + page: { + type: "integer" + }, + per_page: { + type: "integer" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/contributors" + }, + listDeployKeys: { + method: "GET", + params: { + owner: { + required: true, + type: "string" + }, + page: { + type: "integer" + }, + per_page: { + type: "integer" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/keys" + }, + listDeploymentStatuses: { + method: "GET", + params: { + deployment_id: { + required: true, + type: "integer" + }, + owner: { + required: true, + type: "string" + }, + page: { + type: "integer" + }, + per_page: { + type: "integer" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/deployments/:deployment_id/statuses" + }, + listDeployments: { + method: "GET", + params: { + environment: { + type: "string" + }, + owner: { + required: true, + type: "string" + }, + page: { + type: "integer" + }, + per_page: { + type: "integer" + }, + ref: { + type: "string" + }, + repo: { + required: true, + type: "string" + }, + sha: { + type: "string" + }, + task: { + type: "string" + } + }, + url: "/repos/:owner/:repo/deployments" + }, + listDownloads: { + method: "GET", + params: { + owner: { + required: true, + type: "string" + }, + page: { + type: "integer" + }, + per_page: { + type: "integer" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/downloads" + }, + listForOrg: { + method: "GET", + params: { + direction: { + enum: ["asc", "desc"], + type: "string" + }, + org: { + required: true, + type: "string" + }, + page: { + type: "integer" + }, + per_page: { + type: "integer" + }, + sort: { + enum: ["created", "updated", "pushed", "full_name"], + type: "string" + }, + type: { + enum: ["all", "public", "private", "forks", "sources", "member", "internal"], + type: "string" + } + }, + url: "/orgs/:org/repos" + }, + listForUser: { + method: "GET", + params: { + direction: { + enum: ["asc", "desc"], + type: "string" + }, + page: { + type: "integer" + }, + per_page: { + type: "integer" + }, + sort: { + enum: ["created", "updated", "pushed", "full_name"], + type: "string" + }, + type: { + enum: ["all", "owner", "member"], + type: "string" + }, + username: { + required: true, + type: "string" + } + }, + url: "/users/:username/repos" + }, + listForks: { + method: "GET", + params: { + owner: { + required: true, + type: "string" + }, + page: { + type: "integer" + }, + per_page: { + type: "integer" + }, + repo: { + required: true, + type: "string" + }, + sort: { + enum: ["newest", "oldest", "stargazers"], + type: "string" + } + }, + url: "/repos/:owner/:repo/forks" + }, + listHooks: { + method: "GET", + params: { + owner: { + required: true, + type: "string" + }, + page: { + type: "integer" + }, + per_page: { + type: "integer" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/hooks" + }, + listInvitations: { + method: "GET", + params: { + owner: { + required: true, + type: "string" + }, + page: { + type: "integer" + }, + per_page: { + type: "integer" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/invitations" + }, + listInvitationsForAuthenticatedUser: { + method: "GET", + params: { + page: { + type: "integer" + }, + per_page: { + type: "integer" + } + }, + url: "/user/repository_invitations" + }, + listLanguages: { + method: "GET", + params: { + owner: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/languages" + }, + listPagesBuilds: { + method: "GET", + params: { + owner: { + required: true, + type: "string" + }, + page: { + type: "integer" + }, + per_page: { + type: "integer" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/pages/builds" + }, + listProtectedBranchRequiredStatusChecksContexts: { + method: "GET", + params: { + branch: { + required: true, + type: "string" + }, + owner: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/branches/:branch/protection/required_status_checks/contexts" + }, + listProtectedBranchTeamRestrictions: { + deprecated: "octokit.repos.listProtectedBranchTeamRestrictions() has been renamed to octokit.repos.getTeamsWithAccessToProtectedBranch() (2019-09-09)", + method: "GET", + params: { + branch: { + required: true, + type: "string" + }, + owner: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/branches/:branch/protection/restrictions/teams" + }, + listProtectedBranchUserRestrictions: { + deprecated: "octokit.repos.listProtectedBranchUserRestrictions() has been renamed to octokit.repos.getUsersWithAccessToProtectedBranch() (2019-09-09)", + method: "GET", + params: { + branch: { + required: true, + type: "string" + }, + owner: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/branches/:branch/protection/restrictions/users" + }, + listPublic: { + method: "GET", + params: { + page: { + type: "integer" + }, + per_page: { + type: "integer" + }, + since: { + type: "integer" + } + }, + url: "/repositories" + }, + listPullRequestsAssociatedWithCommit: { + headers: { + accept: "application/vnd.github.groot-preview+json" + }, + method: "GET", + params: { + commit_sha: { + required: true, + type: "string" + }, + owner: { + required: true, + type: "string" + }, + page: { + type: "integer" + }, + per_page: { + type: "integer" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/commits/:commit_sha/pulls" + }, + listReleases: { + method: "GET", + params: { + owner: { + required: true, + type: "string" + }, + page: { + type: "integer" + }, + per_page: { + type: "integer" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/releases" + }, + listStatusesForRef: { + method: "GET", + params: { + owner: { + required: true, + type: "string" + }, + page: { + type: "integer" + }, + per_page: { + type: "integer" + }, + ref: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/commits/:ref/statuses" + }, + listTags: { + method: "GET", + params: { + owner: { + required: true, + type: "string" + }, + page: { + type: "integer" + }, + per_page: { + type: "integer" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/tags" + }, + listTeams: { + method: "GET", + params: { + owner: { + required: true, + type: "string" + }, + page: { + type: "integer" + }, + per_page: { + type: "integer" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/teams" + }, + listTeamsWithAccessToProtectedBranch: { + deprecated: "octokit.repos.listTeamsWithAccessToProtectedBranch() has been renamed to octokit.repos.getTeamsWithAccessToProtectedBranch() (2019-09-13)", + method: "GET", + params: { + branch: { + required: true, + type: "string" + }, + owner: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/branches/:branch/protection/restrictions/teams" + }, + listTopics: { + headers: { + accept: "application/vnd.github.mercy-preview+json" + }, + method: "GET", + params: { + owner: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/topics" + }, + listUsersWithAccessToProtectedBranch: { + deprecated: "octokit.repos.listUsersWithAccessToProtectedBranch() has been renamed to octokit.repos.getUsersWithAccessToProtectedBranch() (2019-09-13)", + method: "GET", + params: { + branch: { + required: true, + type: "string" + }, + owner: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/branches/:branch/protection/restrictions/users" + }, + merge: { + method: "POST", + params: { + base: { + required: true, + type: "string" + }, + commit_message: { + type: "string" + }, + head: { + required: true, + type: "string" + }, + owner: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/merges" + }, + pingHook: { + method: "POST", + params: { + hook_id: { + required: true, + type: "integer" + }, + owner: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/hooks/:hook_id/pings" + }, + removeBranchProtection: { + method: "DELETE", + params: { + branch: { + required: true, + type: "string" + }, + owner: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/branches/:branch/protection" + }, + removeCollaborator: { + method: "DELETE", + params: { + owner: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + }, + username: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/collaborators/:username" + }, + removeDeployKey: { + method: "DELETE", + params: { + key_id: { + required: true, + type: "integer" + }, + owner: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/keys/:key_id" + }, + removeProtectedBranchAdminEnforcement: { + method: "DELETE", + params: { + branch: { + required: true, + type: "string" + }, + owner: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/branches/:branch/protection/enforce_admins" + }, + removeProtectedBranchAppRestrictions: { + method: "DELETE", + params: { + apps: { + mapTo: "data", + required: true, + type: "string[]" + }, + branch: { + required: true, + type: "string" + }, + owner: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/branches/:branch/protection/restrictions/apps" + }, + removeProtectedBranchPullRequestReviewEnforcement: { + method: "DELETE", + params: { + branch: { + required: true, + type: "string" + }, + owner: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/branches/:branch/protection/required_pull_request_reviews" + }, + removeProtectedBranchRequiredSignatures: { + headers: { + accept: "application/vnd.github.zzzax-preview+json" + }, + method: "DELETE", + params: { + branch: { + required: true, + type: "string" + }, + owner: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/branches/:branch/protection/required_signatures" + }, + removeProtectedBranchRequiredStatusChecks: { + method: "DELETE", + params: { + branch: { + required: true, + type: "string" + }, + owner: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/branches/:branch/protection/required_status_checks" + }, + removeProtectedBranchRequiredStatusChecksContexts: { + method: "DELETE", + params: { + branch: { + required: true, + type: "string" + }, + contexts: { + mapTo: "data", + required: true, + type: "string[]" + }, + owner: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/branches/:branch/protection/required_status_checks/contexts" + }, + removeProtectedBranchRestrictions: { + method: "DELETE", + params: { + branch: { + required: true, + type: "string" + }, + owner: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/branches/:branch/protection/restrictions" + }, + removeProtectedBranchTeamRestrictions: { + method: "DELETE", + params: { + branch: { + required: true, + type: "string" + }, + owner: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + }, + teams: { + mapTo: "data", + required: true, + type: "string[]" + } + }, + url: "/repos/:owner/:repo/branches/:branch/protection/restrictions/teams" + }, + removeProtectedBranchUserRestrictions: { + method: "DELETE", + params: { + branch: { + required: true, + type: "string" + }, + owner: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + }, + users: { + mapTo: "data", + required: true, + type: "string[]" + } + }, + url: "/repos/:owner/:repo/branches/:branch/protection/restrictions/users" + }, + replaceProtectedBranchAppRestrictions: { + method: "PUT", + params: { + apps: { + mapTo: "data", + required: true, + type: "string[]" + }, + branch: { + required: true, + type: "string" + }, + owner: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/branches/:branch/protection/restrictions/apps" + }, + replaceProtectedBranchRequiredStatusChecksContexts: { + method: "PUT", + params: { + branch: { + required: true, + type: "string" + }, + contexts: { + mapTo: "data", + required: true, + type: "string[]" + }, + owner: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/branches/:branch/protection/required_status_checks/contexts" + }, + replaceProtectedBranchTeamRestrictions: { + method: "PUT", + params: { + branch: { + required: true, + type: "string" + }, + owner: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + }, + teams: { + mapTo: "data", + required: true, + type: "string[]" + } + }, + url: "/repos/:owner/:repo/branches/:branch/protection/restrictions/teams" + }, + replaceProtectedBranchUserRestrictions: { + method: "PUT", + params: { + branch: { + required: true, + type: "string" + }, + owner: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + }, + users: { + mapTo: "data", + required: true, + type: "string[]" + } + }, + url: "/repos/:owner/:repo/branches/:branch/protection/restrictions/users" + }, + replaceTopics: { + headers: { + accept: "application/vnd.github.mercy-preview+json" + }, + method: "PUT", + params: { + names: { + required: true, + type: "string[]" + }, + owner: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/topics" + }, + requestPageBuild: { + method: "POST", + params: { + owner: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/pages/builds" + }, + retrieveCommunityProfileMetrics: { + method: "GET", + params: { + owner: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/community/profile" + }, + testPushHook: { + method: "POST", + params: { + hook_id: { + required: true, + type: "integer" + }, + owner: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/hooks/:hook_id/tests" + }, + transfer: { + method: "POST", + params: { + new_owner: { + type: "string" + }, + owner: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + }, + team_ids: { + type: "integer[]" + } + }, + url: "/repos/:owner/:repo/transfer" + }, + update: { + method: "PATCH", + params: { + allow_merge_commit: { + type: "boolean" + }, + allow_rebase_merge: { + type: "boolean" + }, + allow_squash_merge: { + type: "boolean" + }, + archived: { + type: "boolean" + }, + default_branch: { + type: "string" + }, + delete_branch_on_merge: { + type: "boolean" + }, + description: { + type: "string" + }, + has_issues: { + type: "boolean" + }, + has_projects: { + type: "boolean" + }, + has_wiki: { + type: "boolean" + }, + homepage: { + type: "string" + }, + is_template: { + type: "boolean" + }, + name: { + type: "string" + }, + owner: { + required: true, + type: "string" + }, + private: { + type: "boolean" + }, + repo: { + required: true, + type: "string" + }, + visibility: { + enum: ["public", "private", "visibility", "internal"], + type: "string" + } + }, + url: "/repos/:owner/:repo" + }, + updateBranchProtection: { + method: "PUT", + params: { + allow_deletions: { + type: "boolean" + }, + allow_force_pushes: { + allowNull: true, + type: "boolean" + }, + branch: { + required: true, + type: "string" + }, + enforce_admins: { + allowNull: true, + required: true, + type: "boolean" + }, + owner: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + }, + required_linear_history: { + type: "boolean" + }, + required_pull_request_reviews: { + allowNull: true, + required: true, + type: "object" + }, + "required_pull_request_reviews.dismiss_stale_reviews": { + type: "boolean" + }, + "required_pull_request_reviews.dismissal_restrictions": { + type: "object" + }, + "required_pull_request_reviews.dismissal_restrictions.teams": { + type: "string[]" + }, + "required_pull_request_reviews.dismissal_restrictions.users": { + type: "string[]" + }, + "required_pull_request_reviews.require_code_owner_reviews": { + type: "boolean" + }, + "required_pull_request_reviews.required_approving_review_count": { + type: "integer" + }, + required_status_checks: { + allowNull: true, + required: true, + type: "object" + }, + "required_status_checks.contexts": { + required: true, + type: "string[]" + }, + "required_status_checks.strict": { + required: true, + type: "boolean" + }, + restrictions: { + allowNull: true, + required: true, + type: "object" + }, + "restrictions.apps": { + type: "string[]" + }, + "restrictions.teams": { + required: true, + type: "string[]" + }, + "restrictions.users": { + required: true, + type: "string[]" + } + }, + url: "/repos/:owner/:repo/branches/:branch/protection" + }, + updateCommitComment: { + method: "PATCH", + params: { + body: { + required: true, + type: "string" + }, + comment_id: { + required: true, + type: "integer" + }, + owner: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/comments/:comment_id" + }, + updateFile: { + deprecated: "octokit.repos.updateFile() has been renamed to octokit.repos.createOrUpdateFile() (2019-06-07)", + method: "PUT", + params: { + author: { + type: "object" + }, + "author.email": { + required: true, + type: "string" + }, + "author.name": { + required: true, + type: "string" + }, + branch: { + type: "string" + }, + committer: { + type: "object" + }, + "committer.email": { + required: true, + type: "string" + }, + "committer.name": { + required: true, + type: "string" + }, + content: { + required: true, + type: "string" + }, + message: { + required: true, + type: "string" + }, + owner: { + required: true, + type: "string" + }, + path: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + }, + sha: { + type: "string" + } + }, + url: "/repos/:owner/:repo/contents/:path" + }, + updateHook: { + method: "PATCH", + params: { + active: { + type: "boolean" + }, + add_events: { + type: "string[]" + }, + config: { + type: "object" + }, + "config.content_type": { + type: "string" + }, + "config.insecure_ssl": { + type: "string" + }, + "config.secret": { + type: "string" + }, + "config.url": { + required: true, + type: "string" + }, + events: { + type: "string[]" + }, + hook_id: { + required: true, + type: "integer" + }, + owner: { + required: true, + type: "string" + }, + remove_events: { + type: "string[]" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/hooks/:hook_id" + }, + updateInformationAboutPagesSite: { + method: "PUT", + params: { + cname: { + type: "string" + }, + owner: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + }, + source: { + enum: ['"gh-pages"', '"master"', '"master /docs"'], + type: "string" + } + }, + url: "/repos/:owner/:repo/pages" + }, + updateInvitation: { + method: "PATCH", + params: { + invitation_id: { + required: true, + type: "integer" + }, + owner: { + required: true, + type: "string" + }, + permissions: { + enum: ["read", "write", "admin"], + type: "string" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/invitations/:invitation_id" + }, + updateProtectedBranchPullRequestReviewEnforcement: { + method: "PATCH", + params: { + branch: { + required: true, + type: "string" + }, + dismiss_stale_reviews: { + type: "boolean" + }, + dismissal_restrictions: { + type: "object" + }, + "dismissal_restrictions.teams": { + type: "string[]" + }, + "dismissal_restrictions.users": { + type: "string[]" + }, + owner: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + }, + require_code_owner_reviews: { + type: "boolean" + }, + required_approving_review_count: { + type: "integer" + } + }, + url: "/repos/:owner/:repo/branches/:branch/protection/required_pull_request_reviews" + }, + updateProtectedBranchRequiredStatusChecks: { + method: "PATCH", + params: { + branch: { + required: true, + type: "string" + }, + contexts: { + type: "string[]" + }, + owner: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + }, + strict: { + type: "boolean" + } + }, + url: "/repos/:owner/:repo/branches/:branch/protection/required_status_checks" + }, + updateRelease: { + method: "PATCH", + params: { + body: { + type: "string" + }, + draft: { + type: "boolean" + }, + name: { + type: "string" + }, + owner: { + required: true, + type: "string" + }, + prerelease: { + type: "boolean" + }, + release_id: { + required: true, + type: "integer" + }, + repo: { + required: true, + type: "string" + }, + tag_name: { + type: "string" + }, + target_commitish: { + type: "string" + } + }, + url: "/repos/:owner/:repo/releases/:release_id" + }, + updateReleaseAsset: { + method: "PATCH", + params: { + asset_id: { + required: true, + type: "integer" + }, + label: { + type: "string" + }, + name: { + type: "string" + }, + owner: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + } + }, + url: "/repos/:owner/:repo/releases/assets/:asset_id" + }, + uploadReleaseAsset: { + method: "POST", + params: { + data: { + mapTo: "data", + required: true, + type: "string | object" + }, + file: { + alias: "data", + deprecated: true, + type: "string | object" + }, + headers: { + required: true, + type: "object" + }, + "headers.content-length": { + required: true, + type: "integer" + }, + "headers.content-type": { + required: true, + type: "string" + }, + label: { + type: "string" + }, + name: { + required: true, + type: "string" + }, + url: { + required: true, + type: "string" + } + }, + url: ":url" + } + }, + search: { + code: { + method: "GET", + params: { + order: { + enum: ["desc", "asc"], + type: "string" + }, + page: { + type: "integer" + }, + per_page: { + type: "integer" + }, + q: { + required: true, + type: "string" + }, + sort: { + enum: ["indexed"], + type: "string" + } + }, + url: "/search/code" + }, + commits: { + headers: { + accept: "application/vnd.github.cloak-preview+json" + }, + method: "GET", + params: { + order: { + enum: ["desc", "asc"], + type: "string" + }, + page: { + type: "integer" + }, + per_page: { + type: "integer" + }, + q: { + required: true, + type: "string" + }, + sort: { + enum: ["author-date", "committer-date"], + type: "string" + } + }, + url: "/search/commits" + }, + issues: { + deprecated: "octokit.search.issues() has been renamed to octokit.search.issuesAndPullRequests() (2018-12-27)", + method: "GET", + params: { + order: { + enum: ["desc", "asc"], + type: "string" + }, + page: { + type: "integer" + }, + per_page: { + type: "integer" + }, + q: { + required: true, + type: "string" + }, + sort: { + enum: ["comments", "reactions", "reactions-+1", "reactions--1", "reactions-smile", "reactions-thinking_face", "reactions-heart", "reactions-tada", "interactions", "created", "updated"], + type: "string" + } + }, + url: "/search/issues" + }, + issuesAndPullRequests: { + method: "GET", + params: { + order: { + enum: ["desc", "asc"], + type: "string" + }, + page: { + type: "integer" + }, + per_page: { + type: "integer" + }, + q: { + required: true, + type: "string" + }, + sort: { + enum: ["comments", "reactions", "reactions-+1", "reactions--1", "reactions-smile", "reactions-thinking_face", "reactions-heart", "reactions-tada", "interactions", "created", "updated"], + type: "string" + } + }, + url: "/search/issues" + }, + labels: { + method: "GET", + params: { + order: { + enum: ["desc", "asc"], + type: "string" + }, + q: { + required: true, + type: "string" + }, + repository_id: { + required: true, + type: "integer" + }, + sort: { + enum: ["created", "updated"], + type: "string" + } + }, + url: "/search/labels" + }, + repos: { + method: "GET", + params: { + order: { + enum: ["desc", "asc"], + type: "string" + }, + page: { + type: "integer" + }, + per_page: { + type: "integer" + }, + q: { + required: true, + type: "string" + }, + sort: { + enum: ["stars", "forks", "help-wanted-issues", "updated"], + type: "string" + } + }, + url: "/search/repositories" + }, + topics: { + method: "GET", + params: { + q: { + required: true, + type: "string" + } + }, + url: "/search/topics" + }, + users: { + method: "GET", + params: { + order: { + enum: ["desc", "asc"], + type: "string" + }, + page: { + type: "integer" + }, + per_page: { + type: "integer" + }, + q: { + required: true, + type: "string" + }, + sort: { + enum: ["followers", "repositories", "joined"], + type: "string" + } + }, + url: "/search/users" + } + }, + teams: { + addMember: { + deprecated: "octokit.teams.addMember() has been renamed to octokit.teams.addMemberLegacy() (2020-01-16)", + method: "PUT", + params: { + team_id: { + required: true, + type: "integer" + }, + username: { + required: true, + type: "string" + } + }, + url: "/teams/:team_id/members/:username" + }, + addMemberLegacy: { + deprecated: "octokit.teams.addMemberLegacy() is deprecated, see https://developer.github.com/v3/teams/members/#add-team-member-legacy", + method: "PUT", + params: { + team_id: { + required: true, + type: "integer" + }, + username: { + required: true, + type: "string" + } + }, + url: "/teams/:team_id/members/:username" + }, + addOrUpdateMembership: { + deprecated: "octokit.teams.addOrUpdateMembership() has been renamed to octokit.teams.addOrUpdateMembershipLegacy() (2020-01-16)", + method: "PUT", + params: { + role: { + enum: ["member", "maintainer"], + type: "string" + }, + team_id: { + required: true, + type: "integer" + }, + username: { + required: true, + type: "string" + } + }, + url: "/teams/:team_id/memberships/:username" + }, + addOrUpdateMembershipInOrg: { + method: "PUT", + params: { + org: { + required: true, + type: "string" + }, + role: { + enum: ["member", "maintainer"], + type: "string" + }, + team_slug: { + required: true, + type: "string" + }, + username: { + required: true, + type: "string" + } + }, + url: "/orgs/:org/teams/:team_slug/memberships/:username" + }, + addOrUpdateMembershipLegacy: { + deprecated: "octokit.teams.addOrUpdateMembershipLegacy() is deprecated, see https://developer.github.com/v3/teams/members/#add-or-update-team-membership-legacy", + method: "PUT", + params: { + role: { + enum: ["member", "maintainer"], + type: "string" + }, + team_id: { + required: true, + type: "integer" + }, + username: { + required: true, + type: "string" + } + }, + url: "/teams/:team_id/memberships/:username" + }, + addOrUpdateProject: { + deprecated: "octokit.teams.addOrUpdateProject() has been renamed to octokit.teams.addOrUpdateProjectLegacy() (2020-01-16)", + headers: { + accept: "application/vnd.github.inertia-preview+json" + }, + method: "PUT", + params: { + permission: { + enum: ["read", "write", "admin"], + type: "string" + }, + project_id: { + required: true, + type: "integer" + }, + team_id: { + required: true, + type: "integer" + } + }, + url: "/teams/:team_id/projects/:project_id" + }, + addOrUpdateProjectInOrg: { + headers: { + accept: "application/vnd.github.inertia-preview+json" + }, + method: "PUT", + params: { + org: { + required: true, + type: "string" + }, + permission: { + enum: ["read", "write", "admin"], + type: "string" + }, + project_id: { + required: true, + type: "integer" + }, + team_slug: { + required: true, + type: "string" + } + }, + url: "/orgs/:org/teams/:team_slug/projects/:project_id" + }, + addOrUpdateProjectLegacy: { + deprecated: "octokit.teams.addOrUpdateProjectLegacy() is deprecated, see https://developer.github.com/v3/teams/#add-or-update-team-project-legacy", + headers: { + accept: "application/vnd.github.inertia-preview+json" + }, + method: "PUT", + params: { + permission: { + enum: ["read", "write", "admin"], + type: "string" + }, + project_id: { + required: true, + type: "integer" + }, + team_id: { + required: true, + type: "integer" + } + }, + url: "/teams/:team_id/projects/:project_id" + }, + addOrUpdateRepo: { + deprecated: "octokit.teams.addOrUpdateRepo() has been renamed to octokit.teams.addOrUpdateRepoLegacy() (2020-01-16)", + method: "PUT", + params: { + owner: { + required: true, + type: "string" + }, + permission: { + enum: ["pull", "push", "admin"], + type: "string" + }, + repo: { + required: true, + type: "string" + }, + team_id: { + required: true, + type: "integer" + } + }, + url: "/teams/:team_id/repos/:owner/:repo" + }, + addOrUpdateRepoInOrg: { + method: "PUT", + params: { + org: { + required: true, + type: "string" + }, + owner: { + required: true, + type: "string" + }, + permission: { + enum: ["pull", "push", "admin"], + type: "string" + }, + repo: { + required: true, + type: "string" + }, + team_slug: { + required: true, + type: "string" + } + }, + url: "/orgs/:org/teams/:team_slug/repos/:owner/:repo" + }, + addOrUpdateRepoLegacy: { + deprecated: "octokit.teams.addOrUpdateRepoLegacy() is deprecated, see https://developer.github.com/v3/teams/#add-or-update-team-repository-legacy", + method: "PUT", + params: { + owner: { + required: true, + type: "string" + }, + permission: { + enum: ["pull", "push", "admin"], + type: "string" + }, + repo: { + required: true, + type: "string" + }, + team_id: { + required: true, + type: "integer" + } + }, + url: "/teams/:team_id/repos/:owner/:repo" + }, + checkManagesRepo: { + deprecated: "octokit.teams.checkManagesRepo() has been renamed to octokit.teams.checkManagesRepoLegacy() (2020-01-16)", + method: "GET", + params: { + owner: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + }, + team_id: { + required: true, + type: "integer" + } + }, + url: "/teams/:team_id/repos/:owner/:repo" + }, + checkManagesRepoInOrg: { + method: "GET", + params: { + org: { + required: true, + type: "string" + }, + owner: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + }, + team_slug: { + required: true, + type: "string" + } + }, + url: "/orgs/:org/teams/:team_slug/repos/:owner/:repo" + }, + checkManagesRepoLegacy: { + deprecated: "octokit.teams.checkManagesRepoLegacy() is deprecated, see https://developer.github.com/v3/teams/#check-if-a-team-manages-a-repository-legacy", + method: "GET", + params: { + owner: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + }, + team_id: { + required: true, + type: "integer" + } + }, + url: "/teams/:team_id/repos/:owner/:repo" + }, + create: { + method: "POST", + params: { + description: { + type: "string" + }, + maintainers: { + type: "string[]" + }, + name: { + required: true, + type: "string" + }, + org: { + required: true, + type: "string" + }, + parent_team_id: { + type: "integer" + }, + permission: { + enum: ["pull", "push", "admin"], + type: "string" + }, + privacy: { + enum: ["secret", "closed"], + type: "string" + }, + repo_names: { + type: "string[]" + } + }, + url: "/orgs/:org/teams" + }, + createDiscussion: { + deprecated: "octokit.teams.createDiscussion() has been renamed to octokit.teams.createDiscussionLegacy() (2020-01-16)", + method: "POST", + params: { + body: { + required: true, + type: "string" + }, + private: { + type: "boolean" + }, + team_id: { + required: true, + type: "integer" + }, + title: { + required: true, + type: "string" + } + }, + url: "/teams/:team_id/discussions" + }, + createDiscussionComment: { + deprecated: "octokit.teams.createDiscussionComment() has been renamed to octokit.teams.createDiscussionCommentLegacy() (2020-01-16)", + method: "POST", + params: { + body: { + required: true, + type: "string" + }, + discussion_number: { + required: true, + type: "integer" + }, + team_id: { + required: true, + type: "integer" + } + }, + url: "/teams/:team_id/discussions/:discussion_number/comments" + }, + createDiscussionCommentInOrg: { + method: "POST", + params: { + body: { + required: true, + type: "string" + }, + discussion_number: { + required: true, + type: "integer" + }, + org: { + required: true, + type: "string" + }, + team_slug: { + required: true, + type: "string" + } + }, + url: "/orgs/:org/teams/:team_slug/discussions/:discussion_number/comments" + }, + createDiscussionCommentLegacy: { + deprecated: "octokit.teams.createDiscussionCommentLegacy() is deprecated, see https://developer.github.com/v3/teams/discussion_comments/#create-a-comment-legacy", + method: "POST", + params: { + body: { + required: true, + type: "string" + }, + discussion_number: { + required: true, + type: "integer" + }, + team_id: { + required: true, + type: "integer" + } + }, + url: "/teams/:team_id/discussions/:discussion_number/comments" + }, + createDiscussionInOrg: { + method: "POST", + params: { + body: { + required: true, + type: "string" + }, + org: { + required: true, + type: "string" + }, + private: { + type: "boolean" + }, + team_slug: { + required: true, + type: "string" + }, + title: { + required: true, + type: "string" + } + }, + url: "/orgs/:org/teams/:team_slug/discussions" + }, + createDiscussionLegacy: { + deprecated: "octokit.teams.createDiscussionLegacy() is deprecated, see https://developer.github.com/v3/teams/discussions/#create-a-discussion-legacy", + method: "POST", + params: { + body: { + required: true, + type: "string" + }, + private: { + type: "boolean" + }, + team_id: { + required: true, + type: "integer" + }, + title: { + required: true, + type: "string" + } + }, + url: "/teams/:team_id/discussions" + }, + delete: { + deprecated: "octokit.teams.delete() has been renamed to octokit.teams.deleteLegacy() (2020-01-16)", + method: "DELETE", + params: { + team_id: { + required: true, + type: "integer" + } + }, + url: "/teams/:team_id" + }, + deleteDiscussion: { + deprecated: "octokit.teams.deleteDiscussion() has been renamed to octokit.teams.deleteDiscussionLegacy() (2020-01-16)", + method: "DELETE", + params: { + discussion_number: { + required: true, + type: "integer" + }, + team_id: { + required: true, + type: "integer" + } + }, + url: "/teams/:team_id/discussions/:discussion_number" + }, + deleteDiscussionComment: { + deprecated: "octokit.teams.deleteDiscussionComment() has been renamed to octokit.teams.deleteDiscussionCommentLegacy() (2020-01-16)", + method: "DELETE", + params: { + comment_number: { + required: true, + type: "integer" + }, + discussion_number: { + required: true, + type: "integer" + }, + team_id: { + required: true, + type: "integer" + } + }, + url: "/teams/:team_id/discussions/:discussion_number/comments/:comment_number" + }, + deleteDiscussionCommentInOrg: { + method: "DELETE", + params: { + comment_number: { + required: true, + type: "integer" + }, + discussion_number: { + required: true, + type: "integer" + }, + org: { + required: true, + type: "string" + }, + team_slug: { + required: true, + type: "string" + } + }, + url: "/orgs/:org/teams/:team_slug/discussions/:discussion_number/comments/:comment_number" + }, + deleteDiscussionCommentLegacy: { + deprecated: "octokit.teams.deleteDiscussionCommentLegacy() is deprecated, see https://developer.github.com/v3/teams/discussion_comments/#delete-a-comment-legacy", + method: "DELETE", + params: { + comment_number: { + required: true, + type: "integer" + }, + discussion_number: { + required: true, + type: "integer" + }, + team_id: { + required: true, + type: "integer" + } + }, + url: "/teams/:team_id/discussions/:discussion_number/comments/:comment_number" + }, + deleteDiscussionInOrg: { + method: "DELETE", + params: { + discussion_number: { + required: true, + type: "integer" + }, + org: { + required: true, + type: "string" + }, + team_slug: { + required: true, + type: "string" + } + }, + url: "/orgs/:org/teams/:team_slug/discussions/:discussion_number" + }, + deleteDiscussionLegacy: { + deprecated: "octokit.teams.deleteDiscussionLegacy() is deprecated, see https://developer.github.com/v3/teams/discussions/#delete-a-discussion-legacy", + method: "DELETE", + params: { + discussion_number: { + required: true, + type: "integer" + }, + team_id: { + required: true, + type: "integer" + } + }, + url: "/teams/:team_id/discussions/:discussion_number" + }, + deleteInOrg: { + method: "DELETE", + params: { + org: { + required: true, + type: "string" + }, + team_slug: { + required: true, + type: "string" + } + }, + url: "/orgs/:org/teams/:team_slug" + }, + deleteLegacy: { + deprecated: "octokit.teams.deleteLegacy() is deprecated, see https://developer.github.com/v3/teams/#delete-team-legacy", + method: "DELETE", + params: { + team_id: { + required: true, + type: "integer" + } + }, + url: "/teams/:team_id" + }, + get: { + deprecated: "octokit.teams.get() has been renamed to octokit.teams.getLegacy() (2020-01-16)", + method: "GET", + params: { + team_id: { + required: true, + type: "integer" + } + }, + url: "/teams/:team_id" + }, + getByName: { + method: "GET", + params: { + org: { + required: true, + type: "string" + }, + team_slug: { + required: true, + type: "string" + } + }, + url: "/orgs/:org/teams/:team_slug" + }, + getDiscussion: { + deprecated: "octokit.teams.getDiscussion() has been renamed to octokit.teams.getDiscussionLegacy() (2020-01-16)", + method: "GET", + params: { + discussion_number: { + required: true, + type: "integer" + }, + team_id: { + required: true, + type: "integer" + } + }, + url: "/teams/:team_id/discussions/:discussion_number" + }, + getDiscussionComment: { + deprecated: "octokit.teams.getDiscussionComment() has been renamed to octokit.teams.getDiscussionCommentLegacy() (2020-01-16)", + method: "GET", + params: { + comment_number: { + required: true, + type: "integer" + }, + discussion_number: { + required: true, + type: "integer" + }, + team_id: { + required: true, + type: "integer" + } + }, + url: "/teams/:team_id/discussions/:discussion_number/comments/:comment_number" + }, + getDiscussionCommentInOrg: { + method: "GET", + params: { + comment_number: { + required: true, + type: "integer" + }, + discussion_number: { + required: true, + type: "integer" + }, + org: { + required: true, + type: "string" + }, + team_slug: { + required: true, + type: "string" + } + }, + url: "/orgs/:org/teams/:team_slug/discussions/:discussion_number/comments/:comment_number" + }, + getDiscussionCommentLegacy: { + deprecated: "octokit.teams.getDiscussionCommentLegacy() is deprecated, see https://developer.github.com/v3/teams/discussion_comments/#get-a-single-comment-legacy", + method: "GET", + params: { + comment_number: { + required: true, + type: "integer" + }, + discussion_number: { + required: true, + type: "integer" + }, + team_id: { + required: true, + type: "integer" + } + }, + url: "/teams/:team_id/discussions/:discussion_number/comments/:comment_number" + }, + getDiscussionInOrg: { + method: "GET", + params: { + discussion_number: { + required: true, + type: "integer" + }, + org: { + required: true, + type: "string" + }, + team_slug: { + required: true, + type: "string" + } + }, + url: "/orgs/:org/teams/:team_slug/discussions/:discussion_number" + }, + getDiscussionLegacy: { + deprecated: "octokit.teams.getDiscussionLegacy() is deprecated, see https://developer.github.com/v3/teams/discussions/#get-a-single-discussion-legacy", + method: "GET", + params: { + discussion_number: { + required: true, + type: "integer" + }, + team_id: { + required: true, + type: "integer" + } + }, + url: "/teams/:team_id/discussions/:discussion_number" + }, + getLegacy: { + deprecated: "octokit.teams.getLegacy() is deprecated, see https://developer.github.com/v3/teams/#get-team-legacy", + method: "GET", + params: { + team_id: { + required: true, + type: "integer" + } + }, + url: "/teams/:team_id" + }, + getMember: { + deprecated: "octokit.teams.getMember() has been renamed to octokit.teams.getMemberLegacy() (2020-01-16)", + method: "GET", + params: { + team_id: { + required: true, + type: "integer" + }, + username: { + required: true, + type: "string" + } + }, + url: "/teams/:team_id/members/:username" + }, + getMemberLegacy: { + deprecated: "octokit.teams.getMemberLegacy() is deprecated, see https://developer.github.com/v3/teams/members/#get-team-member-legacy", + method: "GET", + params: { + team_id: { + required: true, + type: "integer" + }, + username: { + required: true, + type: "string" + } + }, + url: "/teams/:team_id/members/:username" + }, + getMembership: { + deprecated: "octokit.teams.getMembership() has been renamed to octokit.teams.getMembershipLegacy() (2020-01-16)", + method: "GET", + params: { + team_id: { + required: true, + type: "integer" + }, + username: { + required: true, + type: "string" + } + }, + url: "/teams/:team_id/memberships/:username" + }, + getMembershipInOrg: { + method: "GET", + params: { + org: { + required: true, + type: "string" + }, + team_slug: { + required: true, + type: "string" + }, + username: { + required: true, + type: "string" + } + }, + url: "/orgs/:org/teams/:team_slug/memberships/:username" + }, + getMembershipLegacy: { + deprecated: "octokit.teams.getMembershipLegacy() is deprecated, see https://developer.github.com/v3/teams/members/#get-team-membership-legacy", + method: "GET", + params: { + team_id: { + required: true, + type: "integer" + }, + username: { + required: true, + type: "string" + } + }, + url: "/teams/:team_id/memberships/:username" + }, + list: { + method: "GET", + params: { + org: { + required: true, + type: "string" + }, + page: { + type: "integer" + }, + per_page: { + type: "integer" + } + }, + url: "/orgs/:org/teams" + }, + listChild: { + deprecated: "octokit.teams.listChild() has been renamed to octokit.teams.listChildLegacy() (2020-01-16)", + method: "GET", + params: { + page: { + type: "integer" + }, + per_page: { + type: "integer" + }, + team_id: { + required: true, + type: "integer" + } + }, + url: "/teams/:team_id/teams" + }, + listChildInOrg: { + method: "GET", + params: { + org: { + required: true, + type: "string" + }, + page: { + type: "integer" + }, + per_page: { + type: "integer" + }, + team_slug: { + required: true, + type: "string" + } + }, + url: "/orgs/:org/teams/:team_slug/teams" + }, + listChildLegacy: { + deprecated: "octokit.teams.listChildLegacy() is deprecated, see https://developer.github.com/v3/teams/#list-child-teams-legacy", + method: "GET", + params: { + page: { + type: "integer" + }, + per_page: { + type: "integer" + }, + team_id: { + required: true, + type: "integer" + } + }, + url: "/teams/:team_id/teams" + }, + listDiscussionComments: { + deprecated: "octokit.teams.listDiscussionComments() has been renamed to octokit.teams.listDiscussionCommentsLegacy() (2020-01-16)", + method: "GET", + params: { + direction: { + enum: ["asc", "desc"], + type: "string" + }, + discussion_number: { + required: true, + type: "integer" + }, + page: { + type: "integer" + }, + per_page: { + type: "integer" + }, + team_id: { + required: true, + type: "integer" + } + }, + url: "/teams/:team_id/discussions/:discussion_number/comments" + }, + listDiscussionCommentsInOrg: { + method: "GET", + params: { + direction: { + enum: ["asc", "desc"], + type: "string" + }, + discussion_number: { + required: true, + type: "integer" + }, + org: { + required: true, + type: "string" + }, + page: { + type: "integer" + }, + per_page: { + type: "integer" + }, + team_slug: { + required: true, + type: "string" + } + }, + url: "/orgs/:org/teams/:team_slug/discussions/:discussion_number/comments" + }, + listDiscussionCommentsLegacy: { + deprecated: "octokit.teams.listDiscussionCommentsLegacy() is deprecated, see https://developer.github.com/v3/teams/discussion_comments/#list-comments-legacy", + method: "GET", + params: { + direction: { + enum: ["asc", "desc"], + type: "string" + }, + discussion_number: { + required: true, + type: "integer" + }, + page: { + type: "integer" + }, + per_page: { + type: "integer" + }, + team_id: { + required: true, + type: "integer" + } + }, + url: "/teams/:team_id/discussions/:discussion_number/comments" + }, + listDiscussions: { + deprecated: "octokit.teams.listDiscussions() has been renamed to octokit.teams.listDiscussionsLegacy() (2020-01-16)", + method: "GET", + params: { + direction: { + enum: ["asc", "desc"], + type: "string" + }, + page: { + type: "integer" + }, + per_page: { + type: "integer" + }, + team_id: { + required: true, + type: "integer" + } + }, + url: "/teams/:team_id/discussions" + }, + listDiscussionsInOrg: { + method: "GET", + params: { + direction: { + enum: ["asc", "desc"], + type: "string" + }, + org: { + required: true, + type: "string" + }, + page: { + type: "integer" + }, + per_page: { + type: "integer" + }, + team_slug: { + required: true, + type: "string" + } + }, + url: "/orgs/:org/teams/:team_slug/discussions" + }, + listDiscussionsLegacy: { + deprecated: "octokit.teams.listDiscussionsLegacy() is deprecated, see https://developer.github.com/v3/teams/discussions/#list-discussions-legacy", + method: "GET", + params: { + direction: { + enum: ["asc", "desc"], + type: "string" + }, + page: { + type: "integer" + }, + per_page: { + type: "integer" + }, + team_id: { + required: true, + type: "integer" + } + }, + url: "/teams/:team_id/discussions" + }, + listForAuthenticatedUser: { + method: "GET", + params: { + page: { + type: "integer" + }, + per_page: { + type: "integer" + } + }, + url: "/user/teams" + }, + listMembers: { + deprecated: "octokit.teams.listMembers() has been renamed to octokit.teams.listMembersLegacy() (2020-01-16)", + method: "GET", + params: { + page: { + type: "integer" + }, + per_page: { + type: "integer" + }, + role: { + enum: ["member", "maintainer", "all"], + type: "string" + }, + team_id: { + required: true, + type: "integer" + } + }, + url: "/teams/:team_id/members" + }, + listMembersInOrg: { + method: "GET", + params: { + org: { + required: true, + type: "string" + }, + page: { + type: "integer" + }, + per_page: { + type: "integer" + }, + role: { + enum: ["member", "maintainer", "all"], + type: "string" + }, + team_slug: { + required: true, + type: "string" + } + }, + url: "/orgs/:org/teams/:team_slug/members" + }, + listMembersLegacy: { + deprecated: "octokit.teams.listMembersLegacy() is deprecated, see https://developer.github.com/v3/teams/members/#list-team-members-legacy", + method: "GET", + params: { + page: { + type: "integer" + }, + per_page: { + type: "integer" + }, + role: { + enum: ["member", "maintainer", "all"], + type: "string" + }, + team_id: { + required: true, + type: "integer" + } + }, + url: "/teams/:team_id/members" + }, + listPendingInvitations: { + deprecated: "octokit.teams.listPendingInvitations() has been renamed to octokit.teams.listPendingInvitationsLegacy() (2020-01-16)", + method: "GET", + params: { + page: { + type: "integer" + }, + per_page: { + type: "integer" + }, + team_id: { + required: true, + type: "integer" + } + }, + url: "/teams/:team_id/invitations" + }, + listPendingInvitationsInOrg: { + method: "GET", + params: { + org: { + required: true, + type: "string" + }, + page: { + type: "integer" + }, + per_page: { + type: "integer" + }, + team_slug: { + required: true, + type: "string" + } + }, + url: "/orgs/:org/teams/:team_slug/invitations" + }, + listPendingInvitationsLegacy: { + deprecated: "octokit.teams.listPendingInvitationsLegacy() is deprecated, see https://developer.github.com/v3/teams/members/#list-pending-team-invitations-legacy", + method: "GET", + params: { + page: { + type: "integer" + }, + per_page: { + type: "integer" + }, + team_id: { + required: true, + type: "integer" + } + }, + url: "/teams/:team_id/invitations" + }, + listProjects: { + deprecated: "octokit.teams.listProjects() has been renamed to octokit.teams.listProjectsLegacy() (2020-01-16)", + headers: { + accept: "application/vnd.github.inertia-preview+json" + }, + method: "GET", + params: { + page: { + type: "integer" + }, + per_page: { + type: "integer" + }, + team_id: { + required: true, + type: "integer" + } + }, + url: "/teams/:team_id/projects" + }, + listProjectsInOrg: { + headers: { + accept: "application/vnd.github.inertia-preview+json" + }, + method: "GET", + params: { + org: { + required: true, + type: "string" + }, + page: { + type: "integer" + }, + per_page: { + type: "integer" + }, + team_slug: { + required: true, + type: "string" + } + }, + url: "/orgs/:org/teams/:team_slug/projects" + }, + listProjectsLegacy: { + deprecated: "octokit.teams.listProjectsLegacy() is deprecated, see https://developer.github.com/v3/teams/#list-team-projects-legacy", + headers: { + accept: "application/vnd.github.inertia-preview+json" + }, + method: "GET", + params: { + page: { + type: "integer" + }, + per_page: { + type: "integer" + }, + team_id: { + required: true, + type: "integer" + } + }, + url: "/teams/:team_id/projects" + }, + listRepos: { + deprecated: "octokit.teams.listRepos() has been renamed to octokit.teams.listReposLegacy() (2020-01-16)", + method: "GET", + params: { + page: { + type: "integer" + }, + per_page: { + type: "integer" + }, + team_id: { + required: true, + type: "integer" + } + }, + url: "/teams/:team_id/repos" + }, + listReposInOrg: { + method: "GET", + params: { + org: { + required: true, + type: "string" + }, + page: { + type: "integer" + }, + per_page: { + type: "integer" + }, + team_slug: { + required: true, + type: "string" + } + }, + url: "/orgs/:org/teams/:team_slug/repos" + }, + listReposLegacy: { + deprecated: "octokit.teams.listReposLegacy() is deprecated, see https://developer.github.com/v3/teams/#list-team-repos-legacy", + method: "GET", + params: { + page: { + type: "integer" + }, + per_page: { + type: "integer" + }, + team_id: { + required: true, + type: "integer" + } + }, + url: "/teams/:team_id/repos" + }, + removeMember: { + deprecated: "octokit.teams.removeMember() has been renamed to octokit.teams.removeMemberLegacy() (2020-01-16)", + method: "DELETE", + params: { + team_id: { + required: true, + type: "integer" + }, + username: { + required: true, + type: "string" + } + }, + url: "/teams/:team_id/members/:username" + }, + removeMemberLegacy: { + deprecated: "octokit.teams.removeMemberLegacy() is deprecated, see https://developer.github.com/v3/teams/members/#remove-team-member-legacy", + method: "DELETE", + params: { + team_id: { + required: true, + type: "integer" + }, + username: { + required: true, + type: "string" + } + }, + url: "/teams/:team_id/members/:username" + }, + removeMembership: { + deprecated: "octokit.teams.removeMembership() has been renamed to octokit.teams.removeMembershipLegacy() (2020-01-16)", + method: "DELETE", + params: { + team_id: { + required: true, + type: "integer" + }, + username: { + required: true, + type: "string" + } + }, + url: "/teams/:team_id/memberships/:username" + }, + removeMembershipInOrg: { + method: "DELETE", + params: { + org: { + required: true, + type: "string" + }, + team_slug: { + required: true, + type: "string" + }, + username: { + required: true, + type: "string" + } + }, + url: "/orgs/:org/teams/:team_slug/memberships/:username" + }, + removeMembershipLegacy: { + deprecated: "octokit.teams.removeMembershipLegacy() is deprecated, see https://developer.github.com/v3/teams/members/#remove-team-membership-legacy", + method: "DELETE", + params: { + team_id: { + required: true, + type: "integer" + }, + username: { + required: true, + type: "string" + } + }, + url: "/teams/:team_id/memberships/:username" + }, + removeProject: { + deprecated: "octokit.teams.removeProject() has been renamed to octokit.teams.removeProjectLegacy() (2020-01-16)", + method: "DELETE", + params: { + project_id: { + required: true, + type: "integer" + }, + team_id: { + required: true, + type: "integer" + } + }, + url: "/teams/:team_id/projects/:project_id" + }, + removeProjectInOrg: { + method: "DELETE", + params: { + org: { + required: true, + type: "string" + }, + project_id: { + required: true, + type: "integer" + }, + team_slug: { + required: true, + type: "string" + } + }, + url: "/orgs/:org/teams/:team_slug/projects/:project_id" + }, + removeProjectLegacy: { + deprecated: "octokit.teams.removeProjectLegacy() is deprecated, see https://developer.github.com/v3/teams/#remove-team-project-legacy", + method: "DELETE", + params: { + project_id: { + required: true, + type: "integer" + }, + team_id: { + required: true, + type: "integer" + } + }, + url: "/teams/:team_id/projects/:project_id" + }, + removeRepo: { + deprecated: "octokit.teams.removeRepo() has been renamed to octokit.teams.removeRepoLegacy() (2020-01-16)", + method: "DELETE", + params: { + owner: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + }, + team_id: { + required: true, + type: "integer" + } + }, + url: "/teams/:team_id/repos/:owner/:repo" + }, + removeRepoInOrg: { + method: "DELETE", + params: { + org: { + required: true, + type: "string" + }, + owner: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + }, + team_slug: { + required: true, + type: "string" + } + }, + url: "/orgs/:org/teams/:team_slug/repos/:owner/:repo" + }, + removeRepoLegacy: { + deprecated: "octokit.teams.removeRepoLegacy() is deprecated, see https://developer.github.com/v3/teams/#remove-team-repository-legacy", + method: "DELETE", + params: { + owner: { + required: true, + type: "string" + }, + repo: { + required: true, + type: "string" + }, + team_id: { + required: true, + type: "integer" + } + }, + url: "/teams/:team_id/repos/:owner/:repo" + }, + reviewProject: { + deprecated: "octokit.teams.reviewProject() has been renamed to octokit.teams.reviewProjectLegacy() (2020-01-16)", + headers: { + accept: "application/vnd.github.inertia-preview+json" + }, + method: "GET", + params: { + project_id: { + required: true, + type: "integer" + }, + team_id: { + required: true, + type: "integer" + } + }, + url: "/teams/:team_id/projects/:project_id" + }, + reviewProjectInOrg: { + headers: { + accept: "application/vnd.github.inertia-preview+json" + }, + method: "GET", + params: { + org: { + required: true, + type: "string" + }, + project_id: { + required: true, + type: "integer" + }, + team_slug: { + required: true, + type: "string" + } + }, + url: "/orgs/:org/teams/:team_slug/projects/:project_id" + }, + reviewProjectLegacy: { + deprecated: "octokit.teams.reviewProjectLegacy() is deprecated, see https://developer.github.com/v3/teams/#review-a-team-project-legacy", + headers: { + accept: "application/vnd.github.inertia-preview+json" + }, + method: "GET", + params: { + project_id: { + required: true, + type: "integer" + }, + team_id: { + required: true, + type: "integer" + } + }, + url: "/teams/:team_id/projects/:project_id" + }, + update: { + deprecated: "octokit.teams.update() has been renamed to octokit.teams.updateLegacy() (2020-01-16)", + method: "PATCH", + params: { + description: { + type: "string" + }, + name: { + required: true, + type: "string" + }, + parent_team_id: { + type: "integer" + }, + permission: { + enum: ["pull", "push", "admin"], + type: "string" + }, + privacy: { + enum: ["secret", "closed"], + type: "string" + }, + team_id: { + required: true, + type: "integer" + } + }, + url: "/teams/:team_id" + }, + updateDiscussion: { + deprecated: "octokit.teams.updateDiscussion() has been renamed to octokit.teams.updateDiscussionLegacy() (2020-01-16)", + method: "PATCH", + params: { + body: { + type: "string" + }, + discussion_number: { + required: true, + type: "integer" + }, + team_id: { + required: true, + type: "integer" + }, + title: { + type: "string" + } + }, + url: "/teams/:team_id/discussions/:discussion_number" + }, + updateDiscussionComment: { + deprecated: "octokit.teams.updateDiscussionComment() has been renamed to octokit.teams.updateDiscussionCommentLegacy() (2020-01-16)", + method: "PATCH", + params: { + body: { + required: true, + type: "string" + }, + comment_number: { + required: true, + type: "integer" + }, + discussion_number: { + required: true, + type: "integer" + }, + team_id: { + required: true, + type: "integer" + } + }, + url: "/teams/:team_id/discussions/:discussion_number/comments/:comment_number" + }, + updateDiscussionCommentInOrg: { + method: "PATCH", + params: { + body: { + required: true, + type: "string" + }, + comment_number: { + required: true, + type: "integer" + }, + discussion_number: { + required: true, + type: "integer" + }, + org: { + required: true, + type: "string" + }, + team_slug: { + required: true, + type: "string" + } + }, + url: "/orgs/:org/teams/:team_slug/discussions/:discussion_number/comments/:comment_number" + }, + updateDiscussionCommentLegacy: { + deprecated: "octokit.teams.updateDiscussionCommentLegacy() is deprecated, see https://developer.github.com/v3/teams/discussion_comments/#edit-a-comment-legacy", + method: "PATCH", + params: { + body: { + required: true, + type: "string" + }, + comment_number: { + required: true, + type: "integer" + }, + discussion_number: { + required: true, + type: "integer" + }, + team_id: { + required: true, + type: "integer" + } + }, + url: "/teams/:team_id/discussions/:discussion_number/comments/:comment_number" + }, + updateDiscussionInOrg: { + method: "PATCH", + params: { + body: { + type: "string" + }, + discussion_number: { + required: true, + type: "integer" + }, + org: { + required: true, + type: "string" + }, + team_slug: { + required: true, + type: "string" + }, + title: { + type: "string" + } + }, + url: "/orgs/:org/teams/:team_slug/discussions/:discussion_number" + }, + updateDiscussionLegacy: { + deprecated: "octokit.teams.updateDiscussionLegacy() is deprecated, see https://developer.github.com/v3/teams/discussions/#edit-a-discussion-legacy", + method: "PATCH", + params: { + body: { + type: "string" + }, + discussion_number: { + required: true, + type: "integer" + }, + team_id: { + required: true, + type: "integer" + }, + title: { + type: "string" + } + }, + url: "/teams/:team_id/discussions/:discussion_number" + }, + updateInOrg: { + method: "PATCH", + params: { + description: { + type: "string" + }, + name: { + required: true, + type: "string" + }, + org: { + required: true, + type: "string" + }, + parent_team_id: { + type: "integer" + }, + permission: { + enum: ["pull", "push", "admin"], + type: "string" + }, + privacy: { + enum: ["secret", "closed"], + type: "string" + }, + team_slug: { + required: true, + type: "string" + } + }, + url: "/orgs/:org/teams/:team_slug" + }, + updateLegacy: { + deprecated: "octokit.teams.updateLegacy() is deprecated, see https://developer.github.com/v3/teams/#edit-team-legacy", + method: "PATCH", + params: { + description: { + type: "string" + }, + name: { + required: true, + type: "string" + }, + parent_team_id: { + type: "integer" + }, + permission: { + enum: ["pull", "push", "admin"], + type: "string" + }, + privacy: { + enum: ["secret", "closed"], + type: "string" + }, + team_id: { + required: true, + type: "integer" + } + }, + url: "/teams/:team_id" + } + }, + users: { + addEmails: { + method: "POST", + params: { + emails: { + required: true, + type: "string[]" + } + }, + url: "/user/emails" + }, + block: { + method: "PUT", + params: { + username: { + required: true, + type: "string" + } + }, + url: "/user/blocks/:username" + }, + checkBlocked: { + method: "GET", + params: { + username: { + required: true, + type: "string" + } + }, + url: "/user/blocks/:username" + }, + checkFollowing: { + method: "GET", + params: { + username: { + required: true, + type: "string" + } + }, + url: "/user/following/:username" + }, + checkFollowingForUser: { + method: "GET", + params: { + target_user: { + required: true, + type: "string" + }, + username: { + required: true, + type: "string" + } + }, + url: "/users/:username/following/:target_user" + }, + createGpgKey: { + method: "POST", + params: { + armored_public_key: { + type: "string" + } + }, + url: "/user/gpg_keys" + }, + createPublicKey: { + method: "POST", + params: { + key: { + type: "string" + }, + title: { + type: "string" + } + }, + url: "/user/keys" + }, + deleteEmails: { + method: "DELETE", + params: { + emails: { + required: true, + type: "string[]" + } + }, + url: "/user/emails" + }, + deleteGpgKey: { + method: "DELETE", + params: { + gpg_key_id: { + required: true, + type: "integer" + } + }, + url: "/user/gpg_keys/:gpg_key_id" + }, + deletePublicKey: { + method: "DELETE", + params: { + key_id: { + required: true, + type: "integer" + } + }, + url: "/user/keys/:key_id" + }, + follow: { + method: "PUT", + params: { + username: { + required: true, + type: "string" + } + }, + url: "/user/following/:username" + }, + getAuthenticated: { + method: "GET", + params: {}, + url: "/user" + }, + getByUsername: { + method: "GET", + params: { + username: { + required: true, + type: "string" + } + }, + url: "/users/:username" + }, + getContextForUser: { + method: "GET", + params: { + subject_id: { + type: "string" + }, + subject_type: { + enum: ["organization", "repository", "issue", "pull_request"], + type: "string" + }, + username: { + required: true, + type: "string" + } + }, + url: "/users/:username/hovercard" + }, + getGpgKey: { + method: "GET", + params: { + gpg_key_id: { + required: true, + type: "integer" + } + }, + url: "/user/gpg_keys/:gpg_key_id" + }, + getPublicKey: { + method: "GET", + params: { + key_id: { + required: true, + type: "integer" + } + }, + url: "/user/keys/:key_id" + }, + list: { + method: "GET", + params: { + page: { + type: "integer" + }, + per_page: { + type: "integer" + }, + since: { + type: "string" + } + }, + url: "/users" + }, + listBlocked: { + method: "GET", + params: {}, + url: "/user/blocks" + }, + listEmails: { + method: "GET", + params: { + page: { + type: "integer" + }, + per_page: { + type: "integer" + } + }, + url: "/user/emails" + }, + listFollowersForAuthenticatedUser: { + method: "GET", + params: { + page: { + type: "integer" + }, + per_page: { + type: "integer" + } + }, + url: "/user/followers" + }, + listFollowersForUser: { + method: "GET", + params: { + page: { + type: "integer" + }, + per_page: { + type: "integer" + }, + username: { + required: true, + type: "string" + } + }, + url: "/users/:username/followers" + }, + listFollowingForAuthenticatedUser: { + method: "GET", + params: { + page: { + type: "integer" + }, + per_page: { + type: "integer" + } + }, + url: "/user/following" + }, + listFollowingForUser: { + method: "GET", + params: { + page: { + type: "integer" + }, + per_page: { + type: "integer" + }, + username: { + required: true, + type: "string" + } + }, + url: "/users/:username/following" + }, + listGpgKeys: { + method: "GET", + params: { + page: { + type: "integer" + }, + per_page: { + type: "integer" + } + }, + url: "/user/gpg_keys" + }, + listGpgKeysForUser: { + method: "GET", + params: { + page: { + type: "integer" + }, + per_page: { + type: "integer" + }, + username: { + required: true, + type: "string" + } + }, + url: "/users/:username/gpg_keys" + }, + listPublicEmails: { + method: "GET", + params: { + page: { + type: "integer" + }, + per_page: { + type: "integer" + } + }, + url: "/user/public_emails" + }, + listPublicKeys: { + method: "GET", + params: { + page: { + type: "integer" + }, + per_page: { + type: "integer" + } + }, + url: "/user/keys" + }, + listPublicKeysForUser: { + method: "GET", + params: { + page: { + type: "integer" + }, + per_page: { + type: "integer" + }, + username: { + required: true, + type: "string" + } + }, + url: "/users/:username/keys" + }, + togglePrimaryEmailVisibility: { + method: "PATCH", + params: { + email: { + required: true, + type: "string" + }, + visibility: { + required: true, + type: "string" + } + }, + url: "/user/email/visibility" + }, + unblock: { + method: "DELETE", + params: { + username: { + required: true, + type: "string" + } + }, + url: "/user/blocks/:username" + }, + unfollow: { + method: "DELETE", + params: { + username: { + required: true, + type: "string" + } + }, + url: "/user/following/:username" + }, + updateAuthenticated: { + method: "PATCH", + params: { + bio: { + type: "string" + }, + blog: { + type: "string" + }, + company: { + type: "string" + }, + email: { + type: "string" + }, + hireable: { + type: "boolean" + }, + location: { + type: "string" + }, + name: { + type: "string" + } + }, + url: "/user" + } + } +}; + +const VERSION = "2.4.0"; + +function registerEndpoints(octokit, routes) { + Object.keys(routes).forEach(namespaceName => { + if (!octokit[namespaceName]) { + octokit[namespaceName] = {}; + } + + Object.keys(routes[namespaceName]).forEach(apiName => { + const apiOptions = routes[namespaceName][apiName]; + const endpointDefaults = ["method", "url", "headers"].reduce((map, key) => { + if (typeof apiOptions[key] !== "undefined") { + map[key] = apiOptions[key]; + } + + return map; + }, {}); + endpointDefaults.request = { + validate: apiOptions.params + }; + let request = octokit.request.defaults(endpointDefaults); // patch request & endpoint methods to support deprecated parameters. + // Not the most elegant solution, but we don’t want to move deprecation + // logic into octokit/endpoint.js as it’s out of scope + + const hasDeprecatedParam = Object.keys(apiOptions.params || {}).find(key => apiOptions.params[key].deprecated); + + if (hasDeprecatedParam) { + const patch = patchForDeprecation.bind(null, octokit, apiOptions); + request = patch(octokit.request.defaults(endpointDefaults), `.${namespaceName}.${apiName}()`); + request.endpoint = patch(request.endpoint, `.${namespaceName}.${apiName}.endpoint()`); + request.endpoint.merge = patch(request.endpoint.merge, `.${namespaceName}.${apiName}.endpoint.merge()`); + } + + if (apiOptions.deprecated) { + octokit[namespaceName][apiName] = Object.assign(function deprecatedEndpointMethod() { + octokit.log.warn(new deprecation.Deprecation(`[@octokit/rest] ${apiOptions.deprecated}`)); + octokit[namespaceName][apiName] = request; + return request.apply(null, arguments); + }, request); + return; + } + + octokit[namespaceName][apiName] = request; + }); + }); +} + +function patchForDeprecation(octokit, apiOptions, method, methodName) { + const patchedMethod = options => { + options = Object.assign({}, options); + Object.keys(options).forEach(key => { + if (apiOptions.params[key] && apiOptions.params[key].deprecated) { + const aliasKey = apiOptions.params[key].alias; + octokit.log.warn(new deprecation.Deprecation(`[@octokit/rest] "${key}" parameter is deprecated for "${methodName}". Use "${aliasKey}" instead`)); + + if (!(aliasKey in options)) { + options[aliasKey] = options[key]; + } + + delete options[key]; + } + }); + return method(options); + }; + + Object.keys(method).forEach(key => { + patchedMethod[key] = method[key]; + }); + return patchedMethod; +} + +/** + * This plugin is a 1:1 copy of internal @octokit/rest plugins. The primary + * goal is to rebuild @octokit/rest on top of @octokit/core. Once that is + * done, we will remove the registerEndpoints methods and return the methods + * directly as with the other plugins. At that point we will also remove the + * legacy workarounds and deprecations. + * + * See the plan at + * https://github.com/octokit/plugin-rest-endpoint-methods.js/pull/1 + */ + +function restEndpointMethods(octokit) { + // @ts-ignore + octokit.registerEndpoints = registerEndpoints.bind(null, octokit); + registerEndpoints(octokit, endpointsByScope); // Aliasing scopes for backward compatibility + // See https://github.com/octokit/rest.js/pull/1134 + + [["gitdata", "git"], ["authorization", "oauthAuthorizations"], ["pullRequests", "pulls"]].forEach(([deprecatedScope, scope]) => { + Object.defineProperty(octokit, deprecatedScope, { + get() { + octokit.log.warn( // @ts-ignore + new deprecation.Deprecation(`[@octokit/plugin-rest-endpoint-methods] "octokit.${deprecatedScope}.*" methods are deprecated, use "octokit.${scope}.*" instead`)); // @ts-ignore + + return octokit[scope]; + } + + }); + }); + return {}; +} +restEndpointMethods.VERSION = VERSION; + +exports.restEndpointMethods = restEndpointMethods; +//# sourceMappingURL=index.js.map + + +/***/ }), + +/***/ 847: +/***/ (function(__unusedmodule, exports, __webpack_require__) { + +"use strict"; + +// The data structure that contains the actual analytics information. +// An analytics data structure contains one or more "sections" that +// are available for grouping. Sections contain one or more "widgets" +// that show data. For example, the `NumberWidget` shows a number, the +// `GraphWidget` shows a graph. +// +// Some of these widgets are able to be computed from dynamic data: +// for example, the `QueryNumberWidget` can execute a query against the +// items REST endpoint on GitHub. +// +// Each widget has an `evaluate` function; this will run its query, +// capture the output, and then return a static value widget with the +// data. That is, running `QueryNumberWidget.evaluate` will return a +// `NumberWidget` with the actual value set. The renderers expect static +// value widgets (the results of `evaluate`). +Object.defineProperty(exports, "__esModule", { value: true }); +const evaluate_1 = __webpack_require__(314); +async function evaluateExpression(expr, context) { + return expr != null ? await evaluate_1.Evaluate.parseExpression(expr, context) : null; +} +async function evaluateMetadata(md, context, value) { + if (md == null) { + return null; + } + const valuedContext = { + github: context.github, + value: value, + userdata: context.userdata + }; + return await evaluate_1.Evaluate.parseExpression(md, valuedContext); +} +async function evaluateQuery(type, query, limit, context) { + // fetch 100 at a time (the GitHub REST API limit) for maximum caching + const FETCH_COUNT = 100; + let queryFunction; + let resultCount = -1; + let totalCount = 2147483647; + let items = new Array(); + let page = 0; + if (type == 0 /* Issue */) { + queryFunction = context.github.search.issuesAndPullRequests; + } + else { + throw new Error(`unknown query type: ${type}`); + } + let parsedQuery = await evaluate_1.Evaluate.parseExpression(query, context); + let url = queryToUrl(parsedQuery); + // start with any data that we've cached for this query. we may need + // to fetch additional pages to supply the requested number of items + if (context.querycache != null && context.querycache[parsedQuery] != null) { + const cached = context.querycache[parsedQuery]; + totalCount = cached.totalCount; + items = cached.items; + resultCount = items.length; + page = items.length / FETCH_COUNT; + } + while (resultCount < limit && resultCount < totalCount) { + let results = await queryFunction({ + q: parsedQuery, + per_page: FETCH_COUNT, + page: ++page + }); + totalCount = results.data.total_count; + resultCount += results.data.items.length; + items.push(...results.data.items); + if (results.data.items.length == 0) { + break; + } + } + if (context.querycache != null) { + context.querycache[parsedQuery] = { + query: parsedQuery, + totalCount: totalCount, + items: items + }; + } + return { + totalCount: totalCount, + items: items.slice(0, limit), + url: url + }; +} +function queryToUrl(query) { + let repo = null; + query = query.replace(/^(.*\s+)?repo:([^\s]+)(\s+.*)?$/, (match, ...args) => { + repo = args[1]; + let replace = ''; + if (args[0] != null) { + replace += args[0]; + } + if (args[2] != null) { + replace += args[2]; + } + return replace; + }); + query = query.replace(/\s+/g, ' ').replace(/^ /, '').replace(/ $/, ''); + return repo ? + `https://github.com/${repo}/issues?q=${encodeURIComponent(query)}` : + `https://github.com/search?q=${encodeURIComponent(query)}`; +} +exports.queryToUrl = queryToUrl; +class Widget { + constructor(title, url) { + this.title = title; + this.url = url; + } +} +exports.Widget = Widget; +// A widget that has an expression that will evaluate to a numeric value +class NumberWidget extends Widget { + constructor(title, url, value, color) { + super(title, url); + this.value = value; + this.color = color; + } + async evaluate(context) { + let value; + if (typeof (this.value) == 'number') { + value = this.value; + } + else { + let result = await evaluate_1.Evaluate.parseExpression(this.value, context); + if (typeof (result) == 'number') { + value = result; + } + else { + value = +result; + } + } + const title = await evaluateMetadata(this.title, context, value); + const url = await evaluateMetadata(this.url, context, value); + const color = await evaluateMetadata(this.color, context, value); + return new NumberWidget(title, url, value, color); + } +} +exports.NumberWidget = NumberWidget; +// A widget that runs an issue query and displays the number of returned +// items as a numeric value +class QueryNumberWidget extends Widget { + constructor(title, url, type, query, color) { + super(title, url); + this.type = type; + this.query = query; + this.color = color; + } + async evaluate(context) { + let results = await evaluateQuery(this.type, this.query, 0, context); + const value = results.totalCount; + const url = this.url != null ? await evaluateMetadata(this.url, context, value) : results.url; + const title = await evaluateMetadata(this.title, context, value); + const color = await evaluateMetadata(this.color, context, value); + return new NumberWidget(title, url, value, color); + } +} +exports.QueryNumberWidget = QueryNumberWidget; +// A widget that runs a script and displays the number of returned +// items as a numeric value +class ScriptNumberWidget extends Widget { + constructor(title, url, script, color) { + super(title, url); + this.script = script; + this.color = color; + } + async evaluate(context) { + let result = await evaluate_1.Evaluate.runScript(this.script, context); + let value; + let title = null; + let url = null; + let color = null; + if (typeof result == 'object' && result.value) { + title = result.title; + url = result.url; + color = result.color; + result = result.value; + } + if (typeof result != 'number') { + result = result.toString(); + if (result.match(/^\d+$/)) { + result = +result; + } + else { + result = Number.NaN; + } + } + value = result; + if (title == null) { + title = await evaluateMetadata(this.title, context, value); + } + if (url == null) { + url = await evaluateMetadata(this.url, context, value); + } + if (color == null) { + color = await evaluateMetadata(this.color, context, value); + } + return new NumberWidget(title, url, result, color); + } +} +exports.ScriptNumberWidget = ScriptNumberWidget; +// A widget that has an expression that will evaluate to a string value +class StringWidget extends Widget { + constructor(title, url, value, align, color) { + super(title, url); + this.value = value; + this.align = align; + this.color = color; + } + async evaluate(context) { + let value = await evaluate_1.Evaluate.parseExpression(this.value, context); + const title = await evaluateMetadata(this.title, context, value); + const url = await evaluateMetadata(this.url, context, value); + const align = await evaluateMetadata(this.align, context, value); + const color = await evaluateMetadata(this.color, context, value); + return new StringWidget(title, url, value, align, color); + } +} +exports.StringWidget = StringWidget; +// A widget that runs a script and displays the string returned +class ScriptStringWidget extends Widget { + constructor(title, url, script, align, color) { + super(title, url); + this.script = script; + this.align = align; + this.color = color; + } + async evaluate(context) { + let result = await evaluate_1.Evaluate.runScript(this.script, context); + let value; + let title = null; + let url = null; + let align = null; + let color = null; + if (typeof result == 'object' && result.value) { + title = result.title; + url = result.url; + color = result.color; + result = result.value; + } + if (typeof result != 'string') { + result = result.toString(); + } + value = result; + if (title == null) { + title = await evaluateMetadata(this.title, context, value); + } + if (url == null) { + url = await evaluateMetadata(this.url, context, value); + } + if (align == null) { + align = await evaluateMetadata(this.align, context, value); + } + if (color == null) { + color = await evaluateMetadata(this.color, context, value); + } + return new StringWidget(title, url, result, align, color); + } +} +exports.ScriptStringWidget = ScriptStringWidget; +// A widget that displays multiple numeric values against each other, +// usually in a bar graph. This actually is composed of other widgets; +// namely `NumberWidget`s (or things that derive from it, like a +// `QueryNumberWidget`s) to store the data. +class GraphWidget extends Widget { + constructor(title, url, elements) { + super(title, url); + this.elements = elements ? elements : new Array(); + } + async evaluate(context) { + let elements = new Array(); + for (let element of this.elements) { + let result = await element.evaluate(context); + if (!(result instanceof NumberWidget)) { + throw new Error('graph widget elements must be number widgets'); + } + elements.push(result); + } + const title = await evaluateExpression(this.title, context); + const url = await evaluateExpression(this.url, context); + return new GraphWidget(title, url, elements); + } +} +exports.GraphWidget = GraphWidget; +class TableWidget extends Widget { + constructor(title, url, headers, elements) { + super(title, url); + this.headers = headers; + this.elements = elements; + } + async evaluate(context) { + let headers = new Array(); + let elements = new Array(); + for (let header of this.headers) { + let result = await header.evaluate(context); + if (!(result instanceof NumberWidget) && !(result instanceof StringWidget)) { + throw new Error('table widget elements must be string or number widgets'); + } + headers.push(result); + } + for (let row of this.elements) { + let cells = new Array(); + for (let cell of row) { + let result = await cell.evaluate(context); + if (!(result instanceof NumberWidget) && !(result instanceof StringWidget)) { + throw new Error('table widget elements must be string or number widgets'); + } + cells.push(result); + } + elements.push(cells); + } + const title = await evaluateExpression(this.title, context); + const url = await evaluateExpression(this.url, context); + return new TableWidget(title, url, headers, elements); + } +} +exports.TableWidget = TableWidget; +class QueryTableWidget extends Widget { + constructor(title, url, type, query, limit, fields) { + super(title, url); + this.type = type; + this.query = query; + this.limit = limit != null ? limit : QueryTableWidget.DEFAULT_LIMIT; + this.fields = fields != null ? fields : QueryTableWidget.DEFAULT_FIELDS[type]; + } + getHeaders() { + const headers = new Array(); + for (let field of this.fields) { + if (field.title != null) { + headers.push(field.title); + } + else if (field.value != null) { + headers.push(field.value); + } + else { + headers.push(field.toString()); + } + } + return headers; + } + static async evaluateItemValue(value, context, item) { + const valuedContext = { + github: context.github, + item: item, + userdata: context.userdata + }; + return await evaluate_1.Evaluate.parseExpression(value, valuedContext); + } + async getRow(item, context) { + const values = new Array(); + for (let field of this.fields) { + if (field.value != null) { + values.push(await QueryTableWidget.evaluateItemValue(field.value, context, item)); + } + else { + let property = (field.property != null) ? field.property : field.toString(); + values.push(item[property]); + } + } + return values; + } + async evaluate(context) { + let headers = new Array(); + let elements = new Array(); + let results = await evaluateQuery(this.type, this.query, this.limit, context); + for (let header of this.getHeaders()) { + headers.push(new StringWidget(null, null, header, null, null)); + } + let item; + for (item of results.items) { + let row = new Array(); + for (let value of await this.getRow(item, context)) { + row.push(new StringWidget(null, item.html_url, value, null, null)); + } + elements.push(row); + } + const title = await evaluateExpression(this.title, context); + const url = this.url != null ? await evaluateExpression(this.url, context) : results.url; + return new TableWidget(title, url, headers, elements); + } +} +exports.QueryTableWidget = QueryTableWidget; +QueryTableWidget.DEFAULT_FIELDS = { + [0 /* Issue */]: [ + { title: 'Issue', property: 'number' }, + { title: 'Title', property: 'title' } + ] +}; +QueryTableWidget.DEFAULT_LIMIT = 10; +// A `Section` contains one or more widgets +class Section { + constructor(title, description, widgets) { + this.title = title; + this.description = description; + this.widgets = widgets; + } + async evaluate(context) { + const evaluated = new Array(); + for (let widget of this.widgets) { + evaluated.push(await widget.evaluate(context)); + } + const title = this.title ? await evaluate_1.Evaluate.parseExpression(this.title, context) : null; + const description = this.description ? await evaluate_1.Evaluate.parseExpression(this.description, context) : null; + return new Section(title, description, evaluated); + } +} +exports.Section = Section; +class Analytics { + constructor(title, description, sections, setup, shutdown) { + this.title = title; + this.description = description; + this.sections = sections; + this.setup = setup; + this.shutdown = shutdown; + } + static async evaluate(config, github) { + const context = { 'github': github, 'querycache': {}, 'userdata': {} }; + const evaluated = new Array(); + if (config.setup != null) { + await evaluate_1.Evaluate.runScript(config.setup, context); + } + for (let section of config.sections) { + evaluated.push(await section.evaluate(context)); + } + const title = await evaluateExpression(config.title, context); + const description = await evaluateExpression(config.description, context); + if (config.shutdown != null) { + await evaluate_1.Evaluate.runScript(config.shutdown, context); + } + return new Analytics(title, description, evaluated, null, null); + } +} +exports.Analytics = Analytics; + + +/***/ }), + +/***/ 850: +/***/ (function(module, __unusedexports, __webpack_require__) { + +module.exports = paginationMethodsPlugin + +function paginationMethodsPlugin (octokit) { + octokit.getFirstPage = __webpack_require__(777).bind(null, octokit) + octokit.getLastPage = __webpack_require__(649).bind(null, octokit) + octokit.getNextPage = __webpack_require__(550).bind(null, octokit) + octokit.getPreviousPage = __webpack_require__(563).bind(null, octokit) + octokit.hasFirstPage = __webpack_require__(536) + octokit.hasLastPage = __webpack_require__(336) + octokit.hasNextPage = __webpack_require__(929) + octokit.hasPreviousPage = __webpack_require__(558) +} + + +/***/ }), + +/***/ 854: +/***/ (function(module) { + +/** + * lodash (Custom Build) + * Build: `lodash modularize exports="npm" -o ./` + * Copyright jQuery Foundation and other contributors + * Released under MIT license + * Based on Underscore.js 1.8.3 + * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors + */ + +/** Used as the `TypeError` message for "Functions" methods. */ +var FUNC_ERROR_TEXT = 'Expected a function'; + +/** Used to stand-in for `undefined` hash values. */ +var HASH_UNDEFINED = '__lodash_hash_undefined__'; + +/** Used as references for various `Number` constants. */ +var INFINITY = 1 / 0; + +/** `Object#toString` result references. */ +var funcTag = '[object Function]', + genTag = '[object GeneratorFunction]', + symbolTag = '[object Symbol]'; + +/** Used to match property names within property paths. */ +var reIsDeepProp = /\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/, + reIsPlainProp = /^\w*$/, + reLeadingDot = /^\./, + rePropName = /[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|$))/g; + +/** + * Used to match `RegExp` + * [syntax characters](http://ecma-international.org/ecma-262/7.0/#sec-patterns). + */ +var reRegExpChar = /[\\^$.*+?()[\]{}|]/g; + +/** Used to match backslashes in property paths. */ +var reEscapeChar = /\\(\\)?/g; + +/** Used to detect host constructors (Safari). */ +var reIsHostCtor = /^\[object .+?Constructor\]$/; + +/** Detect free variable `global` from Node.js. */ +var freeGlobal = typeof global == 'object' && global && global.Object === Object && global; + +/** Detect free variable `self`. */ +var freeSelf = typeof self == 'object' && self && self.Object === Object && self; + +/** Used as a reference to the global object. */ +var root = freeGlobal || freeSelf || Function('return this')(); + +/** + * Gets the value at `key` of `object`. + * + * @private + * @param {Object} [object] The object to query. + * @param {string} key The key of the property to get. + * @returns {*} Returns the property value. + */ +function getValue(object, key) { + return object == null ? undefined : object[key]; +} + +/** + * Checks if `value` is a host object in IE < 9. + * + * @private + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a host object, else `false`. + */ +function isHostObject(value) { + // Many host objects are `Object` objects that can coerce to strings + // despite having improperly defined `toString` methods. + var result = false; + if (value != null && typeof value.toString != 'function') { + try { + result = !!(value + ''); + } catch (e) {} + } + return result; +} + +/** Used for built-in method references. */ +var arrayProto = Array.prototype, + funcProto = Function.prototype, + objectProto = Object.prototype; + +/** Used to detect overreaching core-js shims. */ +var coreJsData = root['__core-js_shared__']; + +/** Used to detect methods masquerading as native. */ +var maskSrcKey = (function() { + var uid = /[^.]+$/.exec(coreJsData && coreJsData.keys && coreJsData.keys.IE_PROTO || ''); + return uid ? ('Symbol(src)_1.' + uid) : ''; +}()); + +/** Used to resolve the decompiled source of functions. */ +var funcToString = funcProto.toString; + +/** Used to check objects for own properties. */ +var hasOwnProperty = objectProto.hasOwnProperty; + +/** + * Used to resolve the + * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring) + * of values. + */ +var objectToString = objectProto.toString; + +/** Used to detect if a method is native. */ +var reIsNative = RegExp('^' + + funcToString.call(hasOwnProperty).replace(reRegExpChar, '\\$&') + .replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, '$1.*?') + '$' +); + +/** Built-in value references. */ +var Symbol = root.Symbol, + splice = arrayProto.splice; + +/* Built-in method references that are verified to be native. */ +var Map = getNative(root, 'Map'), + nativeCreate = getNative(Object, 'create'); + +/** Used to convert symbols to primitives and strings. */ +var symbolProto = Symbol ? Symbol.prototype : undefined, + symbolToString = symbolProto ? symbolProto.toString : undefined; + +/** + * Creates a hash object. + * + * @private + * @constructor + * @param {Array} [entries] The key-value pairs to cache. + */ +function Hash(entries) { + var index = -1, + length = entries ? entries.length : 0; + + this.clear(); + while (++index < length) { + var entry = entries[index]; + this.set(entry[0], entry[1]); + } +} + +/** + * Removes all key-value entries from the hash. + * + * @private + * @name clear + * @memberOf Hash + */ +function hashClear() { + this.__data__ = nativeCreate ? nativeCreate(null) : {}; +} + +/** + * Removes `key` and its value from the hash. + * + * @private + * @name delete + * @memberOf Hash + * @param {Object} hash The hash to modify. + * @param {string} key The key of the value to remove. + * @returns {boolean} Returns `true` if the entry was removed, else `false`. + */ +function hashDelete(key) { + return this.has(key) && delete this.__data__[key]; +} + +/** + * Gets the hash value for `key`. + * + * @private + * @name get + * @memberOf Hash + * @param {string} key The key of the value to get. + * @returns {*} Returns the entry value. + */ +function hashGet(key) { + var data = this.__data__; + if (nativeCreate) { + var result = data[key]; + return result === HASH_UNDEFINED ? undefined : result; + } + return hasOwnProperty.call(data, key) ? data[key] : undefined; +} + +/** + * Checks if a hash value for `key` exists. + * + * @private + * @name has + * @memberOf Hash + * @param {string} key The key of the entry to check. + * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`. + */ +function hashHas(key) { + var data = this.__data__; + return nativeCreate ? data[key] !== undefined : hasOwnProperty.call(data, key); +} + +/** + * Sets the hash `key` to `value`. + * + * @private + * @name set + * @memberOf Hash + * @param {string} key The key of the value to set. + * @param {*} value The value to set. + * @returns {Object} Returns the hash instance. + */ +function hashSet(key, value) { + var data = this.__data__; + data[key] = (nativeCreate && value === undefined) ? HASH_UNDEFINED : value; + return this; +} + +// Add methods to `Hash`. +Hash.prototype.clear = hashClear; +Hash.prototype['delete'] = hashDelete; +Hash.prototype.get = hashGet; +Hash.prototype.has = hashHas; +Hash.prototype.set = hashSet; + +/** + * Creates an list cache object. + * + * @private + * @constructor + * @param {Array} [entries] The key-value pairs to cache. + */ +function ListCache(entries) { + var index = -1, + length = entries ? entries.length : 0; + + this.clear(); + while (++index < length) { + var entry = entries[index]; + this.set(entry[0], entry[1]); + } +} + +/** + * Removes all key-value entries from the list cache. + * + * @private + * @name clear + * @memberOf ListCache + */ +function listCacheClear() { + this.__data__ = []; +} + +/** + * Removes `key` and its value from the list cache. + * + * @private + * @name delete + * @memberOf ListCache + * @param {string} key The key of the value to remove. + * @returns {boolean} Returns `true` if the entry was removed, else `false`. + */ +function listCacheDelete(key) { + var data = this.__data__, + index = assocIndexOf(data, key); + + if (index < 0) { + return false; + } + var lastIndex = data.length - 1; + if (index == lastIndex) { + data.pop(); + } else { + splice.call(data, index, 1); + } + return true; +} + +/** + * Gets the list cache value for `key`. + * + * @private + * @name get + * @memberOf ListCache + * @param {string} key The key of the value to get. + * @returns {*} Returns the entry value. + */ +function listCacheGet(key) { + var data = this.__data__, + index = assocIndexOf(data, key); + + return index < 0 ? undefined : data[index][1]; +} + +/** + * Checks if a list cache value for `key` exists. + * + * @private + * @name has + * @memberOf ListCache + * @param {string} key The key of the entry to check. + * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`. + */ +function listCacheHas(key) { + return assocIndexOf(this.__data__, key) > -1; +} + +/** + * Sets the list cache `key` to `value`. + * + * @private + * @name set + * @memberOf ListCache + * @param {string} key The key of the value to set. + * @param {*} value The value to set. + * @returns {Object} Returns the list cache instance. + */ +function listCacheSet(key, value) { + var data = this.__data__, + index = assocIndexOf(data, key); + + if (index < 0) { + data.push([key, value]); + } else { + data[index][1] = value; + } + return this; +} + +// Add methods to `ListCache`. +ListCache.prototype.clear = listCacheClear; +ListCache.prototype['delete'] = listCacheDelete; +ListCache.prototype.get = listCacheGet; +ListCache.prototype.has = listCacheHas; +ListCache.prototype.set = listCacheSet; + +/** + * Creates a map cache object to store key-value pairs. + * + * @private + * @constructor + * @param {Array} [entries] The key-value pairs to cache. + */ +function MapCache(entries) { + var index = -1, + length = entries ? entries.length : 0; + + this.clear(); + while (++index < length) { + var entry = entries[index]; + this.set(entry[0], entry[1]); + } +} + +/** + * Removes all key-value entries from the map. + * + * @private + * @name clear + * @memberOf MapCache + */ +function mapCacheClear() { + this.__data__ = { + 'hash': new Hash, + 'map': new (Map || ListCache), + 'string': new Hash + }; +} + +/** + * Removes `key` and its value from the map. + * + * @private + * @name delete + * @memberOf MapCache + * @param {string} key The key of the value to remove. + * @returns {boolean} Returns `true` if the entry was removed, else `false`. + */ +function mapCacheDelete(key) { + return getMapData(this, key)['delete'](key); +} + +/** + * Gets the map value for `key`. + * + * @private + * @name get + * @memberOf MapCache + * @param {string} key The key of the value to get. + * @returns {*} Returns the entry value. + */ +function mapCacheGet(key) { + return getMapData(this, key).get(key); +} + +/** + * Checks if a map value for `key` exists. + * + * @private + * @name has + * @memberOf MapCache + * @param {string} key The key of the entry to check. + * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`. + */ +function mapCacheHas(key) { + return getMapData(this, key).has(key); +} + +/** + * Sets the map `key` to `value`. + * + * @private + * @name set + * @memberOf MapCache + * @param {string} key The key of the value to set. + * @param {*} value The value to set. + * @returns {Object} Returns the map cache instance. + */ +function mapCacheSet(key, value) { + getMapData(this, key).set(key, value); + return this; +} + +// Add methods to `MapCache`. +MapCache.prototype.clear = mapCacheClear; +MapCache.prototype['delete'] = mapCacheDelete; +MapCache.prototype.get = mapCacheGet; +MapCache.prototype.has = mapCacheHas; +MapCache.prototype.set = mapCacheSet; + +/** + * Gets the index at which the `key` is found in `array` of key-value pairs. + * + * @private + * @param {Array} array The array to inspect. + * @param {*} key The key to search for. + * @returns {number} Returns the index of the matched value, else `-1`. + */ +function assocIndexOf(array, key) { + var length = array.length; + while (length--) { + if (eq(array[length][0], key)) { + return length; + } + } + return -1; +} + +/** + * The base implementation of `_.get` without support for default values. + * + * @private + * @param {Object} object The object to query. + * @param {Array|string} path The path of the property to get. + * @returns {*} Returns the resolved value. + */ +function baseGet(object, path) { + path = isKey(path, object) ? [path] : castPath(path); + + var index = 0, + length = path.length; + + while (object != null && index < length) { + object = object[toKey(path[index++])]; + } + return (index && index == length) ? object : undefined; +} + +/** + * The base implementation of `_.isNative` without bad shim checks. + * + * @private + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a native function, + * else `false`. + */ +function baseIsNative(value) { + if (!isObject(value) || isMasked(value)) { + return false; + } + var pattern = (isFunction(value) || isHostObject(value)) ? reIsNative : reIsHostCtor; + return pattern.test(toSource(value)); +} + +/** + * The base implementation of `_.toString` which doesn't convert nullish + * values to empty strings. + * + * @private + * @param {*} value The value to process. + * @returns {string} Returns the string. + */ +function baseToString(value) { + // Exit early for strings to avoid a performance hit in some environments. + if (typeof value == 'string') { + return value; + } + if (isSymbol(value)) { + return symbolToString ? symbolToString.call(value) : ''; + } + var result = (value + ''); + return (result == '0' && (1 / value) == -INFINITY) ? '-0' : result; +} + +/** + * Casts `value` to a path array if it's not one. + * + * @private + * @param {*} value The value to inspect. + * @returns {Array} Returns the cast property path array. + */ +function castPath(value) { + return isArray(value) ? value : stringToPath(value); +} + +/** + * Gets the data for `map`. + * + * @private + * @param {Object} map The map to query. + * @param {string} key The reference key. + * @returns {*} Returns the map data. + */ +function getMapData(map, key) { + var data = map.__data__; + return isKeyable(key) + ? data[typeof key == 'string' ? 'string' : 'hash'] + : data.map; +} + +/** + * Gets the native function at `key` of `object`. + * + * @private + * @param {Object} object The object to query. + * @param {string} key The key of the method to get. + * @returns {*} Returns the function if it's native, else `undefined`. + */ +function getNative(object, key) { + var value = getValue(object, key); + return baseIsNative(value) ? value : undefined; +} + +/** + * Checks if `value` is a property name and not a property path. + * + * @private + * @param {*} value The value to check. + * @param {Object} [object] The object to query keys on. + * @returns {boolean} Returns `true` if `value` is a property name, else `false`. + */ +function isKey(value, object) { + if (isArray(value)) { + return false; + } + var type = typeof value; + if (type == 'number' || type == 'symbol' || type == 'boolean' || + value == null || isSymbol(value)) { + return true; + } + return reIsPlainProp.test(value) || !reIsDeepProp.test(value) || + (object != null && value in Object(object)); +} + +/** + * Checks if `value` is suitable for use as unique object key. + * + * @private + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is suitable, else `false`. + */ +function isKeyable(value) { + var type = typeof value; + return (type == 'string' || type == 'number' || type == 'symbol' || type == 'boolean') + ? (value !== '__proto__') + : (value === null); +} + +/** + * Checks if `func` has its source masked. + * + * @private + * @param {Function} func The function to check. + * @returns {boolean} Returns `true` if `func` is masked, else `false`. + */ +function isMasked(func) { + return !!maskSrcKey && (maskSrcKey in func); +} + +/** + * Converts `string` to a property path array. + * + * @private + * @param {string} string The string to convert. + * @returns {Array} Returns the property path array. + */ +var stringToPath = memoize(function(string) { + string = toString(string); + + var result = []; + if (reLeadingDot.test(string)) { + result.push(''); + } + string.replace(rePropName, function(match, number, quote, string) { + result.push(quote ? string.replace(reEscapeChar, '$1') : (number || match)); + }); + return result; +}); + +/** + * Converts `value` to a string key if it's not a string or symbol. + * + * @private + * @param {*} value The value to inspect. + * @returns {string|symbol} Returns the key. + */ +function toKey(value) { + if (typeof value == 'string' || isSymbol(value)) { + return value; + } + var result = (value + ''); + return (result == '0' && (1 / value) == -INFINITY) ? '-0' : result; +} + +/** + * Converts `func` to its source code. + * + * @private + * @param {Function} func The function to process. + * @returns {string} Returns the source code. + */ +function toSource(func) { + if (func != null) { + try { + return funcToString.call(func); + } catch (e) {} + try { + return (func + ''); + } catch (e) {} + } + return ''; +} + +/** + * Creates a function that memoizes the result of `func`. If `resolver` is + * provided, it determines the cache key for storing the result based on the + * arguments provided to the memoized function. By default, the first argument + * provided to the memoized function is used as the map cache key. The `func` + * is invoked with the `this` binding of the memoized function. + * + * **Note:** The cache is exposed as the `cache` property on the memoized + * function. Its creation may be customized by replacing the `_.memoize.Cache` + * constructor with one whose instances implement the + * [`Map`](http://ecma-international.org/ecma-262/7.0/#sec-properties-of-the-map-prototype-object) + * method interface of `delete`, `get`, `has`, and `set`. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Function + * @param {Function} func The function to have its output memoized. + * @param {Function} [resolver] The function to resolve the cache key. + * @returns {Function} Returns the new memoized function. + * @example + * + * var object = { 'a': 1, 'b': 2 }; + * var other = { 'c': 3, 'd': 4 }; + * + * var values = _.memoize(_.values); + * values(object); + * // => [1, 2] + * + * values(other); + * // => [3, 4] + * + * object.a = 2; + * values(object); + * // => [1, 2] + * + * // Modify the result cache. + * values.cache.set(object, ['a', 'b']); + * values(object); + * // => ['a', 'b'] + * + * // Replace `_.memoize.Cache`. + * _.memoize.Cache = WeakMap; + */ +function memoize(func, resolver) { + if (typeof func != 'function' || (resolver && typeof resolver != 'function')) { + throw new TypeError(FUNC_ERROR_TEXT); + } + var memoized = function() { + var args = arguments, + key = resolver ? resolver.apply(this, args) : args[0], + cache = memoized.cache; + + if (cache.has(key)) { + return cache.get(key); + } + var result = func.apply(this, args); + memoized.cache = cache.set(key, result); + return result; + }; + memoized.cache = new (memoize.Cache || MapCache); + return memoized; +} + +// Assign cache to `_.memoize`. +memoize.Cache = MapCache; + +/** + * Performs a + * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero) + * comparison between two values to determine if they are equivalent. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Lang + * @param {*} value The value to compare. + * @param {*} other The other value to compare. + * @returns {boolean} Returns `true` if the values are equivalent, else `false`. + * @example + * + * var object = { 'a': 1 }; + * var other = { 'a': 1 }; + * + * _.eq(object, object); + * // => true + * + * _.eq(object, other); + * // => false + * + * _.eq('a', 'a'); + * // => true + * + * _.eq('a', Object('a')); + * // => false + * + * _.eq(NaN, NaN); + * // => true + */ +function eq(value, other) { + return value === other || (value !== value && other !== other); +} + +/** + * Checks if `value` is classified as an `Array` object. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is an array, else `false`. + * @example + * + * _.isArray([1, 2, 3]); + * // => true + * + * _.isArray(document.body.children); + * // => false + * + * _.isArray('abc'); + * // => false + * + * _.isArray(_.noop); + * // => false + */ +var isArray = Array.isArray; + +/** + * Checks if `value` is classified as a `Function` object. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a function, else `false`. + * @example + * + * _.isFunction(_); + * // => true + * + * _.isFunction(/abc/); + * // => false + */ +function isFunction(value) { + // The use of `Object#toString` avoids issues with the `typeof` operator + // in Safari 8-9 which returns 'object' for typed array and other constructors. + var tag = isObject(value) ? objectToString.call(value) : ''; + return tag == funcTag || tag == genTag; +} + +/** + * Checks if `value` is the + * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types) + * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`) + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is an object, else `false`. + * @example + * + * _.isObject({}); + * // => true + * + * _.isObject([1, 2, 3]); + * // => true + * + * _.isObject(_.noop); + * // => true + * + * _.isObject(null); + * // => false + */ +function isObject(value) { + var type = typeof value; + return !!value && (type == 'object' || type == 'function'); +} + +/** + * Checks if `value` is object-like. A value is object-like if it's not `null` + * and has a `typeof` result of "object". + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is object-like, else `false`. + * @example + * + * _.isObjectLike({}); + * // => true + * + * _.isObjectLike([1, 2, 3]); + * // => true + * + * _.isObjectLike(_.noop); + * // => false + * + * _.isObjectLike(null); + * // => false + */ +function isObjectLike(value) { + return !!value && typeof value == 'object'; +} + +/** + * Checks if `value` is classified as a `Symbol` primitive or object. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a symbol, else `false`. + * @example + * + * _.isSymbol(Symbol.iterator); + * // => true + * + * _.isSymbol('abc'); + * // => false + */ +function isSymbol(value) { + return typeof value == 'symbol' || + (isObjectLike(value) && objectToString.call(value) == symbolTag); +} + +/** + * Converts `value` to a string. An empty string is returned for `null` + * and `undefined` values. The sign of `-0` is preserved. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Lang + * @param {*} value The value to process. + * @returns {string} Returns the string. + * @example + * + * _.toString(null); + * // => '' + * + * _.toString(-0); + * // => '-0' + * + * _.toString([1, 2, 3]); + * // => '1,2,3' + */ +function toString(value) { + return value == null ? '' : baseToString(value); +} + +/** + * Gets the value at `path` of `object`. If the resolved value is + * `undefined`, the `defaultValue` is returned in its place. + * + * @static + * @memberOf _ + * @since 3.7.0 + * @category Object + * @param {Object} object The object to query. + * @param {Array|string} path The path of the property to get. + * @param {*} [defaultValue] The value returned for `undefined` resolved values. + * @returns {*} Returns the resolved value. + * @example + * + * var object = { 'a': [{ 'b': { 'c': 3 } }] }; + * + * _.get(object, 'a[0].b.c'); + * // => 3 + * + * _.get(object, ['a', '0', 'b', 'c']); + * // => 3 + * + * _.get(object, 'a.b.c', 'default'); + * // => 'default' + */ +function get(object, path, defaultValue) { + var result = object == null ? undefined : baseGet(object, path); + return result === undefined ? defaultValue : result; +} + +module.exports = get; + + +/***/ }), + +/***/ 855: +/***/ (function(module, __unusedexports, __webpack_require__) { + +module.exports = registerPlugin; + +const factory = __webpack_require__(47); + +function registerPlugin(plugins, pluginFunction) { + return factory( + plugins.includes(pluginFunction) ? plugins : plugins.concat(pluginFunction) + ); +} + + +/***/ }), + +/***/ 856: +/***/ (function(module, __unusedexports, __webpack_require__) { + +module.exports = __webpack_require__(141); + + +/***/ }), + +/***/ 863: +/***/ (function(module, __unusedexports, __webpack_require__) { + +module.exports = authenticationBeforeRequest; + +const btoa = __webpack_require__(675); + +const withAuthorizationPrefix = __webpack_require__(143); + +function authenticationBeforeRequest(state, options) { + if (typeof state.auth === "string") { + options.headers.authorization = withAuthorizationPrefix(state.auth); + return; + } + + if (state.auth.username) { + const hash = btoa(`${state.auth.username}:${state.auth.password}`); + options.headers.authorization = `Basic ${hash}`; + if (state.otp) { + options.headers["x-github-otp"] = state.otp; + } + return; + } + + if (state.auth.clientId) { + // There is a special case for OAuth applications, when `clientId` and `clientSecret` is passed as + // Basic Authorization instead of query parameters. The only routes where that applies share the same + // URL though: `/applications/:client_id/tokens/:access_token`. + // + // 1. [Check an authorization](https://developer.github.com/v3/oauth_authorizations/#check-an-authorization) + // 2. [Reset an authorization](https://developer.github.com/v3/oauth_authorizations/#reset-an-authorization) + // 3. [Revoke an authorization for an application](https://developer.github.com/v3/oauth_authorizations/#revoke-an-authorization-for-an-application) + // + // We identify by checking the URL. It must merge both "/applications/:client_id/tokens/:access_token" + // as well as "/applications/123/tokens/token456" + if (/\/applications\/:?[\w_]+\/tokens\/:?[\w_]+($|\?)/.test(options.url)) { + const hash = btoa(`${state.auth.clientId}:${state.auth.clientSecret}`); + options.headers.authorization = `Basic ${hash}`; + return; + } + + options.url += options.url.indexOf("?") === -1 ? "?" : "&"; + options.url += `client_id=${state.auth.clientId}&client_secret=${state.auth.clientSecret}`; + return; + } + + return Promise.resolve() + + .then(() => { + return state.auth(); + }) + + .then(authorization => { + options.headers.authorization = withAuthorizationPrefix(authorization); + }); +} + + +/***/ }), + +/***/ 866: +/***/ (function(module, __unusedexports, __webpack_require__) { + +"use strict"; + +var shebangRegex = __webpack_require__(816); + +module.exports = function (str) { + var match = str.match(shebangRegex); + + if (!match) { + return null; + } + + var arr = match[0].replace(/#! ?/, '').split(' '); + var bin = arr[0].split('/').pop(); + var arg = arr[1]; + + return (bin === 'env' ? + arg : + bin + (arg ? ' ' + arg : '') + ); +}; + + +/***/ }), + +/***/ 881: +/***/ (function(module) { + +"use strict"; + + +const isWin = process.platform === 'win32'; + +function notFoundError(original, syscall) { + return Object.assign(new Error(`${syscall} ${original.command} ENOENT`), { + code: 'ENOENT', + errno: 'ENOENT', + syscall: `${syscall} ${original.command}`, + path: original.command, + spawnargs: original.args, + }); +} + +function hookChildProcess(cp, parsed) { + if (!isWin) { + return; + } + + const originalEmit = cp.emit; + + cp.emit = function (name, arg1) { + // If emitting "exit" event and exit code is 1, we need to check if + // the command exists and emit an "error" instead + // See https://github.com/IndigoUnited/node-cross-spawn/issues/16 + if (name === 'exit') { + const err = verifyENOENT(arg1, parsed, 'spawn'); + + if (err) { + return originalEmit.call(cp, 'error', err); + } + } + + return originalEmit.apply(cp, arguments); // eslint-disable-line prefer-rest-params + }; +} + +function verifyENOENT(status, parsed) { + if (isWin && status === 1 && !parsed.file) { + return notFoundError(parsed.original, 'spawn'); + } + + return null; +} + +function verifyENOENTSync(status, parsed) { + if (isWin && status === 1 && !parsed.file) { + return notFoundError(parsed.original, 'spawnSync'); + } + + return null; +} + +module.exports = { + hookChildProcess, + verifyENOENT, + verifyENOENTSync, + notFoundError, +}; + + +/***/ }), + +/***/ 883: +/***/ (function(module) { + +/** + * lodash (Custom Build) + * Build: `lodash modularize exports="npm" -o ./` + * Copyright jQuery Foundation and other contributors + * Released under MIT license + * Based on Underscore.js 1.8.3 + * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors + */ + +/** Used as the `TypeError` message for "Functions" methods. */ +var FUNC_ERROR_TEXT = 'Expected a function'; + +/** Used to stand-in for `undefined` hash values. */ +var HASH_UNDEFINED = '__lodash_hash_undefined__'; + +/** Used as references for various `Number` constants. */ +var INFINITY = 1 / 0, + MAX_SAFE_INTEGER = 9007199254740991; + +/** `Object#toString` result references. */ +var funcTag = '[object Function]', + genTag = '[object GeneratorFunction]', + symbolTag = '[object Symbol]'; + +/** Used to match property names within property paths. */ +var reIsDeepProp = /\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/, + reIsPlainProp = /^\w*$/, + reLeadingDot = /^\./, + rePropName = /[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|$))/g; + +/** + * Used to match `RegExp` + * [syntax characters](http://ecma-international.org/ecma-262/7.0/#sec-patterns). + */ +var reRegExpChar = /[\\^$.*+?()[\]{}|]/g; + +/** Used to match backslashes in property paths. */ +var reEscapeChar = /\\(\\)?/g; + +/** Used to detect host constructors (Safari). */ +var reIsHostCtor = /^\[object .+?Constructor\]$/; + +/** Used to detect unsigned integer values. */ +var reIsUint = /^(?:0|[1-9]\d*)$/; + +/** Detect free variable `global` from Node.js. */ +var freeGlobal = typeof global == 'object' && global && global.Object === Object && global; + +/** Detect free variable `self`. */ +var freeSelf = typeof self == 'object' && self && self.Object === Object && self; + +/** Used as a reference to the global object. */ +var root = freeGlobal || freeSelf || Function('return this')(); + +/** + * Gets the value at `key` of `object`. + * + * @private + * @param {Object} [object] The object to query. + * @param {string} key The key of the property to get. + * @returns {*} Returns the property value. + */ +function getValue(object, key) { + return object == null ? undefined : object[key]; +} + +/** + * Checks if `value` is a host object in IE < 9. + * + * @private + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a host object, else `false`. + */ +function isHostObject(value) { + // Many host objects are `Object` objects that can coerce to strings + // despite having improperly defined `toString` methods. + var result = false; + if (value != null && typeof value.toString != 'function') { + try { + result = !!(value + ''); + } catch (e) {} + } + return result; +} + +/** Used for built-in method references. */ +var arrayProto = Array.prototype, + funcProto = Function.prototype, + objectProto = Object.prototype; + +/** Used to detect overreaching core-js shims. */ +var coreJsData = root['__core-js_shared__']; + +/** Used to detect methods masquerading as native. */ +var maskSrcKey = (function() { + var uid = /[^.]+$/.exec(coreJsData && coreJsData.keys && coreJsData.keys.IE_PROTO || ''); + return uid ? ('Symbol(src)_1.' + uid) : ''; +}()); + +/** Used to resolve the decompiled source of functions. */ +var funcToString = funcProto.toString; + +/** Used to check objects for own properties. */ +var hasOwnProperty = objectProto.hasOwnProperty; + +/** + * Used to resolve the + * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring) + * of values. + */ +var objectToString = objectProto.toString; + +/** Used to detect if a method is native. */ +var reIsNative = RegExp('^' + + funcToString.call(hasOwnProperty).replace(reRegExpChar, '\\$&') + .replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, '$1.*?') + '$' +); + +/** Built-in value references. */ +var Symbol = root.Symbol, + splice = arrayProto.splice; + +/* Built-in method references that are verified to be native. */ +var Map = getNative(root, 'Map'), + nativeCreate = getNative(Object, 'create'); + +/** Used to convert symbols to primitives and strings. */ +var symbolProto = Symbol ? Symbol.prototype : undefined, + symbolToString = symbolProto ? symbolProto.toString : undefined; + +/** + * Creates a hash object. + * + * @private + * @constructor + * @param {Array} [entries] The key-value pairs to cache. + */ +function Hash(entries) { + var index = -1, + length = entries ? entries.length : 0; + + this.clear(); + while (++index < length) { + var entry = entries[index]; + this.set(entry[0], entry[1]); + } +} + +/** + * Removes all key-value entries from the hash. + * + * @private + * @name clear + * @memberOf Hash + */ +function hashClear() { + this.__data__ = nativeCreate ? nativeCreate(null) : {}; +} + +/** + * Removes `key` and its value from the hash. + * + * @private + * @name delete + * @memberOf Hash + * @param {Object} hash The hash to modify. + * @param {string} key The key of the value to remove. + * @returns {boolean} Returns `true` if the entry was removed, else `false`. + */ +function hashDelete(key) { + return this.has(key) && delete this.__data__[key]; +} + +/** + * Gets the hash value for `key`. + * + * @private + * @name get + * @memberOf Hash + * @param {string} key The key of the value to get. + * @returns {*} Returns the entry value. + */ +function hashGet(key) { + var data = this.__data__; + if (nativeCreate) { + var result = data[key]; + return result === HASH_UNDEFINED ? undefined : result; + } + return hasOwnProperty.call(data, key) ? data[key] : undefined; +} + +/** + * Checks if a hash value for `key` exists. + * + * @private + * @name has + * @memberOf Hash + * @param {string} key The key of the entry to check. + * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`. + */ +function hashHas(key) { + var data = this.__data__; + return nativeCreate ? data[key] !== undefined : hasOwnProperty.call(data, key); +} + +/** + * Sets the hash `key` to `value`. + * + * @private + * @name set + * @memberOf Hash + * @param {string} key The key of the value to set. + * @param {*} value The value to set. + * @returns {Object} Returns the hash instance. + */ +function hashSet(key, value) { + var data = this.__data__; + data[key] = (nativeCreate && value === undefined) ? HASH_UNDEFINED : value; + return this; +} + +// Add methods to `Hash`. +Hash.prototype.clear = hashClear; +Hash.prototype['delete'] = hashDelete; +Hash.prototype.get = hashGet; +Hash.prototype.has = hashHas; +Hash.prototype.set = hashSet; + +/** + * Creates an list cache object. + * + * @private + * @constructor + * @param {Array} [entries] The key-value pairs to cache. + */ +function ListCache(entries) { + var index = -1, + length = entries ? entries.length : 0; + + this.clear(); + while (++index < length) { + var entry = entries[index]; + this.set(entry[0], entry[1]); + } +} + +/** + * Removes all key-value entries from the list cache. + * + * @private + * @name clear + * @memberOf ListCache + */ +function listCacheClear() { + this.__data__ = []; +} + +/** + * Removes `key` and its value from the list cache. + * + * @private + * @name delete + * @memberOf ListCache + * @param {string} key The key of the value to remove. + * @returns {boolean} Returns `true` if the entry was removed, else `false`. + */ +function listCacheDelete(key) { + var data = this.__data__, + index = assocIndexOf(data, key); + + if (index < 0) { + return false; + } + var lastIndex = data.length - 1; + if (index == lastIndex) { + data.pop(); + } else { + splice.call(data, index, 1); + } + return true; +} + +/** + * Gets the list cache value for `key`. + * + * @private + * @name get + * @memberOf ListCache + * @param {string} key The key of the value to get. + * @returns {*} Returns the entry value. + */ +function listCacheGet(key) { + var data = this.__data__, + index = assocIndexOf(data, key); + + return index < 0 ? undefined : data[index][1]; +} + +/** + * Checks if a list cache value for `key` exists. + * + * @private + * @name has + * @memberOf ListCache + * @param {string} key The key of the entry to check. + * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`. + */ +function listCacheHas(key) { + return assocIndexOf(this.__data__, key) > -1; +} + +/** + * Sets the list cache `key` to `value`. + * + * @private + * @name set + * @memberOf ListCache + * @param {string} key The key of the value to set. + * @param {*} value The value to set. + * @returns {Object} Returns the list cache instance. + */ +function listCacheSet(key, value) { + var data = this.__data__, + index = assocIndexOf(data, key); + + if (index < 0) { + data.push([key, value]); + } else { + data[index][1] = value; + } + return this; +} + +// Add methods to `ListCache`. +ListCache.prototype.clear = listCacheClear; +ListCache.prototype['delete'] = listCacheDelete; +ListCache.prototype.get = listCacheGet; +ListCache.prototype.has = listCacheHas; +ListCache.prototype.set = listCacheSet; + +/** + * Creates a map cache object to store key-value pairs. + * + * @private + * @constructor + * @param {Array} [entries] The key-value pairs to cache. + */ +function MapCache(entries) { + var index = -1, + length = entries ? entries.length : 0; + + this.clear(); + while (++index < length) { + var entry = entries[index]; + this.set(entry[0], entry[1]); + } +} + +/** + * Removes all key-value entries from the map. + * + * @private + * @name clear + * @memberOf MapCache + */ +function mapCacheClear() { + this.__data__ = { + 'hash': new Hash, + 'map': new (Map || ListCache), + 'string': new Hash + }; +} + +/** + * Removes `key` and its value from the map. + * + * @private + * @name delete + * @memberOf MapCache + * @param {string} key The key of the value to remove. + * @returns {boolean} Returns `true` if the entry was removed, else `false`. + */ +function mapCacheDelete(key) { + return getMapData(this, key)['delete'](key); +} + +/** + * Gets the map value for `key`. + * + * @private + * @name get + * @memberOf MapCache + * @param {string} key The key of the value to get. + * @returns {*} Returns the entry value. + */ +function mapCacheGet(key) { + return getMapData(this, key).get(key); +} + +/** + * Checks if a map value for `key` exists. + * + * @private + * @name has + * @memberOf MapCache + * @param {string} key The key of the entry to check. + * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`. + */ +function mapCacheHas(key) { + return getMapData(this, key).has(key); +} + +/** + * Sets the map `key` to `value`. + * + * @private + * @name set + * @memberOf MapCache + * @param {string} key The key of the value to set. + * @param {*} value The value to set. + * @returns {Object} Returns the map cache instance. + */ +function mapCacheSet(key, value) { + getMapData(this, key).set(key, value); + return this; +} + +// Add methods to `MapCache`. +MapCache.prototype.clear = mapCacheClear; +MapCache.prototype['delete'] = mapCacheDelete; +MapCache.prototype.get = mapCacheGet; +MapCache.prototype.has = mapCacheHas; +MapCache.prototype.set = mapCacheSet; + +/** + * Assigns `value` to `key` of `object` if the existing value is not equivalent + * using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero) + * for equality comparisons. + * + * @private + * @param {Object} object The object to modify. + * @param {string} key The key of the property to assign. + * @param {*} value The value to assign. + */ +function assignValue(object, key, value) { + var objValue = object[key]; + if (!(hasOwnProperty.call(object, key) && eq(objValue, value)) || + (value === undefined && !(key in object))) { + object[key] = value; + } +} + +/** + * Gets the index at which the `key` is found in `array` of key-value pairs. + * + * @private + * @param {Array} array The array to inspect. + * @param {*} key The key to search for. + * @returns {number} Returns the index of the matched value, else `-1`. + */ +function assocIndexOf(array, key) { + var length = array.length; + while (length--) { + if (eq(array[length][0], key)) { + return length; + } + } + return -1; +} + +/** + * The base implementation of `_.isNative` without bad shim checks. + * + * @private + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a native function, + * else `false`. + */ +function baseIsNative(value) { + if (!isObject(value) || isMasked(value)) { + return false; + } + var pattern = (isFunction(value) || isHostObject(value)) ? reIsNative : reIsHostCtor; + return pattern.test(toSource(value)); +} + +/** + * The base implementation of `_.set`. + * + * @private + * @param {Object} object The object to modify. + * @param {Array|string} path The path of the property to set. + * @param {*} value The value to set. + * @param {Function} [customizer] The function to customize path creation. + * @returns {Object} Returns `object`. + */ +function baseSet(object, path, value, customizer) { + if (!isObject(object)) { + return object; + } + path = isKey(path, object) ? [path] : castPath(path); + + var index = -1, + length = path.length, + lastIndex = length - 1, + nested = object; + + while (nested != null && ++index < length) { + var key = toKey(path[index]), + newValue = value; + + if (index != lastIndex) { + var objValue = nested[key]; + newValue = customizer ? customizer(objValue, key, nested) : undefined; + if (newValue === undefined) { + newValue = isObject(objValue) + ? objValue + : (isIndex(path[index + 1]) ? [] : {}); + } + } + assignValue(nested, key, newValue); + nested = nested[key]; + } + return object; +} + +/** + * The base implementation of `_.toString` which doesn't convert nullish + * values to empty strings. + * + * @private + * @param {*} value The value to process. + * @returns {string} Returns the string. + */ +function baseToString(value) { + // Exit early for strings to avoid a performance hit in some environments. + if (typeof value == 'string') { + return value; + } + if (isSymbol(value)) { + return symbolToString ? symbolToString.call(value) : ''; + } + var result = (value + ''); + return (result == '0' && (1 / value) == -INFINITY) ? '-0' : result; +} + +/** + * Casts `value` to a path array if it's not one. + * + * @private + * @param {*} value The value to inspect. + * @returns {Array} Returns the cast property path array. + */ +function castPath(value) { + return isArray(value) ? value : stringToPath(value); +} + +/** + * Gets the data for `map`. + * + * @private + * @param {Object} map The map to query. + * @param {string} key The reference key. + * @returns {*} Returns the map data. + */ +function getMapData(map, key) { + var data = map.__data__; + return isKeyable(key) + ? data[typeof key == 'string' ? 'string' : 'hash'] + : data.map; +} + +/** + * Gets the native function at `key` of `object`. + * + * @private + * @param {Object} object The object to query. + * @param {string} key The key of the method to get. + * @returns {*} Returns the function if it's native, else `undefined`. + */ +function getNative(object, key) { + var value = getValue(object, key); + return baseIsNative(value) ? value : undefined; +} + +/** + * Checks if `value` is a valid array-like index. + * + * @private + * @param {*} value The value to check. + * @param {number} [length=MAX_SAFE_INTEGER] The upper bounds of a valid index. + * @returns {boolean} Returns `true` if `value` is a valid index, else `false`. + */ +function isIndex(value, length) { + length = length == null ? MAX_SAFE_INTEGER : length; + return !!length && + (typeof value == 'number' || reIsUint.test(value)) && + (value > -1 && value % 1 == 0 && value < length); +} + +/** + * Checks if `value` is a property name and not a property path. + * + * @private + * @param {*} value The value to check. + * @param {Object} [object] The object to query keys on. + * @returns {boolean} Returns `true` if `value` is a property name, else `false`. + */ +function isKey(value, object) { + if (isArray(value)) { + return false; + } + var type = typeof value; + if (type == 'number' || type == 'symbol' || type == 'boolean' || + value == null || isSymbol(value)) { + return true; + } + return reIsPlainProp.test(value) || !reIsDeepProp.test(value) || + (object != null && value in Object(object)); +} + +/** + * Checks if `value` is suitable for use as unique object key. + * + * @private + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is suitable, else `false`. + */ +function isKeyable(value) { + var type = typeof value; + return (type == 'string' || type == 'number' || type == 'symbol' || type == 'boolean') + ? (value !== '__proto__') + : (value === null); +} + +/** + * Checks if `func` has its source masked. + * + * @private + * @param {Function} func The function to check. + * @returns {boolean} Returns `true` if `func` is masked, else `false`. + */ +function isMasked(func) { + return !!maskSrcKey && (maskSrcKey in func); +} + +/** + * Converts `string` to a property path array. + * + * @private + * @param {string} string The string to convert. + * @returns {Array} Returns the property path array. + */ +var stringToPath = memoize(function(string) { + string = toString(string); + + var result = []; + if (reLeadingDot.test(string)) { + result.push(''); + } + string.replace(rePropName, function(match, number, quote, string) { + result.push(quote ? string.replace(reEscapeChar, '$1') : (number || match)); + }); + return result; +}); + +/** + * Converts `value` to a string key if it's not a string or symbol. + * + * @private + * @param {*} value The value to inspect. + * @returns {string|symbol} Returns the key. + */ +function toKey(value) { + if (typeof value == 'string' || isSymbol(value)) { + return value; + } + var result = (value + ''); + return (result == '0' && (1 / value) == -INFINITY) ? '-0' : result; +} + +/** + * Converts `func` to its source code. + * + * @private + * @param {Function} func The function to process. + * @returns {string} Returns the source code. + */ +function toSource(func) { + if (func != null) { + try { + return funcToString.call(func); + } catch (e) {} + try { + return (func + ''); + } catch (e) {} + } + return ''; +} + +/** + * Creates a function that memoizes the result of `func`. If `resolver` is + * provided, it determines the cache key for storing the result based on the + * arguments provided to the memoized function. By default, the first argument + * provided to the memoized function is used as the map cache key. The `func` + * is invoked with the `this` binding of the memoized function. + * + * **Note:** The cache is exposed as the `cache` property on the memoized + * function. Its creation may be customized by replacing the `_.memoize.Cache` + * constructor with one whose instances implement the + * [`Map`](http://ecma-international.org/ecma-262/7.0/#sec-properties-of-the-map-prototype-object) + * method interface of `delete`, `get`, `has`, and `set`. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Function + * @param {Function} func The function to have its output memoized. + * @param {Function} [resolver] The function to resolve the cache key. + * @returns {Function} Returns the new memoized function. + * @example + * + * var object = { 'a': 1, 'b': 2 }; + * var other = { 'c': 3, 'd': 4 }; + * + * var values = _.memoize(_.values); + * values(object); + * // => [1, 2] + * + * values(other); + * // => [3, 4] + * + * object.a = 2; + * values(object); + * // => [1, 2] + * + * // Modify the result cache. + * values.cache.set(object, ['a', 'b']); + * values(object); + * // => ['a', 'b'] + * + * // Replace `_.memoize.Cache`. + * _.memoize.Cache = WeakMap; + */ +function memoize(func, resolver) { + if (typeof func != 'function' || (resolver && typeof resolver != 'function')) { + throw new TypeError(FUNC_ERROR_TEXT); + } + var memoized = function() { + var args = arguments, + key = resolver ? resolver.apply(this, args) : args[0], + cache = memoized.cache; + + if (cache.has(key)) { + return cache.get(key); + } + var result = func.apply(this, args); + memoized.cache = cache.set(key, result); + return result; + }; + memoized.cache = new (memoize.Cache || MapCache); + return memoized; +} + +// Assign cache to `_.memoize`. +memoize.Cache = MapCache; + +/** + * Performs a + * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero) + * comparison between two values to determine if they are equivalent. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Lang + * @param {*} value The value to compare. + * @param {*} other The other value to compare. + * @returns {boolean} Returns `true` if the values are equivalent, else `false`. + * @example + * + * var object = { 'a': 1 }; + * var other = { 'a': 1 }; + * + * _.eq(object, object); + * // => true + * + * _.eq(object, other); + * // => false + * + * _.eq('a', 'a'); + * // => true + * + * _.eq('a', Object('a')); + * // => false + * + * _.eq(NaN, NaN); + * // => true + */ +function eq(value, other) { + return value === other || (value !== value && other !== other); +} + +/** + * Checks if `value` is classified as an `Array` object. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is an array, else `false`. + * @example + * + * _.isArray([1, 2, 3]); + * // => true + * + * _.isArray(document.body.children); + * // => false + * + * _.isArray('abc'); + * // => false + * + * _.isArray(_.noop); + * // => false + */ +var isArray = Array.isArray; + +/** + * Checks if `value` is classified as a `Function` object. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a function, else `false`. + * @example + * + * _.isFunction(_); + * // => true + * + * _.isFunction(/abc/); + * // => false + */ +function isFunction(value) { + // The use of `Object#toString` avoids issues with the `typeof` operator + // in Safari 8-9 which returns 'object' for typed array and other constructors. + var tag = isObject(value) ? objectToString.call(value) : ''; + return tag == funcTag || tag == genTag; +} + +/** + * Checks if `value` is the + * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types) + * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`) + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is an object, else `false`. + * @example + * + * _.isObject({}); + * // => true + * + * _.isObject([1, 2, 3]); + * // => true + * + * _.isObject(_.noop); + * // => true + * + * _.isObject(null); + * // => false + */ +function isObject(value) { + var type = typeof value; + return !!value && (type == 'object' || type == 'function'); +} + +/** + * Checks if `value` is object-like. A value is object-like if it's not `null` + * and has a `typeof` result of "object". + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is object-like, else `false`. + * @example + * + * _.isObjectLike({}); + * // => true + * + * _.isObjectLike([1, 2, 3]); + * // => true + * + * _.isObjectLike(_.noop); + * // => false + * + * _.isObjectLike(null); + * // => false + */ +function isObjectLike(value) { + return !!value && typeof value == 'object'; +} + +/** + * Checks if `value` is classified as a `Symbol` primitive or object. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a symbol, else `false`. + * @example + * + * _.isSymbol(Symbol.iterator); + * // => true + * + * _.isSymbol('abc'); + * // => false + */ +function isSymbol(value) { + return typeof value == 'symbol' || + (isObjectLike(value) && objectToString.call(value) == symbolTag); +} + +/** + * Converts `value` to a string. An empty string is returned for `null` + * and `undefined` values. The sign of `-0` is preserved. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Lang + * @param {*} value The value to process. + * @returns {string} Returns the string. + * @example + * + * _.toString(null); + * // => '' + * + * _.toString(-0); + * // => '-0' + * + * _.toString([1, 2, 3]); + * // => '1,2,3' + */ +function toString(value) { + return value == null ? '' : baseToString(value); +} + +/** + * Sets the value at `path` of `object`. If a portion of `path` doesn't exist, + * it's created. Arrays are created for missing index properties while objects + * are created for all other missing properties. Use `_.setWith` to customize + * `path` creation. + * + * **Note:** This method mutates `object`. + * + * @static + * @memberOf _ + * @since 3.7.0 + * @category Object + * @param {Object} object The object to modify. + * @param {Array|string} path The path of the property to set. + * @param {*} value The value to set. + * @returns {Object} Returns `object`. + * @example + * + * var object = { 'a': [{ 'b': { 'c': 3 } }] }; + * + * _.set(object, 'a[0].b.c', 4); + * console.log(object.a[0].b.c); + * // => 4 + * + * _.set(object, ['x', '0', 'y', 'z'], 5); + * console.log(object.x[0].y.z); + * // => 5 + */ +function set(object, path, value) { + return object == null ? object : baseSet(object, path, value); +} + +module.exports = set; + + +/***/ }), + +/***/ 897: +/***/ (function(__unusedmodule, exports, __webpack_require__) { + +"use strict"; + +// A renderer takes an `Analytics` structure and emits it as data. +Object.defineProperty(exports, "__esModule", { value: true }); +const render_html_1 = __webpack_require__(144); +const render_markdown_1 = __webpack_require__(104); +class Renderer { + static fromConfig(config) { + if (config.output == null) { + throw new Error(`config: 'output' is not defined`); + } + if (config.output.format == null) { + throw new Error(`config: 'output.format' is not defined`); + } + if (config.output.format == 'markdown') { + return new render_markdown_1.MarkdownRenderer(config); + } + else if (config.output.format == 'html') { + return new render_html_1.HtmlRenderer(config); + } + else { + throw new Error(`config: unknown output format type '${config.output.format}'`); + } + } +} +exports.Renderer = Renderer; + + +/***/ }), + +/***/ 898: +/***/ (function(__unusedmodule, exports, __webpack_require__) { + +"use strict"; + + +Object.defineProperty(exports, '__esModule', { value: true }); + +var request = __webpack_require__(753); +var universalUserAgent = __webpack_require__(796); + +const VERSION = "4.3.1"; + +class GraphqlError extends Error { + constructor(request, response) { + const message = response.data.errors[0].message; + super(message); + Object.assign(this, response.data); + this.name = "GraphqlError"; + this.request = request; // Maintains proper stack trace (only available on V8) + + /* istanbul ignore next */ + + if (Error.captureStackTrace) { + Error.captureStackTrace(this, this.constructor); + } + } + +} + +const NON_VARIABLE_OPTIONS = ["method", "baseUrl", "url", "headers", "request", "query"]; +function graphql(request, query, options) { + options = typeof query === "string" ? options = Object.assign({ + query + }, options) : options = query; + const requestOptions = Object.keys(options).reduce((result, key) => { + if (NON_VARIABLE_OPTIONS.includes(key)) { + result[key] = options[key]; + return result; + } + + if (!result.variables) { + result.variables = {}; + } + + result.variables[key] = options[key]; + return result; + }, {}); + return request(requestOptions).then(response => { + if (response.data.errors) { + throw new GraphqlError(requestOptions, { + data: response.data + }); + } + + return response.data.data; + }); +} + +function withDefaults(request$1, newDefaults) { + const newRequest = request$1.defaults(newDefaults); + + const newApi = (query, options) => { + return graphql(newRequest, query, options); + }; + + return Object.assign(newApi, { + defaults: withDefaults.bind(null, newRequest), + endpoint: request.request.endpoint + }); +} + +const graphql$1 = withDefaults(request.request, { + headers: { + "user-agent": `octokit-graphql.js/${VERSION} ${universalUserAgent.getUserAgent()}` + }, + method: "POST", + url: "/graphql" +}); +function withCustomRequest(customRequest) { + return withDefaults(customRequest, { + method: "POST", + url: "/graphql" + }); +} + +exports.graphql = graphql$1; +exports.withCustomRequest = withCustomRequest; +//# sourceMappingURL=index.js.map + + +/***/ }), + +/***/ 910: +/***/ (function(module, __unusedexports, __webpack_require__) { + +"use strict"; +// JS-YAML's default schema for `load` function. +// It is not described in the YAML specification. +// +// This schema is based on JS-YAML's default safe schema and includes +// JavaScript-specific types: !!js/undefined, !!js/regexp and !!js/function. +// +// Also this schema is used as default base schema at `Schema.create` function. + + + + + +var Schema = __webpack_require__(43); + + +module.exports = Schema.DEFAULT = new Schema({ + include: [ + __webpack_require__(723) + ], + explicit: [ + __webpack_require__(386), + __webpack_require__(237), + __webpack_require__(352) + ] +}); + + +/***/ }), + +/***/ 913: +/***/ (function(module, __unusedexports, __webpack_require__) { + +"use strict"; + + +/*eslint-disable no-bitwise*/ + +var NodeBuffer; + +try { + // A trick for browserified version, to not include `Buffer` shim + var _require = require; + NodeBuffer = _require('buffer').Buffer; +} catch (__) {} + +var Type = __webpack_require__(945); + + +// [ 64, 65, 66 ] -> [ padding, CR, LF ] +var BASE64_MAP = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=\n\r'; + + +function resolveYamlBinary(data) { + if (data === null) return false; + + var code, idx, bitlen = 0, max = data.length, map = BASE64_MAP; + + // Convert one by one. + for (idx = 0; idx < max; idx++) { + code = map.indexOf(data.charAt(idx)); + + // Skip CR/LF + if (code > 64) continue; + + // Fail on illegal characters + if (code < 0) return false; + + bitlen += 6; + } + + // If there are any bits left, source was corrupted + return (bitlen % 8) === 0; +} + +function constructYamlBinary(data) { + var idx, tailbits, + input = data.replace(/[\r\n=]/g, ''), // remove CR/LF & padding to simplify scan + max = input.length, + map = BASE64_MAP, + bits = 0, + result = []; + + // Collect by 6*4 bits (3 bytes) + + for (idx = 0; idx < max; idx++) { + if ((idx % 4 === 0) && idx) { + result.push((bits >> 16) & 0xFF); + result.push((bits >> 8) & 0xFF); + result.push(bits & 0xFF); + } + + bits = (bits << 6) | map.indexOf(input.charAt(idx)); + } + + // Dump tail + + tailbits = (max % 4) * 6; + + if (tailbits === 0) { + result.push((bits >> 16) & 0xFF); + result.push((bits >> 8) & 0xFF); + result.push(bits & 0xFF); + } else if (tailbits === 18) { + result.push((bits >> 10) & 0xFF); + result.push((bits >> 2) & 0xFF); + } else if (tailbits === 12) { + result.push((bits >> 4) & 0xFF); + } + + // Wrap into Buffer for NodeJS and leave Array for browser + if (NodeBuffer) { + // Support node 6.+ Buffer API when available + return NodeBuffer.from ? NodeBuffer.from(result) : new NodeBuffer(result); + } + + return result; +} + +function representYamlBinary(object /*, style*/) { + var result = '', bits = 0, idx, tail, + max = object.length, + map = BASE64_MAP; + + // Convert every three bytes to 4 ASCII characters. + + for (idx = 0; idx < max; idx++) { + if ((idx % 3 === 0) && idx) { + result += map[(bits >> 18) & 0x3F]; + result += map[(bits >> 12) & 0x3F]; + result += map[(bits >> 6) & 0x3F]; + result += map[bits & 0x3F]; + } + + bits = (bits << 8) + object[idx]; + } + + // Dump tail + + tail = max % 3; + + if (tail === 0) { + result += map[(bits >> 18) & 0x3F]; + result += map[(bits >> 12) & 0x3F]; + result += map[(bits >> 6) & 0x3F]; + result += map[bits & 0x3F]; + } else if (tail === 2) { + result += map[(bits >> 10) & 0x3F]; + result += map[(bits >> 4) & 0x3F]; + result += map[(bits << 2) & 0x3F]; + result += map[64]; + } else if (tail === 1) { + result += map[(bits >> 2) & 0x3F]; + result += map[(bits << 4) & 0x3F]; + result += map[64]; + result += map[64]; + } + + return result; +} + +function isBinary(object) { + return NodeBuffer && NodeBuffer.isBuffer(object); +} + +module.exports = new Type('tag:yaml.org,2002:binary', { + kind: 'scalar', + resolve: resolveYamlBinary, + construct: constructYamlBinary, + predicate: isBinary, + represent: representYamlBinary +}); + + +/***/ }), + +/***/ 916: +/***/ (function(__unusedmodule, exports) { + +"use strict"; + + +Object.defineProperty(exports, '__esModule', { value: true }); + +const VERSION = "1.0.0"; + +/** + * @param octokit Octokit instance + * @param options Options passed to Octokit constructor + */ + +function requestLog(octokit) { + octokit.hook.wrap("request", (request, options) => { + octokit.log.debug("request", options); + const start = Date.now(); + const requestOptions = octokit.request.endpoint.parse(options); + const path = requestOptions.url.replace(options.baseUrl, ""); + return request(options).then(response => { + octokit.log.info(`${requestOptions.method} ${path} - ${response.status} in ${Date.now() - start}ms`); + return response; + }).catch(error => { + octokit.log.info(`${requestOptions.method} ${path} - ${error.status} in ${Date.now() - start}ms`); + throw error; + }); + }); +} +requestLog.VERSION = VERSION; + +exports.requestLog = requestLog; +//# sourceMappingURL=index.js.map + + +/***/ }), + +/***/ 921: +/***/ (function(module, __unusedexports, __webpack_require__) { + +"use strict"; + + +var Type = __webpack_require__(945); + +module.exports = new Type('tag:yaml.org,2002:seq', { + kind: 'sequence', + construct: function (data) { return data !== null ? data : []; } +}); + + +/***/ }), + +/***/ 929: +/***/ (function(module, __unusedexports, __webpack_require__) { + +module.exports = hasNextPage + +const deprecate = __webpack_require__(370) +const getPageLinks = __webpack_require__(577) + +function hasNextPage (link) { + deprecate(`octokit.hasNextPage() – You can use octokit.paginate or async iterators instead: https://github.com/octokit/rest.js#pagination.`) + return getPageLinks(link).next +} + + +/***/ }), + +/***/ 945: +/***/ (function(module, __unusedexports, __webpack_require__) { + +"use strict"; + + +var YAMLException = __webpack_require__(556); + +var TYPE_CONSTRUCTOR_OPTIONS = [ + 'kind', + 'resolve', + 'construct', + 'instanceOf', + 'predicate', + 'represent', + 'defaultStyle', + 'styleAliases' +]; + +var YAML_NODE_KINDS = [ + 'scalar', + 'sequence', + 'mapping' +]; + +function compileStyleAliases(map) { + var result = {}; + + if (map !== null) { + Object.keys(map).forEach(function (style) { + map[style].forEach(function (alias) { + result[String(alias)] = style; + }); + }); + } + + return result; +} + +function Type(tag, options) { + options = options || {}; + + Object.keys(options).forEach(function (name) { + if (TYPE_CONSTRUCTOR_OPTIONS.indexOf(name) === -1) { + throw new YAMLException('Unknown option "' + name + '" is met in definition of "' + tag + '" YAML type.'); + } + }); + + // TODO: Add tag format check. + this.tag = tag; + this.kind = options['kind'] || null; + this.resolve = options['resolve'] || function () { return true; }; + this.construct = options['construct'] || function (data) { return data; }; + this.instanceOf = options['instanceOf'] || null; + this.predicate = options['predicate'] || null; + this.represent = options['represent'] || null; + this.defaultStyle = options['defaultStyle'] || null; + this.styleAliases = compileStyleAliases(options['styleAliases'] || null); + + if (YAML_NODE_KINDS.indexOf(this.kind) === -1) { + throw new YAMLException('Unknown kind "' + this.kind + '" is specified for "' + tag + '" YAML type.'); + } +} + +module.exports = Type; + + +/***/ }), + +/***/ 947: +/***/ (function(module, __unusedexports, __webpack_require__) { + +"use strict"; + + +var Type = __webpack_require__(945); + +var _toString = Object.prototype.toString; + +function resolveYamlPairs(data) { + if (data === null) return true; + + var index, length, pair, keys, result, + object = data; + + result = new Array(object.length); + + for (index = 0, length = object.length; index < length; index += 1) { + pair = object[index]; + + if (_toString.call(pair) !== '[object Object]') return false; + + keys = Object.keys(pair); + + if (keys.length !== 1) return false; + + result[index] = [ keys[0], pair[keys[0]] ]; + } + + return true; +} + +function constructYamlPairs(data) { + if (data === null) return []; + + var index, length, pair, keys, result, + object = data; + + result = new Array(object.length); + + for (index = 0, length = object.length; index < length; index += 1) { + pair = object[index]; + + keys = Object.keys(pair); + + result[index] = [ keys[0], pair[keys[0]] ]; + } + + return result; +} + +module.exports = new Type('tag:yaml.org,2002:pairs', { + kind: 'sequence', + resolve: resolveYamlPairs, + construct: constructYamlPairs +}); + + +/***/ }), + +/***/ 948: +/***/ (function(module) { + +"use strict"; + + +/** + * Tries to execute a function and discards any error that occurs. + * @param {Function} fn - Function that might or might not throw an error. + * @returns {?*} Return-value of the function when no error occurred. + */ +module.exports = function(fn) { + + try { return fn() } catch (e) {} + +} + +/***/ }), + +/***/ 950: +/***/ (function(__unusedmodule, exports, __webpack_require__) { + +"use strict"; + +Object.defineProperty(exports, "__esModule", { value: true }); +const url = __webpack_require__(835); +function getProxyUrl(reqUrl) { + let usingSsl = reqUrl.protocol === 'https:'; + let proxyUrl; + if (checkBypass(reqUrl)) { + return proxyUrl; + } + let proxyVar; + if (usingSsl) { + proxyVar = process.env["https_proxy"] || + process.env["HTTPS_PROXY"]; + } + else { + proxyVar = process.env["http_proxy"] || + process.env["HTTP_PROXY"]; + } + if (proxyVar) { + proxyUrl = url.parse(proxyVar); + } + return proxyUrl; +} +exports.getProxyUrl = getProxyUrl; +function checkBypass(reqUrl) { + if (!reqUrl.hostname) { + return false; + } + let noProxy = process.env["no_proxy"] || process.env["NO_PROXY"] || ''; + if (!noProxy) { + return false; + } + // Determine the request port + let reqPort; + if (reqUrl.port) { + reqPort = Number(reqUrl.port); + } + else if (reqUrl.protocol === 'http:') { + reqPort = 80; + } + else if (reqUrl.protocol === 'https:') { + reqPort = 443; + } + // Format the request hostname and hostname with port + let upperReqHosts = [reqUrl.hostname.toUpperCase()]; + if (typeof reqPort === 'number') { + upperReqHosts.push(`${upperReqHosts[0]}:${reqPort}`); + } + // Compare request host against noproxy + for (let upperNoProxyItem of noProxy.split(',').map(x => x.trim().toUpperCase()).filter(x => x)) { + if (upperReqHosts.some(x => x === upperNoProxyItem)) { + return true; + } + } + return false; +} +exports.checkBypass = checkBypass; + + +/***/ }), + +/***/ 954: +/***/ (function(module) { + +module.exports = validateAuth; + +function validateAuth(auth) { + if (typeof auth === "string") { + return; + } + + if (typeof auth === "function") { + return; + } + + if (auth.username && auth.password) { + return; + } + + if (auth.clientId && auth.clientSecret) { + return; + } + + throw new Error(`Invalid "auth" option: ${JSON.stringify(auth)}`); +} + + +/***/ }), + +/***/ 955: +/***/ (function(module, __unusedexports, __webpack_require__) { + +"use strict"; + +const path = __webpack_require__(622); +const childProcess = __webpack_require__(129); +const crossSpawn = __webpack_require__(20); +const stripEof = __webpack_require__(768); +const npmRunPath = __webpack_require__(621); +const isStream = __webpack_require__(323); +const _getStream = __webpack_require__(145); +const pFinally = __webpack_require__(697); +const onExit = __webpack_require__(260); +const errname = __webpack_require__(427); +const stdio = __webpack_require__(168); + +const TEN_MEGABYTES = 1000 * 1000 * 10; + +function handleArgs(cmd, args, opts) { + let parsed; + + opts = Object.assign({ + extendEnv: true, + env: {} + }, opts); + + if (opts.extendEnv) { + opts.env = Object.assign({}, process.env, opts.env); + } + + if (opts.__winShell === true) { + delete opts.__winShell; + parsed = { + command: cmd, + args, + options: opts, + file: cmd, + original: { + cmd, + args + } + }; + } else { + parsed = crossSpawn._parse(cmd, args, opts); + } + + opts = Object.assign({ + maxBuffer: TEN_MEGABYTES, + buffer: true, + stripEof: true, + preferLocal: true, + localDir: parsed.options.cwd || process.cwd(), + encoding: 'utf8', + reject: true, + cleanup: true + }, parsed.options); + + opts.stdio = stdio(opts); + + if (opts.preferLocal) { + opts.env = npmRunPath.env(Object.assign({}, opts, {cwd: opts.localDir})); + } + + if (opts.detached) { + // #115 + opts.cleanup = false; + } + + if (process.platform === 'win32' && path.basename(parsed.command) === 'cmd.exe') { + // #116 + parsed.args.unshift('/q'); + } + + return { + cmd: parsed.command, + args: parsed.args, + opts, + parsed + }; +} + +function handleInput(spawned, input) { + if (input === null || input === undefined) { + return; + } + + if (isStream(input)) { + input.pipe(spawned.stdin); + } else { + spawned.stdin.end(input); + } +} + +function handleOutput(opts, val) { + if (val && opts.stripEof) { + val = stripEof(val); + } + + return val; +} + +function handleShell(fn, cmd, opts) { + let file = '/bin/sh'; + let args = ['-c', cmd]; + + opts = Object.assign({}, opts); + + if (process.platform === 'win32') { + opts.__winShell = true; + file = process.env.comspec || 'cmd.exe'; + args = ['/s', '/c', `"${cmd}"`]; + opts.windowsVerbatimArguments = true; + } + + if (opts.shell) { + file = opts.shell; + delete opts.shell; + } + + return fn(file, args, opts); +} + +function getStream(process, stream, {encoding, buffer, maxBuffer}) { + if (!process[stream]) { + return null; + } + + let ret; + + if (!buffer) { + // TODO: Use `ret = util.promisify(stream.finished)(process[stream]);` when targeting Node.js 10 + ret = new Promise((resolve, reject) => { + process[stream] + .once('end', resolve) + .once('error', reject); + }); + } else if (encoding) { + ret = _getStream(process[stream], { + encoding, + maxBuffer + }); + } else { + ret = _getStream.buffer(process[stream], {maxBuffer}); + } + + return ret.catch(err => { + err.stream = stream; + err.message = `${stream} ${err.message}`; + throw err; + }); +} + +function makeError(result, options) { + const {stdout, stderr} = result; + + let err = result.error; + const {code, signal} = result; + + const {parsed, joinedCmd} = options; + const timedOut = options.timedOut || false; + + if (!err) { + let output = ''; + + if (Array.isArray(parsed.opts.stdio)) { + if (parsed.opts.stdio[2] !== 'inherit') { + output += output.length > 0 ? stderr : `\n${stderr}`; + } + + if (parsed.opts.stdio[1] !== 'inherit') { + output += `\n${stdout}`; + } + } else if (parsed.opts.stdio !== 'inherit') { + output = `\n${stderr}${stdout}`; + } + + err = new Error(`Command failed: ${joinedCmd}${output}`); + err.code = code < 0 ? errname(code) : code; + } + + err.stdout = stdout; + err.stderr = stderr; + err.failed = true; + err.signal = signal || null; + err.cmd = joinedCmd; + err.timedOut = timedOut; + + return err; +} + +function joinCmd(cmd, args) { + let joinedCmd = cmd; + + if (Array.isArray(args) && args.length > 0) { + joinedCmd += ' ' + args.join(' '); + } + + return joinedCmd; +} + +module.exports = (cmd, args, opts) => { + const parsed = handleArgs(cmd, args, opts); + const {encoding, buffer, maxBuffer} = parsed.opts; + const joinedCmd = joinCmd(cmd, args); + + let spawned; + try { + spawned = childProcess.spawn(parsed.cmd, parsed.args, parsed.opts); + } catch (err) { + return Promise.reject(err); + } + + let removeExitHandler; + if (parsed.opts.cleanup) { + removeExitHandler = onExit(() => { + spawned.kill(); + }); + } + + let timeoutId = null; + let timedOut = false; + + const cleanup = () => { + if (timeoutId) { + clearTimeout(timeoutId); + timeoutId = null; + } + + if (removeExitHandler) { + removeExitHandler(); + } + }; + + if (parsed.opts.timeout > 0) { + timeoutId = setTimeout(() => { + timeoutId = null; + timedOut = true; + spawned.kill(parsed.opts.killSignal); + }, parsed.opts.timeout); + } + + const processDone = new Promise(resolve => { + spawned.on('exit', (code, signal) => { + cleanup(); + resolve({code, signal}); + }); + + spawned.on('error', err => { + cleanup(); + resolve({error: err}); + }); + + if (spawned.stdin) { + spawned.stdin.on('error', err => { + cleanup(); + resolve({error: err}); + }); + } + }); + + function destroy() { + if (spawned.stdout) { + spawned.stdout.destroy(); + } + + if (spawned.stderr) { + spawned.stderr.destroy(); + } + } + + const handlePromise = () => pFinally(Promise.all([ + processDone, + getStream(spawned, 'stdout', {encoding, buffer, maxBuffer}), + getStream(spawned, 'stderr', {encoding, buffer, maxBuffer}) + ]).then(arr => { + const result = arr[0]; + result.stdout = arr[1]; + result.stderr = arr[2]; + + if (result.error || result.code !== 0 || result.signal !== null) { + const err = makeError(result, { + joinedCmd, + parsed, + timedOut + }); + + // TODO: missing some timeout logic for killed + // https://github.com/nodejs/node/blob/master/lib/child_process.js#L203 + // err.killed = spawned.killed || killed; + err.killed = err.killed || spawned.killed; + + if (!parsed.opts.reject) { + return err; + } + + throw err; + } + + return { + stdout: handleOutput(parsed.opts, result.stdout), + stderr: handleOutput(parsed.opts, result.stderr), + code: 0, + failed: false, + killed: false, + signal: null, + cmd: joinedCmd, + timedOut: false + }; + }), destroy); + + crossSpawn._enoent.hookChildProcess(spawned, parsed.parsed); + + handleInput(spawned, parsed.opts.input); + + spawned.then = (onfulfilled, onrejected) => handlePromise().then(onfulfilled, onrejected); + spawned.catch = onrejected => handlePromise().catch(onrejected); + + return spawned; +}; + +// TODO: set `stderr: 'ignore'` when that option is implemented +module.exports.stdout = (...args) => module.exports(...args).then(x => x.stdout); + +// TODO: set `stdout: 'ignore'` when that option is implemented +module.exports.stderr = (...args) => module.exports(...args).then(x => x.stderr); + +module.exports.shell = (cmd, opts) => handleShell(module.exports, cmd, opts); + +module.exports.sync = (cmd, args, opts) => { + const parsed = handleArgs(cmd, args, opts); + const joinedCmd = joinCmd(cmd, args); + + if (isStream(parsed.opts.input)) { + throw new TypeError('The `input` option cannot be a stream in sync mode'); + } + + const result = childProcess.spawnSync(parsed.cmd, parsed.args, parsed.opts); + result.code = result.status; + + if (result.error || result.status !== 0 || result.signal !== null) { + const err = makeError(result, { + joinedCmd, + parsed + }); + + if (!parsed.opts.reject) { + return err; + } + + throw err; + } + + return { + stdout: handleOutput(parsed.opts, result.stdout), + stderr: handleOutput(parsed.opts, result.stderr), + code: 0, + failed: false, + signal: null, + cmd: joinedCmd, + timedOut: false + }; +}; + +module.exports.shellSync = (cmd, opts) => handleShell(module.exports.sync, cmd, opts); + + +/***/ }), + +/***/ 966: +/***/ (function(module, __unusedexports, __webpack_require__) { + +"use strict"; + +const {PassThrough} = __webpack_require__(413); + +module.exports = options => { + options = Object.assign({}, options); + + const {array} = options; + let {encoding} = options; + const buffer = encoding === 'buffer'; + let objectMode = false; + + if (array) { + objectMode = !(encoding || buffer); + } else { + encoding = encoding || 'utf8'; + } + + if (buffer) { + encoding = null; + } + + let len = 0; + const ret = []; + const stream = new PassThrough({objectMode}); + + if (encoding) { + stream.setEncoding(encoding); + } + + stream.on('data', chunk => { + ret.push(chunk); + + if (objectMode) { + len = ret.length; + } else { + len += chunk.length; + } + }); + + stream.getBufferedValue = () => { + if (array) { + return ret; + } + + return buffer ? Buffer.concat(ret, len) : ret.join(''); + }; + + stream.getBufferedLength = () => len; + + return stream; +}; + + +/***/ }), + +/***/ 969: +/***/ (function(module, __unusedexports, __webpack_require__) { + +var wrappy = __webpack_require__(11) +module.exports = wrappy(once) +module.exports.strict = wrappy(onceStrict) + +once.proto = once(function () { + Object.defineProperty(Function.prototype, 'once', { + value: function () { + return once(this) + }, + configurable: true + }) + + Object.defineProperty(Function.prototype, 'onceStrict', { + value: function () { + return onceStrict(this) + }, + configurable: true + }) +}) + +function once (fn) { + var f = function () { + if (f.called) return f.value + f.called = true + return f.value = fn.apply(this, arguments) + } + f.called = false + return f +} + +function onceStrict (fn) { + var f = function () { + if (f.called) + throw new Error(f.onceError) + f.called = true + return f.value = fn.apply(this, arguments) + } + var name = fn.name || 'Function wrapped with `once`' + f.onceError = name + " shouldn't be called more than once" + f.called = false + return f +} + + +/***/ }), + +/***/ 988: +/***/ (function(module, __unusedexports, __webpack_require__) { + +"use strict"; + + +var Type = __webpack_require__(945); + +module.exports = new Type('tag:yaml.org,2002:map', { + kind: 'mapping', + construct: function (data) { return data !== null ? data : {}; } +}); + + +/***/ }) + +/******/ }); \ No newline at end of file