From 28b61d19c344fcea9a337a0289ad3df79275232a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jan=20Wa=C5=9B?= Date: Wed, 4 Sep 2024 12:46:46 +0200 Subject: [PATCH] Import action-surefire-report Import v1.6.2 (7263a78) used in Trino. This version is using a more efficient, native XML parsing library. --- .github/workflows/action-surefire-report.yml | 91 + .github/workflows/ci.yml | 6 + README.md | 4 + action-surefire-report/.eslintignore | 1 + action-surefire-report/.eslintrc.json | 19 + action-surefire-report/.gitignore | 76 + action-surefire-report/.prettierignore | 4 + action-surefire-report/.prettierrc.json | 12 + action-surefire-report/Dockerfile | 5 + action-surefire-report/LICENSE | 201 + action-surefire-report/README.md | 90 + action-surefire-report/action.js | 114 + .../action.test.fixtures.js | 224 + action-surefire-report/action.test.js | 239 + action-surefire-report/action.yml | 53 + ...pro.taskana.common.api.ListUtilTest-H2.xml | 39 + .../TEST-test.MyIntegrationTestSuite.xml | 47 + .../dist/build/Release/xmljs.node | Bin 0 -> 1840416 bytes action-surefire-report/dist/index.js | 16831 ++++++++++++++++ action-surefire-report/go/go.mod | 11 + action-surefire-report/go/go.sum | 17 + action-surefire-report/go/main_test.go | 13 + .../go/utils/string_test.go | 8 + action-surefire-report/index.js | 10 + action-surefire-report/package-lock.json | 11031 ++++++++++ action-surefire-report/package.json | 50 + action-surefire-report/python/__init__.py | 0 action-surefire-report/python/test_sample.py | 14 + action-surefire-report/screenshot.png | Bin 0 -> 97659 bytes .../report/email/EmailAddressTest.class | Bin 0 -> 2786 bytes action-surefire-report/tests/email/pom.xml | 32 + .../surefire/report/email/EmailAddress.java | 34 + .../email/InvalidEmailAddressException.java | 7 + .../report/email/EmailAddressTest.java | 80 + .../tests/evil_twins/pom.xml | 26 + .../surefire/report/twin/first/Twin.java | 8 + .../surefire/report/twin/second/Twin.java | 8 + .../surefire/report/twin/first/TwinTest.java | 16 + .../surefire/report/twin/second/TwinTest.java | 16 + action-surefire-report/tests/pom.xml | 84 + action-surefire-report/tests/utils/pom.xml | 89 + .../surefire/report/calc/CalcUtils.java | 62 + .../surefire/report/calc/StringUtils.java | 29 + .../surefire/report/calc/AllOkTest.java | 10 + .../surefire/report/calc/CalcUtilsTest.kt | 33 + .../surefire/report/calc/StringUtilsTest.java | 51 + action-surefire-report/utils.js | 123 + action-surefire-report/utils.test.js | 360 + 48 files changed, 30278 insertions(+) create mode 100644 .github/workflows/action-surefire-report.yml create mode 100644 action-surefire-report/.eslintignore create mode 100644 action-surefire-report/.eslintrc.json create mode 100644 action-surefire-report/.gitignore create mode 100644 action-surefire-report/.prettierignore create mode 100644 action-surefire-report/.prettierrc.json create mode 100644 action-surefire-report/Dockerfile create mode 100644 action-surefire-report/LICENSE create mode 100644 action-surefire-report/README.md create mode 100644 action-surefire-report/action.js create mode 100644 action-surefire-report/action.test.fixtures.js create mode 100644 action-surefire-report/action.test.js create mode 100644 action-surefire-report/action.yml create mode 100644 action-surefire-report/custom_reports/TEST-pro.taskana.common.api.ListUtilTest-H2.xml create mode 100644 action-surefire-report/custom_reports/TEST-test.MyIntegrationTestSuite.xml create mode 100755 action-surefire-report/dist/build/Release/xmljs.node create mode 100644 action-surefire-report/dist/index.js create mode 100644 action-surefire-report/go/go.mod create mode 100644 action-surefire-report/go/go.sum create mode 100644 action-surefire-report/go/main_test.go create mode 100644 action-surefire-report/go/utils/string_test.go create mode 100644 action-surefire-report/index.js create mode 100644 action-surefire-report/package-lock.json create mode 100644 action-surefire-report/package.json create mode 100644 action-surefire-report/python/__init__.py create mode 100644 action-surefire-report/python/test_sample.py create mode 100644 action-surefire-report/screenshot.png create mode 100644 action-surefire-report/tests/email/build/java/test/action/surefire/report/email/EmailAddressTest.class create mode 100644 action-surefire-report/tests/email/pom.xml create mode 100644 action-surefire-report/tests/email/src/main/java/action/surefire/report/email/EmailAddress.java create mode 100644 action-surefire-report/tests/email/src/main/java/action/surefire/report/email/InvalidEmailAddressException.java create mode 100644 action-surefire-report/tests/email/src/test/java/action/surefire/report/email/EmailAddressTest.java create mode 100644 action-surefire-report/tests/evil_twins/pom.xml create mode 100644 action-surefire-report/tests/evil_twins/src/main/java/action/surefire/report/twin/first/Twin.java create mode 100644 action-surefire-report/tests/evil_twins/src/main/java/action/surefire/report/twin/second/Twin.java create mode 100644 action-surefire-report/tests/evil_twins/src/test/java/action/surefire/report/twin/first/TwinTest.java create mode 100644 action-surefire-report/tests/evil_twins/src/test/java/action/surefire/report/twin/second/TwinTest.java create mode 100644 action-surefire-report/tests/pom.xml create mode 100644 action-surefire-report/tests/utils/pom.xml create mode 100644 action-surefire-report/tests/utils/src/main/java/action/surefire/report/calc/CalcUtils.java create mode 100644 action-surefire-report/tests/utils/src/main/java/action/surefire/report/calc/StringUtils.java create mode 100644 action-surefire-report/tests/utils/src/test/java/action/surefire/report/calc/AllOkTest.java create mode 100644 action-surefire-report/tests/utils/src/test/java/action/surefire/report/calc/CalcUtilsTest.kt create mode 100644 action-surefire-report/tests/utils/src/test/java/action/surefire/report/calc/StringUtilsTest.java create mode 100644 action-surefire-report/utils.js create mode 100644 action-surefire-report/utils.test.js diff --git a/.github/workflows/action-surefire-report.yml b/.github/workflows/action-surefire-report.yml new file mode 100644 index 0000000..fd3dd92 --- /dev/null +++ b/.github/workflows/action-surefire-report.yml @@ -0,0 +1,91 @@ +name: action-surefire-report + +on: + push: + paths: + - 'action-surefire-report/**' + +jobs: + build: + runs-on: ubuntu-latest + permissions: + contents: read + checks: write + defaults: + run: + working-directory: ./action-surefire-report + steps: + - uses: actions/checkout@v3 + + # generate artifacts used for tests + - uses: actions/setup-java@v3 + with: + java-version: 8 + distribution: 'temurin' + cache: 'maven' + - run: | + cd tests && mvn clean test --batch-mode -Dmaven.test.failure.ignore=true + - uses: ./action-surefire-report + if: github.ref != 'refs/heads/main' + with: + check_name: Example Surefire Test Report + - name: Set up Python + uses: actions/setup-python@v5 + with: + python-version: '3.x' + - name: Test with pytest + run: | + python -m pip install --upgrade pip + pip install pytest + pytest --junit-xml=python/report.xml python/ || exit 0 + - uses: ./action-surefire-report + if: github.ref != 'refs/heads/main' + with: + check_name: Example Pytest Report + report_paths: python/report.xml + - uses: actions/setup-go@v3 + with: + go-version: 1.18.x + - run: | + cd go && + go install github.com/jstemmer/go-junit-report/v2@latest && + go test -v 2>&1 ./... | go-junit-report -out report.xml + - uses: ./action-surefire-report + if: github.ref != 'refs/heads/main' + with: + check_name: Example Go Report + report_paths: go/report.xml + file_name_in_stack_trace: true + + # build and test the action + - name: Setup Node.js + uses: actions/setup-node@v3 + with: + node-version: 16.x + cache: 'npm' + cache-dependency-path: | + action-surefire-report/package-lock.json + + - name: Build and test + run: | + npm ci + npm run eslint + npm run test + npm run package + + - name: Compare the expected and actual dist/ directories + run: | + if [ "$(git diff --ignore-space-at-eol dist/ | wc -l)" -gt "0" ]; then + echo "Detected uncommitted changes after build. See status below:" + git diff + exit 1 + fi + id: diff + + # If index.js was different than expected, upload the expected version as an artifact + - uses: actions/upload-artifact@v3 + if: ${{ failure() && steps.diff.conclusion == 'failure' }} + with: + name: dist + path: | + action-surefire-report/dist/ diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index e4092ce..0d561e4 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -2,7 +2,13 @@ name: ci on: push: + branches: + - main + paths-ignore: + - 'action-surefire-report/**' pull_request: + paths-ignore: + - 'action-surefire-report/**' jobs: build: diff --git a/README.md b/README.md index 8ccc242..e23e0cf 100644 --- a/README.md +++ b/README.md @@ -4,3 +4,7 @@ Github actions used in the Trino project Some actions are forked with no local changes to defend against changes with a hash collision and repo deletion: * [github-app-token](/github-app-token) is forked from [https://github.com/tibdex/github-app-token](https://github.com/tibdex/github-app-token) at [v1.6.0 (f66c1c3)](https://github.com/tibdex/github-app-token/commit/f66c1c31c49c0a4d593a5820a9f1e231af3321ad) * [slash-command-dispatch](/slash-command-dispatch) is forked from [peter-evans/slash-command-dispatch](https://github.com/peter-evans/slash-command-dispatch) at [v3.0.0 (71e68e5)](https://github.com/peter-evans/slash-command-dispatch/commit/71e68e5b4a13cff7a8c0c290f4fb9e615d873944) + +Following actions are forked with changes: +* [action-surefire-report](/action-surefire-report) is forked from [ScaCap/action-surefire-report](https://github.com/ScaCap/action-surefire-report) at [v1.6.2 (7263a78)](https://github.com/ScaCap/action-surefire-report/commits/7263a78ba060b395c8a0a0e58fc897efb1bddb7c) to: + * use a more efficient XML parser library, which was reverted in later versions, because it's not portable diff --git a/action-surefire-report/.eslintignore b/action-surefire-report/.eslintignore new file mode 100644 index 0000000..a261f29 --- /dev/null +++ b/action-surefire-report/.eslintignore @@ -0,0 +1 @@ +dist/* diff --git a/action-surefire-report/.eslintrc.json b/action-surefire-report/.eslintrc.json new file mode 100644 index 0000000..347b9c2 --- /dev/null +++ b/action-surefire-report/.eslintrc.json @@ -0,0 +1,19 @@ +{ + "env": { + "commonjs": true, + "es6": true, + "node": true, + "jest": true + }, + "extends": "eslint:recommended", + "globals": { + "Atomics": "readonly", + "SharedArrayBuffer": "readonly" + }, + "parserOptions": { + "ecmaVersion": 2020 + }, + "rules": { + "indent": 2 + } +} diff --git a/action-surefire-report/.gitignore b/action-surefire-report/.gitignore new file mode 100644 index 0000000..4f0ce2a --- /dev/null +++ b/action-surefire-report/.gitignore @@ -0,0 +1,76 @@ +node_modules/ + +# Editors +.vscode + +# Logs +logs +*.log +npm-debug.log* +yarn-debug.log* +yarn-error.log* + +# Runtime data +pids +*.pid +*.seed +*.pid.lock + +# Directory for instrumented libs generated by jscoverage/JSCover +lib-cov + +# Coverage directory used by tools like istanbul +coverage + +# nyc test coverage +.nyc_output + +# Grunt intermediate storage (http://gruntjs.com/creating-plugins#storing-task-files) +.grunt + +# Bower dependency directory (https://bower.io/) +bower_components + +# node-waf configuration +.lock-wscript + +# Compiled binary addons (https://nodejs.org/api/addons.html) +build/Release + +# Other Dependency directories +jspm_packages/ + +# TypeScript v1 declaration files +typings/ + +# Optional npm cache directory +.npm + +# Optional eslint cache +.eslintcache + +# Optional REPL history +.node_repl_history + +# Output of 'npm pack' +*.tgz + +# Yarn Integrity file +.yarn-integrity + +# dotenv environment variables file +.env + +# next.js build output +.next + +.factorypath +.classpath +.project +.settings/ +target/ +.idea +*.iml +junit.xml +report.xml +__pycache__ diff --git a/action-surefire-report/.prettierignore b/action-surefire-report/.prettierignore new file mode 100644 index 0000000..0e0c496 --- /dev/null +++ b/action-surefire-report/.prettierignore @@ -0,0 +1,4 @@ +package.json +package-lock.json +.eslintrc.json +.babelrc diff --git a/action-surefire-report/.prettierrc.json b/action-surefire-report/.prettierrc.json new file mode 100644 index 0000000..df35e47 --- /dev/null +++ b/action-surefire-report/.prettierrc.json @@ -0,0 +1,12 @@ +{ + "printWidth": 100, + "tabWidth": 4, + "useTabs": false, + "semi": true, + "singleQuote": true, + "jsxSingleQuote":false, + "trailingComma": "none", + "bracketSpacing": true, + "jsxBracketSameLine": false, + "arrowParens": "avoid" +} \ No newline at end of file diff --git a/action-surefire-report/Dockerfile b/action-surefire-report/Dockerfile new file mode 100644 index 0000000..7cda2d9 --- /dev/null +++ b/action-surefire-report/Dockerfile @@ -0,0 +1,5 @@ +FROM node:16-bullseye-slim + +COPY dist /dist + +ENTRYPOINT ["node", "/dist/index.js"] diff --git a/action-surefire-report/LICENSE b/action-surefire-report/LICENSE new file mode 100644 index 0000000..af83c19 --- /dev/null +++ b/action-surefire-report/LICENSE @@ -0,0 +1,201 @@ + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright 2020 ScaCap + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. \ No newline at end of file diff --git a/action-surefire-report/README.md b/action-surefire-report/README.md new file mode 100644 index 0000000..bf36c41 --- /dev/null +++ b/action-surefire-report/README.md @@ -0,0 +1,90 @@ +# GitHub Action: Process maven surefire reports + +![](https://github.com/scacap/action-surefire-report/workflows/build/badge.svg) + + +This action processes maven surefire or failsafe XML reports on pull requests and shows the result as a PR check with summary and annotations. + +![Screenshot](./screenshot.png) + +## Inputs + +### `report_paths` + +Optional. [Glob](https://github.com/actions/toolkit/tree/master/packages/glob) expression to surefire or failsafe report paths. The default is `**/surefire-reports/TEST-*.xml`. + +### `create_check` + +Optional. Set to `false` to add annotations to the current job where this action is being executed. The default is `true`. + +### `check_name` + +Optional. Check name to use when creating a check run. The default is `Test Report`. + +### `commit` + +Optional. The commit sha to update the status. This is useful when you run it with `workflow_run`. + +### `fail_on_test_failures` + +Optional. Check will fail if there are test failures. The default is `false`. + +### `fail_if_no_tests` + +Optional. Check will fail if no tests were found. The default is `true`. + +### `skip_publishing` + +Optional. Skip the test report publishing (check run creation). The default is `false`. + +### `github_token` + +Optional. Usually in form of `github_token: ${{ secrets.GITHUB_TOKEN }}`. The default is `${{ github.token }}`. + +### `file_name_in_stack_trace` + +Optional. Set to `true` to get the file name from the stack trace. The default is `false`. + +### `github_base_url` + +Optional: If you use GitHub Enterprise, you can set this to the URL of your server (e.g. https://github.myorg.com/api/v3). + + +## Example usage + +```yml +name: build +on: + pull_request: + +jobs: + build: + name: Build and Run Tests + runs-on: ubuntu-latest + steps: + - name: Checkout Code + uses: actions/checkout@v1 + - name: Build and Run Tests + run: mvn test --batch-mode --fail-at-end + - name: Publish Test Report + if: success() || failure() + uses: scacap/action-surefire-report@v1 +``` + +## Tips for Gradle + +As Gradle uses a different build directory than Maven by default, you might need to set the `report_paths` variable: + +```yaml + report_paths: '**/build/test-results/test/TEST-*.xml' +``` + +You also need to enable JUnit XML reports as shown below. + +```groovy +test { + reports { + junitXml.enabled = true + } +} +``` diff --git a/action-surefire-report/action.js b/action-surefire-report/action.js new file mode 100644 index 0000000..2d38b21 --- /dev/null +++ b/action-surefire-report/action.js @@ -0,0 +1,114 @@ +const core = require('@actions/core'); +const github = require('@actions/github'); +const { Octokit } = require("@octokit/rest"); +const { retry } = require("@octokit/plugin-retry"); +const RetryingOctokit = Octokit.plugin(retry); +const { parseTestReports } = require('./utils.js'); + + +const action = async () => { + const reportPaths = core.getInput('report_paths').split(',').join('\n'); + core.info(`Going to parse results form ${reportPaths}`); + const githubToken = core.getInput('github_token'); + const createCheck = (core.getInput('create_check') || 'true') === 'true'; + const name = core.getInput('check_name'); + const commit = core.getInput('commit'); + const failOnFailedTests = core.getInput('fail_on_test_failures') === 'true'; + const failIfNoTests = core.getInput('fail_if_no_tests') === 'true'; + const skipPublishing = core.getInput('skip_publishing') === 'true'; + const isFilenameInStackTrace = core.getInput('file_name_in_stack_trace') === 'true'; + const githubBaseUrl = core.getInput('github_base_url'); + + let { count, skipped, annotations } = await parseTestReports(reportPaths, isFilenameInStackTrace); + const foundResults = count > 0 || skipped > 0; + const conclusion = + (foundResults && annotations.length === 0) || (!foundResults && !failIfNoTests) + ? 'success' + : 'failure'; + + function buildRetryingOctokitClient() { + const baseRequest = { auth: githubToken, request: { retries: 3 } }; + + if (githubBaseUrl){ + baseRequest.baseUrl = githubBaseUrl; + } + + return new RetryingOctokit(baseRequest) + } + + if (!skipPublishing) { + const title = foundResults + ? `${count} tests run, ${skipped} skipped, ${annotations.length} failed.` + : 'No test results found!'; + core.info(`Result: ${title}`); + + const pullRequest = github.context.payload.pull_request; + const link = (pullRequest && pullRequest.html_url) || github.context.ref; + const status = 'completed'; + const head_sha = commit || (pullRequest && pullRequest.head.sha) || github.context.sha; + + const octokit = buildRetryingOctokitClient(); + if (createCheck) { + core.info(`Posting status '${status}' with conclusion '${conclusion}' to ${link} (sha: ${head_sha})`); + const createCheckRequest = { + ...github.context.repo, + name, + head_sha, + status, + conclusion, + output: { + title, + summary: '', + annotations: annotations.slice(0, 50) + } + }; + + core.debug(JSON.stringify(createCheckRequest, null, 2)); + + await octokit.rest.checks.create(createCheckRequest); + } else { + const { data: {check_runs: check_runs} } = await octokit.rest.checks.listForRef({ + ...github.context.repo, + check_name: name, + ref: head_sha, + status: 'in_progress' + }) + core.debug(JSON.stringify(check_runs, null, 2)); + if (check_runs.length === 0) { + core.setFailed(`Did not find any in progress '${name}' check for sha ${head_sha}`); + return; + } + if (check_runs.length !== 1) { + core.setFailed(`Found multiple in progress '${name}' checks for sha ${head_sha}`); + return; + } + const check_run = check_runs[0]; + core.info(`Patching '${name}' check for ${link} (sha: ${head_sha})`); + const updateCheckRequest = { + ...github.context.repo, + check_run_id: check_run.id, + output: { + title: check_run.output.title || title, + summary: check_run.output.summary || '', + annotations: annotations.slice(0, 50) + } + }; + + core.debug(JSON.stringify(updateCheckRequest, null, 2)); + + await octokit.rest.checks.update(updateCheckRequest); + } + } else { + core.info('Not publishing test result due to skip_publishing=true'); + } + + // make conclusion consumable by downstream actions + core.setOutput('conclusion', conclusion); + + // optionally fail the action if tests fail + if (failOnFailedTests && conclusion !== 'success') { + core.setFailed(`There were ${annotations.length} failed tests`); + } +}; + +module.exports = action; diff --git a/action-surefire-report/action.test.fixtures.js b/action-surefire-report/action.test.fixtures.js new file mode 100644 index 0000000..67a787c --- /dev/null +++ b/action-surefire-report/action.test.fixtures.js @@ -0,0 +1,224 @@ +const finishedWithFailures = { + name: 'Test Report', + head_sha: 'sha123', + status: 'completed', + conclusion: 'failure', + output: { + title: '19 tests run, 1 skipped, 12 failed.', + summary: '', + annotations: [ + { + path: + 'tests/email/src/test/java/action/surefire/report/email/EmailAddressTest.java', + start_line: 39, + end_line: 39, + start_column: 0, + end_column: 0, + annotation_level: 'failure', + title: 'EmailAddressTest.shouldNotContainInternationalizedHostNames', + message: "Invalid email address 'user@ñandú.com.ar'", + raw_details: + "action.surefire.report.email.InvalidEmailAddressException: Invalid email address 'user@ñandú.com.ar'\n\tat action.surefire.report.email.EmailAddressTest.expectException(EmailAddressTest.java:74)\n\tat action.surefire.report.email.EmailAddressTest.shouldNotContainInternationalizedHostNames(EmailAddressTest.java:39)" + }, + { + path: + 'tests/email/src/test/java/action/surefire/report/email/EmailAddressTest.java', + start_line: 49, + end_line: 49, + start_column: 0, + end_column: 0, + annotation_level: 'failure', + title: 'EmailAddressTest.shouldBeStricterThanRfc2821', + message: "Invalid email address 'Abc\\@def@example.com'", + raw_details: + "action.surefire.report.email.InvalidEmailAddressException: Invalid email address 'Abc\\@def@example.com'\n\tat action.surefire.report.email.EmailAddressTest.expectException(EmailAddressTest.java:74)\n\tat action.surefire.report.email.EmailAddressTest.shouldBeStricterThanRfc2821(EmailAddressTest.java:49)" + }, + { + path: + 'tests/email/src/test/java/action/surefire/report/email/EmailAddressTest.java', + start_line: 57, + end_line: 57, + start_column: 0, + end_column: 0, + annotation_level: 'failure', + title: 'EmailAddressTest.shouldBeStricterThanRfc2822', + message: 'Address aba@bab.com should have thrown InvalidEmailAddressException', + raw_details: + 'java.lang.AssertionError: Address aba@bab.com should have thrown InvalidEmailAddressException\n\tat action.surefire.report.email.EmailAddressTest.expectException(EmailAddressTest.java:75)\n\tat action.surefire.report.email.EmailAddressTest.shouldBeStricterThanRfc2822(EmailAddressTest.java:57)' + }, + { + path: + 'tests/email/src/test/java/action/surefire/report/email/EmailAddressTest.java', + start_line: 18, + end_line: 18, + start_column: 0, + end_column: 0, + annotation_level: 'failure', + title: 'EmailAddressTest.shouldNotBeBlank', + message: 'Email address must not be null, empty, or blanks', + raw_details: + 'action.surefire.report.email.InvalidEmailAddressException: Email address must not be null, empty, or blanks\n\tat action.surefire.report.email.EmailAddressTest.expectException(EmailAddressTest.java:74)\n\tat action.surefire.report.email.EmailAddressTest.shouldNotBeBlank(EmailAddressTest.java:18)' + }, + { + path: + 'tests/email/src/test/java/action/surefire/report/email/EmailAddressTest.java', + start_line: 32, + end_line: 32, + start_column: 0, + end_column: 0, + annotation_level: 'failure', + title: 'EmailAddressTest.shouldNotContainLocalHosts', + message: "Invalid email address 'user@host'", + raw_details: + "action.surefire.report.email.InvalidEmailAddressException: Invalid email address 'user@host'\n\tat action.surefire.report.email.EmailAddressTest.expectException(EmailAddressTest.java:74)\n\tat action.surefire.report.email.EmailAddressTest.shouldNotContainLocalHosts(EmailAddressTest.java:32)" + }, + { + path: + 'tests/email/src/test/java/action/surefire/report/email/EmailAddressTest.java', + start_line: 25, + end_line: 25, + start_column: 0, + end_column: 0, + annotation_level: 'failure', + title: 'EmailAddressTest.shouldNotMissComponents', + message: + 'Address user-without-host@test.com should have thrown InvalidEmailAddressException', + raw_details: + 'java.lang.AssertionError: Address user-without-host@test.com should have thrown InvalidEmailAddressException\n\tat action.surefire.report.email.EmailAddressTest.expectException(EmailAddressTest.java:75)\n\tat action.surefire.report.email.EmailAddressTest.shouldNotMissComponents(EmailAddressTest.java:25)' + }, + { + path: + 'tests/email/src/test/java/action/surefire/report/email/EmailAddressTest.java', + start_line: 66, + end_line: 66, + start_column: 0, + end_column: 0, + annotation_level: 'failure', + title: 'EmailAddressTest.shouldNotAllowDotsInWeirdPlaces', + message: "Invalid email address '.user@host.com'", + raw_details: + "action.surefire.report.email.InvalidEmailAddressException: Invalid email address '.user@host.com'\n\tat action.surefire.report.email.EmailAddressTest.expectException(EmailAddressTest.java:74)\n\tat action.surefire.report.email.EmailAddressTest.shouldNotAllowDotsInWeirdPlaces(EmailAddressTest.java:66)" + }, + { + path: + 'tests/evil_twins/src/test/java/action/surefire/report/twin/second/TwinTest.java', + start_line: 13, + end_line: 13, + start_column: 0, + end_column: 0, + annotation_level: 'failure', + title: 'TwinTest.should_always_fail', + message: "Expected: \"Good Twin\"\n but: was \"Evil Twin\"", + raw_details: + "java.lang.AssertionError: \n\nExpected: \"Good Twin\"\n but: was \"Evil Twin\"\n\tat action.surefire.report.twin.second.TwinTest.should_always_fail(TwinTest.java:13)" + }, + { + path: 'tests/utils/src/test/java/action/surefire/report/calc/CalcUtilsTest.kt', + start_line: 27, + end_line: 27, + start_column: 0, + end_column: 0, + annotation_level: 'failure', + title: 'CalcUtilsTest.test error handling', + message: + 'unexpected exception type thrown; expected: but was:', + raw_details: + 'java.lang.AssertionError: unexpected exception type thrown; expected: but was:\n\tat action.surefire.report.calc.CalcUtilsTest.test error handling(CalcUtilsTest.kt:27)\nCaused by: java.lang.IllegalArgumentException: Amount must have max 2 non-zero decimal places\n\tat action.surefire.report.calc.CalcUtilsTest.scale(CalcUtilsTest.kt:31)\n\tat action.surefire.report.calc.CalcUtilsTest.access$scale(CalcUtilsTest.kt:9)\n\tat action.surefire.report.calc.CalcUtilsTest.test error handling(CalcUtilsTest.kt:27)' + }, + { + path: 'tests/utils/src/test/java/action/surefire/report/calc/CalcUtilsTest.kt', + start_line: 15, + end_line: 15, + start_column: 0, + end_column: 0, + annotation_level: 'failure', + title: 'CalcUtilsTest.test scale', + message: 'Expected: <100.10>\n but: was <100.11>', + raw_details: + 'java.lang.AssertionError: \n\nExpected: <100.10>\n but: was <100.11>\n\tat action.surefire.report.calc.CalcUtilsTest.test scale(CalcUtilsTest.kt:15)' + }, + { + path: 'tests/utils/src/test/java/action/surefire/report/calc/StringUtilsTest.java', + start_line: 27, + end_line: 27, + start_column: 0, + end_column: 0, + annotation_level: 'failure', + title: 'StringUtilsTest.require_fail', + message: + 'Expected: (an instance of java.lang.IllegalArgumentException and exception with message a string containing "This is unexpected")\n but: exception with message a string containing "This is unexpected" message was "Input=\'\' didn\'t match condition."\nStacktrace was: java.lang.IllegalArgumentException: Input=\'\' didn\'t match condition.\n at action.surefire.report.calc.StringUtils.requireNotBlank(StringUtils.java:25)\n at action.surefire.report.calc.StringUtils.requireNotBlank(StringUtils.java:18)\n at action.surefire.report.calc.StringUtilsTest.require_fail(StringUtilsTest.java:27)\n at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)\n at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)\n at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)\n at java.lang.reflect.Method.invoke(Method.java:498)\n at org.junit.runners.model.FrameworkMethod$1.runReflectiveCall(FrameworkMethod.java:59)\n at org.junit.internal.runners.model.ReflectiveCallable.run(ReflectiveCallable.java:12)\n at org.junit.runners.model.FrameworkMethod.invokeExplosively(FrameworkMethod.java:56)\n at org.junit.internal.runners.statements.InvokeMethod.evaluate(InvokeMethod.java:17)\n at org.junit.rules.ExpectedException$ExpectedExceptionStatement.evaluate(ExpectedException.java:258)\n at org.junit.runners.ParentRunner$3.evaluate(ParentRunner.java:306)\n at org.junit.runners.BlockJUnit4ClassRunner$1.evaluate(BlockJUnit4ClassRunner.java:100)\n at org.junit.runners.ParentRunner.runLeaf(ParentRunner.java:366)\n at org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:103)\n at org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:63)\n at org.junit.runners.ParentRunner$4.run(ParentRunner.java:331)\n at org.junit.runners.ParentRunner$1.schedule(ParentRunner.java:79)\n at org.junit.runners.ParentRunner.runChildren(ParentRunner.java:329)\n at org.junit.runners.ParentRunner.access$100(ParentRunner.java:66)\n at org.junit.runners.ParentRunner$2.evaluate(ParentRunner.java:293)\n at org.junit.runners.ParentRunner$3.evaluate(ParentRunner.java:306)\n at org.junit.runners.ParentRunner.run(ParentRunner.java:413)\n at org.apache.maven.surefire.junit4.JUnit4Provider.execute(JUnit4Provider.java:365)\n at org.apache.maven.surefire.junit4.JUnit4Provider.executeWithRerun(JUnit4Provider.java:273)\n at org.apache.maven.surefire.junit4.JUnit4Provider.executeTestSet(JUnit4Provider.java:238)\n at org.apache.maven.surefire.junit4.JUnit4Provider.invoke(JUnit4Provider.java:159)\n at org.apache.maven.surefire.booter.ForkedBooter.invokeProviderInSameClassLoader(ForkedBooter.java:384)\n at org.apache.maven.surefire.booter.ForkedBooter.runSuitesInProcess(ForkedBooter.java:345)\n at org.apache.maven.surefire.booter.ForkedBooter.execute(ForkedBooter.java:126)\n at org.apache.maven.surefire.booter.ForkedBooter.main(ForkedBooter.java:418)', + raw_details: + 'java.lang.AssertionError: \n\nExpected: (an instance of java.lang.IllegalArgumentException and exception with message a string containing "This is unexpected")\n but: exception with message a string containing "This is unexpected" message was "Input=\'\' didn\'t match condition."\nStacktrace was: java.lang.IllegalArgumentException: Input=\'\' didn\'t match condition.\n\tat action.surefire.report.calc.StringUtils.requireNotBlank(StringUtils.java:25)\n\tat action.surefire.report.calc.StringUtils.requireNotBlank(StringUtils.java:18)\n\tat action.surefire.report.calc.StringUtilsTest.require_fail(StringUtilsTest.java:27)\n\tat sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)\n\tat sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)\n\tat sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)\n\tat java.lang.reflect.Method.invoke(Method.java:498)\n\tat org.junit.runners.model.FrameworkMethod$1.runReflectiveCall(FrameworkMethod.java:59)\n\tat org.junit.internal.runners.model.ReflectiveCallable.run(ReflectiveCallable.java:12)\n\tat org.junit.runners.model.FrameworkMethod.invokeExplosively(FrameworkMethod.java:56)\n\tat org.junit.internal.runners.statements.InvokeMethod.evaluate(InvokeMethod.java:17)\n\tat org.junit.rules.ExpectedException$ExpectedExceptionStatement.evaluate(ExpectedException.java:258)\n\tat org.junit.runners.ParentRunner$3.evaluate(ParentRunner.java:306)\n\tat org.junit.runners.BlockJUnit4ClassRunner$1.evaluate(BlockJUnit4ClassRunner.java:100)\n\tat org.junit.runners.ParentRunner.runLeaf(ParentRunner.java:366)\n\tat org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:103)\n\tat org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:63)\n\tat org.junit.runners.ParentRunner$4.run(ParentRunner.java:331)\n\tat org.junit.runners.ParentRunner$1.schedule(ParentRunner.java:79)\n\tat org.junit.runners.ParentRunner.runChildren(ParentRunner.java:329)\n\tat org.junit.runners.ParentRunner.access$100(ParentRunner.java:66)\n\tat org.junit.runners.ParentRunner$2.evaluate(ParentRunner.java:293)\n\tat org.junit.runners.ParentRunner$3.evaluate(ParentRunner.java:306)\n\tat org.junit.runners.ParentRunner.run(ParentRunner.java:413)\n\tat org.apache.maven.surefire.junit4.JUnit4Provider.execute(JUnit4Provider.java:365)\n\tat org.apache.maven.surefire.junit4.JUnit4Provider.executeWithRerun(JUnit4Provider.java:273)\n\tat org.apache.maven.surefire.junit4.JUnit4Provider.executeTestSet(JUnit4Provider.java:238)\n\tat org.apache.maven.surefire.junit4.JUnit4Provider.invoke(JUnit4Provider.java:159)\n\tat org.apache.maven.surefire.booter.ForkedBooter.invokeProviderInSameClassLoader(ForkedBooter.java:384)\n\tat org.apache.maven.surefire.booter.ForkedBooter.runSuitesInProcess(ForkedBooter.java:345)\n\tat org.apache.maven.surefire.booter.ForkedBooter.execute(ForkedBooter.java:126)\n\tat org.apache.maven.surefire.booter.ForkedBooter.main(ForkedBooter.java:418)' + }, + { + path: 'tests/utils/src/test/java/action/surefire/report/calc/StringUtilsTest.java', + start_line: 20, + end_line: 20, + start_column: 0, + end_column: 0, + annotation_level: 'failure', + title: 'StringUtilsTest.require', + message: + 'java.lang.AssertionError\n\tat action.surefire.report.calc.StringUtilsTest.require(StringUtilsTest.java:20)', + raw_details: + 'java.lang.AssertionError\n\tat action.surefire.report.calc.StringUtilsTest.require(StringUtilsTest.java:20)' + } + ] + } +}; + +const finishedSuccess = { + name: 'Test Report', + head_sha: 'sha123', + status: 'completed', + conclusion: 'success', + output: { + title: '1 tests run, 0 skipped, 0 failed.', + summary: '', + annotations: [] + } +}; + +const masterSuccess = { + name: 'Test Report', + head_sha: 'masterSha123', + status: 'completed', + conclusion: 'success', + output: { + title: '1 tests run, 0 skipped, 0 failed.', + summary: '', + annotations: [] + } +}; + +const nothingFound = { + name: 'Test Report', + head_sha: 'sha123', + status: 'completed', + conclusion: 'failure', + output: { + title: 'No test results found!', + summary: '', + annotations: [] + } +}; + +const nothingFoundButSuccess = { + name: 'Test Report', + head_sha: 'sha123', + status: 'completed', + conclusion: 'success', + output: { + title: 'No test results found!', + summary: '', + annotations: [] + } +}; + +module.exports = { + finishedWithFailures, + finishedSuccess, + nothingFound, + nothingFoundButSuccess, + masterSuccess +}; diff --git a/action-surefire-report/action.test.js b/action-surefire-report/action.test.js new file mode 100644 index 0000000..5c1bd97 --- /dev/null +++ b/action-surefire-report/action.test.js @@ -0,0 +1,239 @@ +const core = require('@actions/core'); +const github = require('@actions/github'); +const nock = require('nock'); +const action = require('./action'); +const { + finishedWithFailures, + finishedSuccess, + nothingFound, + nothingFoundButSuccess, + masterSuccess +} = require('./action.test.fixtures'); + +jest.setTimeout(20000); + +let inputs; +let outputs; +let failed; + +beforeEach(() => { + inputs = {}; + outputs = {}; + failed = null; +}); + +describe('action should work', () => { + beforeAll(() => { + // https://github.com/actions/checkout/blob/v2.1.0/__test__/input-helper.test.ts + jest.spyOn(core, 'getInput').mockImplementation(name => { + return inputs[name]; + }); + + jest.spyOn(core, 'setOutput').mockImplementation((name, value) => { + outputs[name] = value; + }); + + jest.spyOn(core, 'setFailed').mockImplementation(reason => { + failed = reason; + }); + + jest.spyOn(core, 'error').mockImplementation(jest.fn()); + jest.spyOn(core, 'warning').mockImplementation(jest.fn()); + jest.spyOn(core, 'info').mockImplementation(jest.fn()); + jest.spyOn(core, 'debug').mockImplementation(jest.fn()); + + github.context.payload.pull_request = { + id: 1, + html_url: 'https://github.com/scacap/action-surefire-report', + head: { sha: 'sha123' } + }; + + jest.spyOn(github.context, 'repo', 'get').mockImplementation(() => { + return { + owner: 'scacap', + repo: 'action-surefire-report' + }; + }); + }); + + beforeEach(() => { + // Reset inputs + inputs = { + report_paths: '**/surefire-reports/TEST-*.xml, **/failsafe-reports/TEST-*.xml', + github_token: 'GITHUB_TOKEN', + check_name: 'Test Report', + fail_if_no_tests: 'true', + skip_publishing: 'false' + }; + + // Reset outputs + outputs = {}; + }); + + afterAll(() => { + jest.restoreAllMocks(); + }); + + it('should parse surefire reports and send a check run to GitHub', async () => { + let request = null; + const scope = nock('https://api.github.com') + .post('/repos/scacap/action-surefire-report/check-runs', body => { + request = body; + return body; + }) + .reply(200, {}); + await action(); + scope.done(); + + expect(request).toStrictEqual(finishedWithFailures); + expect(outputs).toHaveProperty('conclusion', 'failure'); + expect(failed).toBeNull(); + }); + + it('should send all ok if no tests were broken', async () => { + inputs.report_paths = '**/surefire-reports/TEST-*AllOkTest.xml'; + let request = null; + const scope = nock('https://api.github.com') + .post('/repos/scacap/action-surefire-report/check-runs', body => { + request = body; + return body; + }) + .reply(200, {}); + await action(); + scope.done(); + + expect(request).toStrictEqual(finishedSuccess); + expect(outputs).toHaveProperty('conclusion', 'success'); + expect(failed).toBeNull(); + }); + + it('should send failure if no test results were found', async () => { + inputs.report_paths = '**/xxx/*.xml'; + let request = null; + const scope = nock('https://api.github.com') + .post('/repos/scacap/action-surefire-report/check-runs', body => { + request = body; + return body; + }) + .reply(200, {}); + await action(); + scope.done(); + + expect(request).toStrictEqual(nothingFound); + expect(outputs).toHaveProperty('conclusion', 'failure'); + }); + + it('should send OK if no test results were found and fail_if_no_tests is false', async () => { + inputs.report_paths = '**/xxx/*.xml'; + inputs.fail_if_no_tests = 'false'; + let request = null; + const scope = nock('https://api.github.com') + .post('/repos/scacap/action-surefire-report/check-runs', body => { + request = body; + return body; + }) + .reply(200, {}); + await action(); + scope.done(); + + expect(request).toStrictEqual(nothingFoundButSuccess); + expect(outputs).toHaveProperty('conclusion', 'success'); + }); + + it('should send reports to sha if no pr detected', async () => { + inputs.report_paths = '**/surefire-reports/TEST-*AllOkTest.xml'; + github.context.payload.pull_request = undefined; + github.context.sha = 'masterSha123'; + github.context.ref = 'refs/heads/master'; + + let request = null; + const scope = nock('https://api.github.com') + .post('/repos/scacap/action-surefire-report/check-runs', body => { + request = body; + return body; + }) + .reply(200, {}); + await action(); + scope.done(); + + expect(request).toStrictEqual(masterSuccess); + }); + + it('should not send report on skip_publishing', async () => { + inputs.skip_publishing = 'true'; + + // nock error if the request is sent + + await action(); + }); + + describe('with option fail_on_test_failures', () => { + it('should not fail on success', async () => { + inputs.report_paths = '**/surefire-reports/TEST-*AllOkTest.xml'; + + const scope = nock('https://api.github.com') + .post('/repos/scacap/action-surefire-report/check-runs') + .reply(200, {}); + + inputs['fail_on_test_failures'] = 'true'; + await action(); + scope.done(); + + expect(failed).toBeNull(); + }); + + it('should fail on failures', async () => { + const scope = nock('https://api.github.com') + .post('/repos/scacap/action-surefire-report/check-runs') + .reply(200, {}); + + inputs['fail_on_test_failures'] = 'true'; + await action(); + scope.done(); + + expect(failed).toBe('There were 12 failed tests'); + }); + }); + + describe('with option create_check=false', () => { + it('should parse surefire reports and update a check run', async () => { + inputs.create_check = 'false'; + inputs.check_name = 'build'; + github.context.sha = 'sha123'; + github.context.job = 'build' + + let request = null; + const getRuns = nock('https://api.github.com') + .get('/repos/scacap/action-surefire-report/commits/sha123/check-runs?check_name=build&status=in_progress') + .reply(200, { + check_runs: [ + { + id: 123, + output: { + title: finishedWithFailures.output.title, + summary: finishedWithFailures.output.summary + }, + pull_requests: [ + { + id: 1 + } + ] + } + ] + }); + const patchRun = nock('https://api.github.com') + .patch('/repos/scacap/action-surefire-report/check-runs/123', body => { + request = body; + return body; + }) + .reply(200, {}); + await action(); + getRuns.done(); + patchRun.done(); + + expect(request).toStrictEqual({output: finishedWithFailures.output}); + expect(outputs).toHaveProperty('conclusion', 'failure'); + expect(failed).toBeNull(); + }); + }); +}); diff --git a/action-surefire-report/action.yml b/action-surefire-report/action.yml new file mode 100644 index 0000000..a6d9dc5 --- /dev/null +++ b/action-surefire-report/action.yml @@ -0,0 +1,53 @@ +name: 'Surefire Report' +description: 'Report Surefire test results as annotations on Github Pull Request [junit, failsafe]' +branding: + icon: 'check-square' + color: 'green' +inputs: + github_token: + description: 'GITHUB_TOKEN' + required: true + default: ${{ github.token }} + report_paths: + description: 'surefire/failsafe/junit compatible xml report paths in glob format' + required: false + default: '**/surefire-reports/TEST-*.xml, **/failsafe-reports/TEST-*.xml' + create_check: + description: 'create a new check with annotations' + required: false + default: 'true' + check_name: + description: 'check name for test reports' + required: false + default: 'Test Report' + commit: + description: 'commit sha to update the status' + required: false + fail_on_test_failures: + description: 'fail run if there were test failures' + required: false + default: 'false' + fail_if_no_tests: + description: 'fail run if there were no test results found' + required: false + default: 'true' + skip_publishing: + description: 'skip test report publishing' + required: false + default: 'false' + file_name_in_stack_trace: + description: 'get filename from stack trace' + required: false + default: 'false' + github_base_url: + description: 'if you use Github Enterprise, you can set this to the URL of your server (e.g. https://github.myorg.com/api/v3)' + required: false + default: "" + +outputs: + outcome: + description: 'the test outcome, either `success` or `failure`' + +runs: + using: 'docker' + image: 'Dockerfile' diff --git a/action-surefire-report/custom_reports/TEST-pro.taskana.common.api.ListUtilTest-H2.xml b/action-surefire-report/custom_reports/TEST-pro.taskana.common.api.ListUtilTest-H2.xml new file mode 100644 index 0000000..ef4c285 --- /dev/null +++ b/action-surefire-report/custom_reports/TEST-pro.taskana.common.api.ListUtilTest-H2.xml @@ -0,0 +1,39 @@ + + + + but was:<10> in: +<[[1, + 2, + 3, + 4, + 5, + 6, + 7, + 96, + 97, + 98, + 99, + 100], + [101, + 102, + 103, + 104, + 194, + 195, + 196, + 197, + 198, + 199, + 200], + [201, + 202, + 997, + 998, + 999, + 1000]]]]> + at pro.taskana.common.api.ListUtilTest.should_SplitListIntoChunks_When_CallingPartitionBasedOnSize(ListUtilTest.java:22) +]]> + + \ No newline at end of file diff --git a/action-surefire-report/custom_reports/TEST-test.MyIntegrationTestSuite.xml b/action-surefire-report/custom_reports/TEST-test.MyIntegrationTestSuite.xml new file mode 100644 index 0000000..f94613c --- /dev/null +++ b/action-surefire-report/custom_reports/TEST-test.MyIntegrationTestSuite.xml @@ -0,0 +1,47 @@ + + + + + java.lang.AssertionError: +JSON path "$.mails[0].subject" +Expected: "MySubject" + but: was "YourSubject" + at test.MyIntegrationTest.testGetMails(MyIntegrationTest.java:43) + + + + + + but was:<403> + at test.DocumentUploadIntegrationTest.shouldReturnBadRequestIfDocumentTypeIsInvalid(DocumentUploadIntegrationTest.java:33) +]]> + + + + + but was:<403> + at test.DocumentUploadIntegrationTest.shouldReturnSuccessResponse(DocumentUploadIntegrationTest.java:23) +]]> + + + + + but was:<403> + at test.DocumentUploadIntegrationTest.shouldReturnBadRequestIfDocumentSizeIsZero(DocumentUploadIntegrationTest.java:47) +]]> + + + + \ No newline at end of file diff --git a/action-surefire-report/dist/build/Release/xmljs.node b/action-surefire-report/dist/build/Release/xmljs.node new file mode 100755 index 0000000000000000000000000000000000000000..1573f98e723a0dce207da76f6e04003180d12917 GIT binary patch literal 1840416 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 z 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 GjOAO~CR}jcQCH^wv)r)mr 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≪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

Nq;V8(`Q@|bJb#<+ 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 literal 0 HcmV?d00001 diff --git a/action-surefire-report/dist/index.js b/action-surefire-report/dist/index.js new file mode 100644 index 0000000..606eb3c --- /dev/null +++ b/action-surefire-report/dist/index.js @@ -0,0 +1,16831 @@ +/******/ (() => { // webpackBootstrap +/******/ var __webpack_modules__ = ({ + +/***/ 4582: +/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { + +const core = __nccwpck_require__(2186); +const github = __nccwpck_require__(5438); +const { Octokit } = __nccwpck_require__(5375); +const { retry } = __nccwpck_require__(6298); +const RetryingOctokit = Octokit.plugin(retry); +const { parseTestReports } = __nccwpck_require__(1252); + + +const action = async () => { + const reportPaths = core.getInput('report_paths').split(',').join('\n'); + core.info(`Going to parse results form ${reportPaths}`); + const githubToken = core.getInput('github_token'); + const createCheck = (core.getInput('create_check') || 'true') === 'true'; + const name = core.getInput('check_name'); + const commit = core.getInput('commit'); + const failOnFailedTests = core.getInput('fail_on_test_failures') === 'true'; + const failIfNoTests = core.getInput('fail_if_no_tests') === 'true'; + const skipPublishing = core.getInput('skip_publishing') === 'true'; + const isFilenameInStackTrace = core.getInput('file_name_in_stack_trace') === 'true'; + const githubBaseUrl = core.getInput('github_base_url'); + + let { count, skipped, annotations } = await parseTestReports(reportPaths, isFilenameInStackTrace); + const foundResults = count > 0 || skipped > 0; + const conclusion = + (foundResults && annotations.length === 0) || (!foundResults && !failIfNoTests) + ? 'success' + : 'failure'; + + function buildRetryingOctokitClient() { + const baseRequest = { auth: githubToken, request: { retries: 3 } }; + + if (githubBaseUrl){ + baseRequest.baseUrl = githubBaseUrl; + } + + return new RetryingOctokit(baseRequest) + } + + if (!skipPublishing) { + const title = foundResults + ? `${count} tests run, ${skipped} skipped, ${annotations.length} failed.` + : 'No test results found!'; + core.info(`Result: ${title}`); + + const pullRequest = github.context.payload.pull_request; + const link = (pullRequest && pullRequest.html_url) || github.context.ref; + const status = 'completed'; + const head_sha = commit || (pullRequest && pullRequest.head.sha) || github.context.sha; + + const octokit = buildRetryingOctokitClient(); + if (createCheck) { + core.info(`Posting status '${status}' with conclusion '${conclusion}' to ${link} (sha: ${head_sha})`); + const createCheckRequest = { + ...github.context.repo, + name, + head_sha, + status, + conclusion, + output: { + title, + summary: '', + annotations: annotations.slice(0, 50) + } + }; + + core.debug(JSON.stringify(createCheckRequest, null, 2)); + + await octokit.rest.checks.create(createCheckRequest); + } else { + const { data: {check_runs: check_runs} } = await octokit.rest.checks.listForRef({ + ...github.context.repo, + check_name: name, + ref: head_sha, + status: 'in_progress' + }) + core.debug(JSON.stringify(check_runs, null, 2)); + if (check_runs.length === 0) { + core.setFailed(`Did not find any in progress '${name}' check for sha ${head_sha}`); + return; + } + if (check_runs.length !== 1) { + core.setFailed(`Found multiple in progress '${name}' checks for sha ${head_sha}`); + return; + } + const check_run = check_runs[0]; + core.info(`Patching '${name}' check for ${link} (sha: ${head_sha})`); + const updateCheckRequest = { + ...github.context.repo, + check_run_id: check_run.id, + output: { + title: check_run.output.title || title, + summary: check_run.output.summary || '', + annotations: annotations.slice(0, 50) + } + }; + + core.debug(JSON.stringify(updateCheckRequest, null, 2)); + + await octokit.rest.checks.update(updateCheckRequest); + } + } else { + core.info('Not publishing test result due to skip_publishing=true'); + } + + // make conclusion consumable by downstream actions + core.setOutput('conclusion', conclusion); + + // optionally fail the action if tests fail + if (failOnFailedTests && conclusion !== 'success') { + core.setFailed(`There were ${annotations.length} failed tests`); + } +}; + +module.exports = action; + + +/***/ }), + +/***/ 7351: +/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { + +"use strict"; + +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } }); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); +}) : function(o, v) { + o["default"] = v; +}); +var __importStar = (this && this.__importStar) || function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k in mod) if (k !== "default" && Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k); + __setModuleDefault(result, mod); + return result; +}; +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.issue = exports.issueCommand = void 0; +const os = __importStar(__nccwpck_require__(2037)); +const utils_1 = __nccwpck_require__(5278); +/** + * Commands + * + * Command Format: + * ::name key=value,key=value::message + * + * Examples: + * ::warning::This is the message + * ::set-env name=MY_VAR::some value + */ +function issueCommand(command, properties, message) { + const cmd = new Command(command, properties, message); + process.stdout.write(cmd.toString() + os.EOL); +} +exports.issueCommand = issueCommand; +function issue(name, message = '') { + issueCommand(name, {}, message); +} +exports.issue = issue; +const CMD_STRING = '::'; +class Command { + constructor(command, properties, message) { + if (!command) { + command = 'missing.command'; + } + this.command = command; + this.properties = properties; + this.message = message; + } + toString() { + let cmdStr = CMD_STRING + this.command; + if (this.properties && Object.keys(this.properties).length > 0) { + cmdStr += ' '; + let first = true; + for (const key in this.properties) { + if (this.properties.hasOwnProperty(key)) { + const val = this.properties[key]; + if (val) { + if (first) { + first = false; + } + else { + cmdStr += ','; + } + cmdStr += `${key}=${escapeProperty(val)}`; + } + } + } + } + cmdStr += `${CMD_STRING}${escapeData(this.message)}`; + return cmdStr; + } +} +function escapeData(s) { + return utils_1.toCommandValue(s) + .replace(/%/g, '%25') + .replace(/\r/g, '%0D') + .replace(/\n/g, '%0A'); +} +function escapeProperty(s) { + return utils_1.toCommandValue(s) + .replace(/%/g, '%25') + .replace(/\r/g, '%0D') + .replace(/\n/g, '%0A') + .replace(/:/g, '%3A') + .replace(/,/g, '%2C'); +} +//# sourceMappingURL=command.js.map + +/***/ }), + +/***/ 2186: +/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { + +"use strict"; + +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } }); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); +}) : function(o, v) { + o["default"] = v; +}); +var __importStar = (this && this.__importStar) || function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k in mod) if (k !== "default" && Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k); + __setModuleDefault(result, mod); + return result; +}; +var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { + function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); } + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +}; +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.getIDToken = exports.getState = exports.saveState = exports.group = exports.endGroup = exports.startGroup = exports.info = exports.notice = exports.warning = exports.error = exports.debug = exports.isDebug = exports.setFailed = exports.setCommandEcho = exports.setOutput = exports.getBooleanInput = exports.getMultilineInput = exports.getInput = exports.addPath = exports.setSecret = exports.exportVariable = exports.ExitCode = void 0; +const command_1 = __nccwpck_require__(7351); +const file_command_1 = __nccwpck_require__(717); +const utils_1 = __nccwpck_require__(5278); +const os = __importStar(__nccwpck_require__(2037)); +const path = __importStar(__nccwpck_require__(1017)); +const oidc_utils_1 = __nccwpck_require__(8041); +/** + * The code to exit an action + */ +var ExitCode; +(function (ExitCode) { + /** + * A code indicating that the action was successful + */ + ExitCode[ExitCode["Success"] = 0] = "Success"; + /** + * A code indicating that the action was a failure + */ + ExitCode[ExitCode["Failure"] = 1] = "Failure"; +})(ExitCode = exports.ExitCode || (exports.ExitCode = {})); +//----------------------------------------------------------------------- +// Variables +//----------------------------------------------------------------------- +/** + * Sets env variable for this action and future actions in the job + * @param name the name of the variable to set + * @param val the value of the variable. Non-string values will be converted to a string via JSON.stringify + */ +// eslint-disable-next-line @typescript-eslint/no-explicit-any +function exportVariable(name, val) { + const convertedVal = utils_1.toCommandValue(val); + process.env[name] = convertedVal; + const filePath = process.env['GITHUB_ENV'] || ''; + if (filePath) { + return file_command_1.issueFileCommand('ENV', file_command_1.prepareKeyValueMessage(name, val)); + } + command_1.issueCommand('set-env', { name }, convertedVal); +} +exports.exportVariable = exportVariable; +/** + * Registers a secret which will get masked from logs + * @param secret value of the secret + */ +function setSecret(secret) { + command_1.issueCommand('add-mask', {}, secret); +} +exports.setSecret = setSecret; +/** + * Prepends inputPath to the PATH (for this action and future actions) + * @param inputPath + */ +function addPath(inputPath) { + const filePath = process.env['GITHUB_PATH'] || ''; + if (filePath) { + file_command_1.issueFileCommand('PATH', inputPath); + } + else { + command_1.issueCommand('add-path', {}, inputPath); + } + process.env['PATH'] = `${inputPath}${path.delimiter}${process.env['PATH']}`; +} +exports.addPath = addPath; +/** + * Gets the value of an input. + * Unless trimWhitespace is set to false in InputOptions, the value is also trimmed. + * Returns an empty string if the value is not defined. + * + * @param name name of the input to get + * @param options optional. See InputOptions. + * @returns string + */ +function getInput(name, options) { + const val = process.env[`INPUT_${name.replace(/ /g, '_').toUpperCase()}`] || ''; + if (options && options.required && !val) { + throw new Error(`Input required and not supplied: ${name}`); + } + if (options && options.trimWhitespace === false) { + return val; + } + return val.trim(); +} +exports.getInput = getInput; +/** + * Gets the values of an multiline input. Each value is also trimmed. + * + * @param name name of the input to get + * @param options optional. See InputOptions. + * @returns string[] + * + */ +function getMultilineInput(name, options) { + const inputs = getInput(name, options) + .split('\n') + .filter(x => x !== ''); + if (options && options.trimWhitespace === false) { + return inputs; + } + return inputs.map(input => input.trim()); +} +exports.getMultilineInput = getMultilineInput; +/** + * Gets the input value of the boolean type in the YAML 1.2 "core schema" specification. + * Support boolean input list: `true | True | TRUE | false | False | FALSE` . + * The return value is also in boolean type. + * ref: https://yaml.org/spec/1.2/spec.html#id2804923 + * + * @param name name of the input to get + * @param options optional. See InputOptions. + * @returns boolean + */ +function getBooleanInput(name, options) { + const trueValue = ['true', 'True', 'TRUE']; + const falseValue = ['false', 'False', 'FALSE']; + const val = getInput(name, options); + if (trueValue.includes(val)) + return true; + if (falseValue.includes(val)) + return false; + throw new TypeError(`Input does not meet YAML 1.2 "Core Schema" specification: ${name}\n` + + `Support boolean input list: \`true | True | TRUE | false | False | FALSE\``); +} +exports.getBooleanInput = getBooleanInput; +/** + * Sets the value of an output. + * + * @param name name of the output to set + * @param value value to store. Non-string values will be converted to a string via JSON.stringify + */ +// eslint-disable-next-line @typescript-eslint/no-explicit-any +function setOutput(name, value) { + const filePath = process.env['GITHUB_OUTPUT'] || ''; + if (filePath) { + return file_command_1.issueFileCommand('OUTPUT', file_command_1.prepareKeyValueMessage(name, value)); + } + process.stdout.write(os.EOL); + command_1.issueCommand('set-output', { name }, utils_1.toCommandValue(value)); +} +exports.setOutput = setOutput; +/** + * Enables or disables the echoing of commands into stdout for the rest of the step. + * Echoing is disabled by default if ACTIONS_STEP_DEBUG is not set. + * + */ +function setCommandEcho(enabled) { + command_1.issue('echo', enabled ? 'on' : 'off'); +} +exports.setCommandEcho = setCommandEcho; +//----------------------------------------------------------------------- +// Results +//----------------------------------------------------------------------- +/** + * Sets the action status to failed. + * When the action exits it will be with an exit code of 1 + * @param message add error issue message + */ +function setFailed(message) { + process.exitCode = ExitCode.Failure; + error(message); +} +exports.setFailed = setFailed; +//----------------------------------------------------------------------- +// Logging Commands +//----------------------------------------------------------------------- +/** + * Gets whether Actions Step Debug is on or not + */ +function isDebug() { + return process.env['RUNNER_DEBUG'] === '1'; +} +exports.isDebug = isDebug; +/** + * Writes debug message to user log + * @param message debug message + */ +function debug(message) { + command_1.issueCommand('debug', {}, message); +} +exports.debug = debug; +/** + * Adds an error issue + * @param message error issue message. Errors will be converted to string via toString() + * @param properties optional properties to add to the annotation. + */ +function error(message, properties = {}) { + command_1.issueCommand('error', utils_1.toCommandProperties(properties), message instanceof Error ? message.toString() : message); +} +exports.error = error; +/** + * Adds a warning issue + * @param message warning issue message. Errors will be converted to string via toString() + * @param properties optional properties to add to the annotation. + */ +function warning(message, properties = {}) { + command_1.issueCommand('warning', utils_1.toCommandProperties(properties), message instanceof Error ? message.toString() : message); +} +exports.warning = warning; +/** + * Adds a notice issue + * @param message notice issue message. Errors will be converted to string via toString() + * @param properties optional properties to add to the annotation. + */ +function notice(message, properties = {}) { + command_1.issueCommand('notice', utils_1.toCommandProperties(properties), message instanceof Error ? message.toString() : message); +} +exports.notice = notice; +/** + * Writes info to log with console.log. + * @param message info message + */ +function info(message) { + process.stdout.write(message + os.EOL); +} +exports.info = info; +/** + * Begin an output group. + * + * Output until the next `groupEnd` will be foldable in this group + * + * @param name The name of the output group + */ +function startGroup(name) { + command_1.issue('group', name); +} +exports.startGroup = startGroup; +/** + * End an output group. + */ +function endGroup() { + command_1.issue('endgroup'); +} +exports.endGroup = endGroup; +/** + * Wrap an asynchronous function call in a group. + * + * Returns the same type as the function itself. + * + * @param name The name of the group + * @param fn The function to wrap in the group + */ +function group(name, fn) { + return __awaiter(this, void 0, void 0, function* () { + startGroup(name); + let result; + try { + result = yield fn(); + } + finally { + endGroup(); + } + return result; + }); +} +exports.group = group; +//----------------------------------------------------------------------- +// Wrapper action state +//----------------------------------------------------------------------- +/** + * Saves state for current action, the state can only be retrieved by this action's post job execution. + * + * @param name name of the state to store + * @param value value to store. Non-string values will be converted to a string via JSON.stringify + */ +// eslint-disable-next-line @typescript-eslint/no-explicit-any +function saveState(name, value) { + const filePath = process.env['GITHUB_STATE'] || ''; + if (filePath) { + return file_command_1.issueFileCommand('STATE', file_command_1.prepareKeyValueMessage(name, value)); + } + command_1.issueCommand('save-state', { name }, utils_1.toCommandValue(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; +function getIDToken(aud) { + return __awaiter(this, void 0, void 0, function* () { + return yield oidc_utils_1.OidcClient.getIDToken(aud); + }); +} +exports.getIDToken = getIDToken; +/** + * Summary exports + */ +var summary_1 = __nccwpck_require__(1327); +Object.defineProperty(exports, "summary", ({ enumerable: true, get: function () { return summary_1.summary; } })); +/** + * @deprecated use core.summary + */ +var summary_2 = __nccwpck_require__(1327); +Object.defineProperty(exports, "markdownSummary", ({ enumerable: true, get: function () { return summary_2.markdownSummary; } })); +/** + * Path exports + */ +var path_utils_1 = __nccwpck_require__(2981); +Object.defineProperty(exports, "toPosixPath", ({ enumerable: true, get: function () { return path_utils_1.toPosixPath; } })); +Object.defineProperty(exports, "toWin32Path", ({ enumerable: true, get: function () { return path_utils_1.toWin32Path; } })); +Object.defineProperty(exports, "toPlatformPath", ({ enumerable: true, get: function () { return path_utils_1.toPlatformPath; } })); +//# sourceMappingURL=core.js.map + +/***/ }), + +/***/ 717: +/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { + +"use strict"; + +// For internal use, subject to change. +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } }); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); +}) : function(o, v) { + o["default"] = v; +}); +var __importStar = (this && this.__importStar) || function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k in mod) if (k !== "default" && Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k); + __setModuleDefault(result, mod); + return result; +}; +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.prepareKeyValueMessage = exports.issueFileCommand = void 0; +// We use any as a valid input type +/* eslint-disable @typescript-eslint/no-explicit-any */ +const fs = __importStar(__nccwpck_require__(7147)); +const os = __importStar(__nccwpck_require__(2037)); +const uuid_1 = __nccwpck_require__(5840); +const utils_1 = __nccwpck_require__(5278); +function issueFileCommand(command, message) { + const filePath = process.env[`GITHUB_${command}`]; + if (!filePath) { + throw new Error(`Unable to find environment variable for file command ${command}`); + } + if (!fs.existsSync(filePath)) { + throw new Error(`Missing file at path: ${filePath}`); + } + fs.appendFileSync(filePath, `${utils_1.toCommandValue(message)}${os.EOL}`, { + encoding: 'utf8' + }); +} +exports.issueFileCommand = issueFileCommand; +function prepareKeyValueMessage(key, value) { + const delimiter = `ghadelimiter_${uuid_1.v4()}`; + const convertedValue = utils_1.toCommandValue(value); + // These should realistically never happen, but just in case someone finds a + // way to exploit uuid generation let's not allow keys or values that contain + // the delimiter. + if (key.includes(delimiter)) { + throw new Error(`Unexpected input: name should not contain the delimiter "${delimiter}"`); + } + if (convertedValue.includes(delimiter)) { + throw new Error(`Unexpected input: value should not contain the delimiter "${delimiter}"`); + } + return `${key}<<${delimiter}${os.EOL}${convertedValue}${os.EOL}${delimiter}`; +} +exports.prepareKeyValueMessage = prepareKeyValueMessage; +//# sourceMappingURL=file-command.js.map + +/***/ }), + +/***/ 8041: +/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { + +"use strict"; + +var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { + function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); } + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +}; +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.OidcClient = void 0; +const http_client_1 = __nccwpck_require__(6255); +const auth_1 = __nccwpck_require__(5526); +const core_1 = __nccwpck_require__(2186); +class OidcClient { + static createHttpClient(allowRetry = true, maxRetry = 10) { + const requestOptions = { + allowRetries: allowRetry, + maxRetries: maxRetry + }; + return new http_client_1.HttpClient('actions/oidc-client', [new auth_1.BearerCredentialHandler(OidcClient.getRequestToken())], requestOptions); + } + static getRequestToken() { + const token = process.env['ACTIONS_ID_TOKEN_REQUEST_TOKEN']; + if (!token) { + throw new Error('Unable to get ACTIONS_ID_TOKEN_REQUEST_TOKEN env variable'); + } + return token; + } + static getIDTokenUrl() { + const runtimeUrl = process.env['ACTIONS_ID_TOKEN_REQUEST_URL']; + if (!runtimeUrl) { + throw new Error('Unable to get ACTIONS_ID_TOKEN_REQUEST_URL env variable'); + } + return runtimeUrl; + } + static getCall(id_token_url) { + var _a; + return __awaiter(this, void 0, void 0, function* () { + const httpclient = OidcClient.createHttpClient(); + const res = yield httpclient + .getJson(id_token_url) + .catch(error => { + throw new Error(`Failed to get ID Token. \n + Error Code : ${error.statusCode}\n + Error Message: ${error.result.message}`); + }); + const id_token = (_a = res.result) === null || _a === void 0 ? void 0 : _a.value; + if (!id_token) { + throw new Error('Response json body do not have ID Token field'); + } + return id_token; + }); + } + static getIDToken(audience) { + return __awaiter(this, void 0, void 0, function* () { + try { + // New ID Token is requested from action service + let id_token_url = OidcClient.getIDTokenUrl(); + if (audience) { + const encodedAudience = encodeURIComponent(audience); + id_token_url = `${id_token_url}&audience=${encodedAudience}`; + } + core_1.debug(`ID token url is ${id_token_url}`); + const id_token = yield OidcClient.getCall(id_token_url); + core_1.setSecret(id_token); + return id_token; + } + catch (error) { + throw new Error(`Error message: ${error.message}`); + } + }); + } +} +exports.OidcClient = OidcClient; +//# sourceMappingURL=oidc-utils.js.map + +/***/ }), + +/***/ 2981: +/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { + +"use strict"; + +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } }); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); +}) : function(o, v) { + o["default"] = v; +}); +var __importStar = (this && this.__importStar) || function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k in mod) if (k !== "default" && Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k); + __setModuleDefault(result, mod); + return result; +}; +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.toPlatformPath = exports.toWin32Path = exports.toPosixPath = void 0; +const path = __importStar(__nccwpck_require__(1017)); +/** + * toPosixPath converts the given path to the posix form. On Windows, \\ will be + * replaced with /. + * + * @param pth. Path to transform. + * @return string Posix path. + */ +function toPosixPath(pth) { + return pth.replace(/[\\]/g, '/'); +} +exports.toPosixPath = toPosixPath; +/** + * toWin32Path converts the given path to the win32 form. On Linux, / will be + * replaced with \\. + * + * @param pth. Path to transform. + * @return string Win32 path. + */ +function toWin32Path(pth) { + return pth.replace(/[/]/g, '\\'); +} +exports.toWin32Path = toWin32Path; +/** + * toPlatformPath converts the given path to a platform-specific path. It does + * this by replacing instances of / and \ with the platform-specific path + * separator. + * + * @param pth The path to platformize. + * @return string The platform-specific path. + */ +function toPlatformPath(pth) { + return pth.replace(/[/\\]/g, path.sep); +} +exports.toPlatformPath = toPlatformPath; +//# sourceMappingURL=path-utils.js.map + +/***/ }), + +/***/ 1327: +/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { + +"use strict"; + +var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { + function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); } + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +}; +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.summary = exports.markdownSummary = exports.SUMMARY_DOCS_URL = exports.SUMMARY_ENV_VAR = void 0; +const os_1 = __nccwpck_require__(2037); +const fs_1 = __nccwpck_require__(7147); +const { access, appendFile, writeFile } = fs_1.promises; +exports.SUMMARY_ENV_VAR = 'GITHUB_STEP_SUMMARY'; +exports.SUMMARY_DOCS_URL = 'https://docs.github.com/actions/using-workflows/workflow-commands-for-github-actions#adding-a-job-summary'; +class Summary { + constructor() { + this._buffer = ''; + } + /** + * Finds the summary file path from the environment, rejects if env var is not found or file does not exist + * Also checks r/w permissions. + * + * @returns step summary file path + */ + filePath() { + return __awaiter(this, void 0, void 0, function* () { + if (this._filePath) { + return this._filePath; + } + const pathFromEnv = process.env[exports.SUMMARY_ENV_VAR]; + if (!pathFromEnv) { + throw new Error(`Unable to find environment variable for $${exports.SUMMARY_ENV_VAR}. Check if your runtime environment supports job summaries.`); + } + try { + yield access(pathFromEnv, fs_1.constants.R_OK | fs_1.constants.W_OK); + } + catch (_a) { + throw new Error(`Unable to access summary file: '${pathFromEnv}'. Check if the file has correct read/write permissions.`); + } + this._filePath = pathFromEnv; + return this._filePath; + }); + } + /** + * Wraps content in an HTML tag, adding any HTML attributes + * + * @param {string} tag HTML tag to wrap + * @param {string | null} content content within the tag + * @param {[attribute: string]: string} attrs key-value list of HTML attributes to add + * + * @returns {string} content wrapped in HTML element + */ + wrap(tag, content, attrs = {}) { + const htmlAttrs = Object.entries(attrs) + .map(([key, value]) => ` ${key}="${value}"`) + .join(''); + if (!content) { + return `<${tag}${htmlAttrs}>`; + } + return `<${tag}${htmlAttrs}>${content}`; + } + /** + * Writes text in the buffer to the summary buffer file and empties buffer. Will append by default. + * + * @param {SummaryWriteOptions} [options] (optional) options for write operation + * + * @returns {Promise

} summary instance + */ + write(options) { + return __awaiter(this, void 0, void 0, function* () { + const overwrite = !!(options === null || options === void 0 ? void 0 : options.overwrite); + const filePath = yield this.filePath(); + const writeFunc = overwrite ? writeFile : appendFile; + yield writeFunc(filePath, this._buffer, { encoding: 'utf8' }); + return this.emptyBuffer(); + }); + } + /** + * Clears the summary buffer and wipes the summary file + * + * @returns {Summary} summary instance + */ + clear() { + return __awaiter(this, void 0, void 0, function* () { + return this.emptyBuffer().write({ overwrite: true }); + }); + } + /** + * Returns the current summary buffer as a string + * + * @returns {string} string of summary buffer + */ + stringify() { + return this._buffer; + } + /** + * If the summary buffer is empty + * + * @returns {boolen} true if the buffer is empty + */ + isEmptyBuffer() { + return this._buffer.length === 0; + } + /** + * Resets the summary buffer without writing to summary file + * + * @returns {Summary} summary instance + */ + emptyBuffer() { + this._buffer = ''; + return this; + } + /** + * Adds raw text to the summary buffer + * + * @param {string} text content to add + * @param {boolean} [addEOL=false] (optional) append an EOL to the raw text (default: false) + * + * @returns {Summary} summary instance + */ + addRaw(text, addEOL = false) { + this._buffer += text; + return addEOL ? this.addEOL() : this; + } + /** + * Adds the operating system-specific end-of-line marker to the buffer + * + * @returns {Summary} summary instance + */ + addEOL() { + return this.addRaw(os_1.EOL); + } + /** + * Adds an HTML codeblock to the summary buffer + * + * @param {string} code content to render within fenced code block + * @param {string} lang (optional) language to syntax highlight code + * + * @returns {Summary} summary instance + */ + addCodeBlock(code, lang) { + const attrs = Object.assign({}, (lang && { lang })); + const element = this.wrap('pre', this.wrap('code', code), attrs); + return this.addRaw(element).addEOL(); + } + /** + * Adds an HTML list to the summary buffer + * + * @param {string[]} items list of items to render + * @param {boolean} [ordered=false] (optional) if the rendered list should be ordered or not (default: false) + * + * @returns {Summary} summary instance + */ + addList(items, ordered = false) { + const tag = ordered ? 'ol' : 'ul'; + const listItems = items.map(item => this.wrap('li', item)).join(''); + const element = this.wrap(tag, listItems); + return this.addRaw(element).addEOL(); + } + /** + * Adds an HTML table to the summary buffer + * + * @param {SummaryTableCell[]} rows table rows + * + * @returns {Summary} summary instance + */ + addTable(rows) { + const tableBody = rows + .map(row => { + const cells = row + .map(cell => { + if (typeof cell === 'string') { + return this.wrap('td', cell); + } + const { header, data, colspan, rowspan } = cell; + const tag = header ? 'th' : 'td'; + const attrs = Object.assign(Object.assign({}, (colspan && { colspan })), (rowspan && { rowspan })); + return this.wrap(tag, data, attrs); + }) + .join(''); + return this.wrap('tr', cells); + }) + .join(''); + const element = this.wrap('table', tableBody); + return this.addRaw(element).addEOL(); + } + /** + * Adds a collapsable HTML details element to the summary buffer + * + * @param {string} label text for the closed state + * @param {string} content collapsable content + * + * @returns {Summary} summary instance + */ + addDetails(label, content) { + const element = this.wrap('details', this.wrap('summary', label) + content); + return this.addRaw(element).addEOL(); + } + /** + * Adds an HTML image tag to the summary buffer + * + * @param {string} src path to the image you to embed + * @param {string} alt text description of the image + * @param {SummaryImageOptions} options (optional) addition image attributes + * + * @returns {Summary} summary instance + */ + addImage(src, alt, options) { + const { width, height } = options || {}; + const attrs = Object.assign(Object.assign({}, (width && { width })), (height && { height })); + const element = this.wrap('img', null, Object.assign({ src, alt }, attrs)); + return this.addRaw(element).addEOL(); + } + /** + * Adds an HTML section heading element + * + * @param {string} text heading text + * @param {number | string} [level=1] (optional) the heading level, default: 1 + * + * @returns {Summary} summary instance + */ + addHeading(text, level) { + const tag = `h${level}`; + const allowedTag = ['h1', 'h2', 'h3', 'h4', 'h5', 'h6'].includes(tag) + ? tag + : 'h1'; + const element = this.wrap(allowedTag, text); + return this.addRaw(element).addEOL(); + } + /** + * Adds an HTML thematic break (
) to the summary buffer + * + * @returns {Summary} summary instance + */ + addSeparator() { + const element = this.wrap('hr', null); + return this.addRaw(element).addEOL(); + } + /** + * Adds an HTML line break (
) to the summary buffer + * + * @returns {Summary} summary instance + */ + addBreak() { + const element = this.wrap('br', null); + return this.addRaw(element).addEOL(); + } + /** + * Adds an HTML blockquote to the summary buffer + * + * @param {string} text quote text + * @param {string} cite (optional) citation url + * + * @returns {Summary} summary instance + */ + addQuote(text, cite) { + const attrs = Object.assign({}, (cite && { cite })); + const element = this.wrap('blockquote', text, attrs); + return this.addRaw(element).addEOL(); + } + /** + * Adds an HTML anchor tag to the summary buffer + * + * @param {string} text link text/content + * @param {string} href hyperlink + * + * @returns {Summary} summary instance + */ + addLink(text, href) { + const element = this.wrap('a', text, { href }); + return this.addRaw(element).addEOL(); + } +} +const _summary = new Summary(); +/** + * @deprecated use `core.summary` + */ +exports.markdownSummary = _summary; +exports.summary = _summary; +//# sourceMappingURL=summary.js.map + +/***/ }), + +/***/ 5278: +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + +// We use any as a valid input type +/* eslint-disable @typescript-eslint/no-explicit-any */ +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.toCommandProperties = exports.toCommandValue = void 0; +/** + * Sanitizes an input into a string so it can be passed into issueCommand safely + * @param input input to sanitize into a string + */ +function toCommandValue(input) { + if (input === null || input === undefined) { + return ''; + } + else if (typeof input === 'string' || input instanceof String) { + return input; + } + return JSON.stringify(input); +} +exports.toCommandValue = toCommandValue; +/** + * + * @param annotationProperties + * @returns The command properties to send with the actual annotation command + * See IssueCommandProperties: https://github.com/actions/runner/blob/main/src/Runner.Worker/ActionCommandManager.cs#L646 + */ +function toCommandProperties(annotationProperties) { + if (!Object.keys(annotationProperties).length) { + return {}; + } + return { + title: annotationProperties.title, + file: annotationProperties.file, + line: annotationProperties.startLine, + endLine: annotationProperties.endLine, + col: annotationProperties.startColumn, + endColumn: annotationProperties.endColumn + }; +} +exports.toCommandProperties = toCommandProperties; +//# sourceMappingURL=utils.js.map + +/***/ }), + +/***/ 4087: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.Context = void 0; +const fs_1 = __nccwpck_require__(7147); +const os_1 = __nccwpck_require__(2037); +class Context { + /** + * Hydrate the context from the environment + */ + constructor() { + var _a, _b, _c; + 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; + this.job = process.env.GITHUB_JOB; + this.runNumber = parseInt(process.env.GITHUB_RUN_NUMBER, 10); + this.runId = parseInt(process.env.GITHUB_RUN_ID, 10); + this.apiUrl = (_a = process.env.GITHUB_API_URL) !== null && _a !== void 0 ? _a : `https://api.github.com`; + this.serverUrl = (_b = process.env.GITHUB_SERVER_URL) !== null && _b !== void 0 ? _b : `https://github.com`; + this.graphqlUrl = (_c = process.env.GITHUB_GRAPHQL_URL) !== null && _c !== void 0 ? _c : `https://api.github.com/graphql`; + } + 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 + +/***/ }), + +/***/ 5438: +/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { + +"use strict"; + +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } }); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); +}) : function(o, v) { + o["default"] = v; +}); +var __importStar = (this && this.__importStar) || function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k in mod) if (k !== "default" && Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k); + __setModuleDefault(result, mod); + return result; +}; +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.getOctokit = exports.context = void 0; +const Context = __importStar(__nccwpck_require__(4087)); +const utils_1 = __nccwpck_require__(3030); +exports.context = new Context.Context(); +/** + * Returns a hydrated octokit ready to use for GitHub Actions + * + * @param token the repo PAT or GITHUB_TOKEN + * @param options other options to set + */ +function getOctokit(token, options, ...additionalPlugins) { + const GitHubWithPlugins = utils_1.GitHub.plugin(...additionalPlugins); + return new GitHubWithPlugins(utils_1.getOctokitOptions(token, options)); +} +exports.getOctokit = getOctokit; +//# sourceMappingURL=github.js.map + +/***/ }), + +/***/ 7914: +/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { + +"use strict"; + +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } }); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); +}) : function(o, v) { + o["default"] = v; +}); +var __importStar = (this && this.__importStar) || function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k in mod) if (k !== "default" && Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k); + __setModuleDefault(result, mod); + return result; +}; +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.getApiBaseUrl = exports.getProxyAgent = exports.getAuthString = void 0; +const httpClient = __importStar(__nccwpck_require__(6255)); +function getAuthString(token, options) { + if (!token && !options.auth) { + throw new Error('Parameter token or opts.auth is required'); + } + else if (token && options.auth) { + throw new Error('Parameters token and opts.auth may not both be specified'); + } + return typeof options.auth === 'string' ? options.auth : `token ${token}`; +} +exports.getAuthString = getAuthString; +function getProxyAgent(destinationUrl) { + const hc = new httpClient.HttpClient(); + return hc.getAgent(destinationUrl); +} +exports.getProxyAgent = getProxyAgent; +function getApiBaseUrl() { + return process.env['GITHUB_API_URL'] || 'https://api.github.com'; +} +exports.getApiBaseUrl = getApiBaseUrl; +//# sourceMappingURL=utils.js.map + +/***/ }), + +/***/ 3030: +/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { + +"use strict"; + +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } }); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); +}) : function(o, v) { + o["default"] = v; +}); +var __importStar = (this && this.__importStar) || function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k in mod) if (k !== "default" && Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k); + __setModuleDefault(result, mod); + return result; +}; +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.getOctokitOptions = exports.GitHub = exports.defaults = exports.context = void 0; +const Context = __importStar(__nccwpck_require__(4087)); +const Utils = __importStar(__nccwpck_require__(7914)); +// octokit + plugins +const core_1 = __nccwpck_require__(8525); +const plugin_rest_endpoint_methods_1 = __nccwpck_require__(3044); +const plugin_paginate_rest_1 = __nccwpck_require__(4193); +exports.context = new Context.Context(); +const baseUrl = Utils.getApiBaseUrl(); +exports.defaults = { + baseUrl, + request: { + agent: Utils.getProxyAgent(baseUrl) + } +}; +exports.GitHub = core_1.Octokit.plugin(plugin_rest_endpoint_methods_1.restEndpointMethods, plugin_paginate_rest_1.paginateRest).defaults(exports.defaults); +/** + * Convience function to correctly format Octokit Options to pass into the constructor. + * + * @param token the repo PAT or GITHUB_TOKEN + * @param options other options to set + */ +function getOctokitOptions(token, options) { + const opts = Object.assign({}, options || {}); // Shallow clone - don't mutate the object provided by the caller + // Auth + const auth = Utils.getAuthString(token, opts); + if (auth) { + opts.auth = auth; + } + return opts; +} +exports.getOctokitOptions = getOctokitOptions; +//# sourceMappingURL=utils.js.map + +/***/ }), + +/***/ 673: +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + + +Object.defineProperty(exports, "__esModule", ({ value: true })); + +const REGEX_IS_INSTALLATION_LEGACY = /^v1\./; +const REGEX_IS_INSTALLATION = /^ghs_/; +const REGEX_IS_USER_TO_SERVER = /^ghu_/; +async function auth(token) { + const isApp = token.split(/\./).length === 3; + const isInstallation = REGEX_IS_INSTALLATION_LEGACY.test(token) || REGEX_IS_INSTALLATION.test(token); + const isUserToServer = REGEX_IS_USER_TO_SERVER.test(token); + const tokenType = isApp ? "app" : isInstallation ? "installation" : isUserToServer ? "user-to-server" : "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 + + +/***/ }), + +/***/ 8525: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + + +Object.defineProperty(exports, "__esModule", ({ value: true })); + +var universalUserAgent = __nccwpck_require__(5030); +var beforeAfterHook = __nccwpck_require__(3682); +var request = __nccwpck_require__(9353); +var graphql = __nccwpck_require__(6422); +var authToken = __nccwpck_require__(673); + +function _objectWithoutPropertiesLoose(source, excluded) { + if (source == null) return {}; + var target = {}; + var sourceKeys = Object.keys(source); + var key, i; + + for (i = 0; i < sourceKeys.length; i++) { + key = sourceKeys[i]; + if (excluded.indexOf(key) >= 0) continue; + target[key] = source[key]; + } + + return target; +} + +function _objectWithoutProperties(source, excluded) { + if (source == null) return {}; + + var target = _objectWithoutPropertiesLoose(source, excluded); + + var key, i; + + if (Object.getOwnPropertySymbols) { + var sourceSymbolKeys = Object.getOwnPropertySymbols(source); + + for (i = 0; i < sourceSymbolKeys.length; i++) { + key = sourceSymbolKeys[i]; + if (excluded.indexOf(key) >= 0) continue; + if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; + target[key] = source[key]; + } + } + + return target; +} + +const VERSION = "3.6.0"; + +const _excluded = ["authStrategy"]; +class Octokit { + constructor(options = {}) { + const hook = new beforeAfterHook.Collection(); + const requestDefaults = { + baseUrl: request.request.endpoint.DEFAULTS.baseUrl, + headers: {}, + request: Object.assign({}, options.request, { + // @ts-ignore internal usage only, no need to type + hook: hook.bind(null, "request") + }), + mediaType: { + previews: [], + format: "" + } + }; // prepend default user agent with `options.userAgent` if set + + requestDefaults.headers["user-agent"] = [options.userAgent, `octokit-core.js/${VERSION} ${universalUserAgent.getUserAgent()}`].filter(Boolean).join(" "); + + if (options.baseUrl) { + requestDefaults.baseUrl = options.baseUrl; + } + + if (options.previews) { + requestDefaults.mediaType.previews = options.previews; + } + + if (options.timeZone) { + requestDefaults.headers["time-zone"] = options.timeZone; + } + + this.request = request.request.defaults(requestDefaults); + this.graphql = graphql.withCustomRequest(this.request).defaults(requestDefaults); + this.log = Object.assign({ + debug: () => {}, + info: () => {}, + warn: console.warn.bind(console), + error: console.error.bind(console) + }, options.log); + this.hook = hook; // (1) If neither `options.authStrategy` nor `options.auth` are set, the `octokit` instance + // is unauthenticated. The `this.auth()` method is a no-op and no request hook is registered. + // (2) If only `options.auth` is set, use the default token authentication strategy. + // (3) If `options.authStrategy` is set then use it and pass in `options.auth`. Always pass own request as many strategies accept a custom request instance. + // TODO: type `options.auth` based on `options.authStrategy`. + + if (!options.authStrategy) { + if (!options.auth) { + // (1) + this.auth = async () => ({ + type: "unauthenticated" + }); + } else { + // (2) + const auth = authToken.createTokenAuth(options.auth); // @ts-ignore ¯\_(ツ)_/¯ + + hook.wrap("request", auth.hook); + this.auth = auth; + } + } else { + const { + authStrategy + } = options, + otherOptions = _objectWithoutProperties(options, _excluded); + + const auth = authStrategy(Object.assign({ + request: this.request, + log: this.log, + // we pass the current octokit instance as well as its constructor options + // to allow for authentication strategies that return a new octokit instance + // that shares the same internal state as the current one. The original + // requirement for this was the "event-octokit" authentication strategy + // of https://github.com/probot/octokit-auth-probot. + octokit: this, + octokitOptions: otherOptions + }, options.auth)); // @ts-ignore ¯\_(ツ)_/¯ + + hook.wrap("request", auth.hook); + this.auth = auth; + } // apply plugins + // https://stackoverflow.com/a/16345172 + + + const classConstructor = this.constructor; + classConstructor.plugins.forEach(plugin => { + Object.assign(this, plugin(this, options)); + }); + } + + static defaults(defaults) { + const OctokitWithDefaults = class extends this { + constructor(...args) { + const options = args[0] || {}; + + if (typeof defaults === "function") { + super(defaults(options)); + return; + } + + super(Object.assign({}, defaults, options, options.userAgent && defaults.userAgent ? { + userAgent: `${options.userAgent} ${defaults.userAgent}` + } : null)); + } + + }; + return OctokitWithDefaults; + } + /** + * Attach a plugin (or many) to your Octokit instance. + * + * @example + * const API = Octokit.plugin(plugin1, plugin2, plugin3, ...) + */ + + + static plugin(...newPlugins) { + var _a; + + const currentPlugins = this.plugins; + const NewOctokit = (_a = class extends this {}, _a.plugins = currentPlugins.concat(newPlugins.filter(plugin => !currentPlugins.includes(plugin))), _a); + return NewOctokit; + } + +} +Octokit.VERSION = VERSION; +Octokit.plugins = []; + +exports.Octokit = Octokit; +//# sourceMappingURL=index.js.map + + +/***/ }), + +/***/ 8713: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + + +Object.defineProperty(exports, "__esModule", ({ value: true })); + +var isPlainObject = __nccwpck_require__(3287); +var universalUserAgent = __nccwpck_require__(5030); + +function lowercaseKeys(object) { + if (!object) { + return {}; + } + + return Object.keys(object).reduce((newObj, key) => { + newObj[key.toLowerCase()] = object[key]; + return newObj; + }, {}); +} + +function mergeDeep(defaults, options) { + const result = Object.assign({}, defaults); + Object.keys(options).forEach(key => { + if (isPlainObject.isPlainObject(options[key])) { + if (!(key in defaults)) Object.assign(result, { + [key]: options[key] + });else result[key] = mergeDeep(defaults[key], options[key]); + } else { + Object.assign(result, { + [key]: options[key] + }); + } + }); + return result; +} + +function removeUndefinedProperties(obj) { + for (const key in obj) { + if (obj[key] === undefined) { + delete obj[key]; + } + } + + return obj; +} + +function merge(defaults, route, options) { + if (typeof route === "string") { + let [method, url] = route.split(" "); + options = Object.assign(url ? { + method, + url + } : { + url: method + }, options); + } else { + options = Object.assign({}, route); + } // lowercase header names before merging with defaults to avoid duplicates + + + options.headers = lowercaseKeys(options.headers); // remove properties with undefined values before merging + + removeUndefinedProperties(options); + removeUndefinedProperties(options.headers); + const mergedOptions = mergeDeep(defaults || {}, options); // mediaType.previews arrays are merged, instead of overwritten + + if (defaults && defaults.mediaType.previews.length) { + mergedOptions.mediaType.previews = defaults.mediaType.previews.filter(preview => !mergedOptions.mediaType.previews.includes(preview)).concat(mergedOptions.mediaType.previews); + } + + mergedOptions.mediaType.previews = mergedOptions.mediaType.previews.map(preview => preview.replace(/-preview/, "")); + return mergedOptions; +} + +function addQueryParameters(url, parameters) { + const separator = /\?/.test(url) ? "&" : "?"; + const names = Object.keys(parameters); + + if (names.length === 0) { + return url; + } + + return url + separator + names.map(name => { + if (name === "q") { + return "q=" + parameters.q.split("+").map(encodeURIComponent).join("+"); + } + + return `${name}=${encodeURIComponent(parameters[name])}`; + }).join("&"); +} + +const urlVariableRegex = /\{[^}]+\}/g; + +function removeNonChars(variableName) { + return variableName.replace(/^\W+|\W+$/g, "").split(/,/); +} + +function extractUrlVariableNames(url) { + const matches = url.match(urlVariableRegex); + + if (!matches) { + return []; + } + + return matches.map(removeNonChars).reduce((a, b) => a.concat(b), []); +} + +function omit(object, keysToOmit) { + return Object.keys(object).filter(option => !keysToOmit.includes(option)).reduce((obj, key) => { + obj[key] = object[key]; + return obj; + }, {}); +} + +// Based on https://github.com/bramstein/url-template, licensed under BSD +// TODO: create separate package. +// +// Copyright (c) 2012-2014, Bram Stein +// All rights reserved. +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions +// are met: +// 1. Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// 2. Redistributions in binary form must reproduce the above copyright +// notice, this list of conditions and the following disclaimer in the +// documentation and/or other materials provided with the distribution. +// 3. The name of the author may not be used to endorse or promote products +// derived from this software without specific prior written permission. +// THIS SOFTWARE IS PROVIDED BY THE AUTHOR "AS IS" AND ANY EXPRESS OR IMPLIED +// WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF +// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO +// EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, +// INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, +// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY +// OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING +// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, +// EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +/* istanbul ignore file */ +function encodeReserved(str) { + return str.split(/(%[0-9A-Fa-f]{2})/g).map(function (part) { + if (!/%[0-9A-Fa-f]/.test(part)) { + part = encodeURI(part).replace(/%5B/g, "[").replace(/%5D/g, "]"); + } + + return part; + }).join(""); +} + +function encodeUnreserved(str) { + return encodeURIComponent(str).replace(/[!'()*]/g, function (c) { + return "%" + c.charCodeAt(0).toString(16).toUpperCase(); + }); +} + +function encodeValue(operator, value, key) { + value = operator === "+" || operator === "#" ? encodeReserved(value) : encodeUnreserved(value); + + if (key) { + return encodeUnreserved(key) + "=" + value; + } else { + return value; + } +} + +function isDefined(value) { + return value !== undefined && value !== null; +} + +function isKeyOperator(operator) { + return operator === ";" || operator === "&" || operator === "?"; +} + +function getValues(context, operator, key, modifier) { + var value = context[key], + result = []; + + if (isDefined(value) && value !== "") { + if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") { + value = value.toString(); + + if (modifier && modifier !== "*") { + value = value.substring(0, parseInt(modifier, 10)); + } + + result.push(encodeValue(operator, value, isKeyOperator(operator) ? key : "")); + } else { + if (modifier === "*") { + if (Array.isArray(value)) { + value.filter(isDefined).forEach(function (value) { + result.push(encodeValue(operator, value, isKeyOperator(operator) ? key : "")); + }); + } else { + Object.keys(value).forEach(function (k) { + if (isDefined(value[k])) { + result.push(encodeValue(operator, value[k], k)); + } + }); + } + } else { + const tmp = []; + + if (Array.isArray(value)) { + value.filter(isDefined).forEach(function (value) { + tmp.push(encodeValue(operator, value)); + }); + } else { + Object.keys(value).forEach(function (k) { + if (isDefined(value[k])) { + tmp.push(encodeUnreserved(k)); + tmp.push(encodeValue(operator, value[k].toString())); + } + }); + } + + if (isKeyOperator(operator)) { + result.push(encodeUnreserved(key) + "=" + tmp.join(",")); + } else if (tmp.length !== 0) { + result.push(tmp.join(",")); + } + } + } + } else { + if (operator === ";") { + if (isDefined(value)) { + result.push(encodeUnreserved(key)); + } + } else if (value === "" && (operator === "&" || operator === "?")) { + result.push(encodeUnreserved(key) + "="); + } else if (value === "") { + result.push(""); + } + } + + return result; +} + +function parseUrl(template) { + return { + expand: expand.bind(null, template) + }; +} + +function expand(template, context) { + var operators = ["+", "#", ".", "/", ";", "?", "&"]; + return template.replace(/\{([^\{\}]+)\}|([^\{\}]+)/g, function (_, expression, literal) { + if (expression) { + let operator = ""; + const values = []; + + if (operators.indexOf(expression.charAt(0)) !== -1) { + operator = expression.charAt(0); + expression = expression.substr(1); + } + + expression.split(/,/g).forEach(function (variable) { + var tmp = /([^:\*]*)(?::(\d+)|(\*))?/.exec(variable); + values.push(getValues(context, operator, tmp[1], tmp[2] || tmp[3])); + }); + + if (operator && operator !== "+") { + var separator = ","; + + if (operator === "?") { + separator = "&"; + } else if (operator !== "#") { + separator = operator; + } + + return (values.length !== 0 ? operator : "") + values.join(separator); + } else { + return values.join(","); + } + } else { + return encodeReserved(literal); + } + }); +} + +function parse(options) { + // https://fetch.spec.whatwg.org/#methods + let method = options.method.toUpperCase(); // replace :varname with {varname} to make it RFC 6570 compatible + + let url = (options.url || "/").replace(/:([a-z]\w+)/g, "{$1}"); + let headers = Object.assign({}, options.headers); + let body; + let parameters = omit(options, ["method", "baseUrl", "url", "headers", "request", "mediaType"]); // extract variable names from URL to calculate remaining variables later + + const urlVariableNames = extractUrlVariableNames(url); + url = parseUrl(url).expand(parameters); + + if (!/^http/.test(url)) { + url = options.baseUrl + url; + } + + const omittedParameters = Object.keys(options).filter(option => urlVariableNames.includes(option)).concat("baseUrl"); + const remainingParameters = omit(parameters, omittedParameters); + const isBinaryRequest = /application\/octet-stream/i.test(headers.accept); + + if (!isBinaryRequest) { + if (options.mediaType.format) { + // e.g. application/vnd.github.v3+json => application/vnd.github.v3.raw + headers.accept = headers.accept.split(/,/).map(preview => preview.replace(/application\/vnd(\.\w+)(\.v3)?(\.\w+)?(\+json)?$/, `application/vnd$1$2.${options.mediaType.format}`)).join(","); + } + + if (options.mediaType.previews.length) { + const previewsFromAcceptHeader = headers.accept.match(/[\w-]+(?=-preview)/g) || []; + headers.accept = previewsFromAcceptHeader.concat(options.mediaType.previews).map(preview => { + const format = options.mediaType.format ? `.${options.mediaType.format}` : "+json"; + return `application/vnd.github.${preview}-preview${format}`; + }).join(","); + } + } // for GET/HEAD requests, set URL query parameters from remaining parameters + // for PATCH/POST/PUT/DELETE requests, set request body from remaining parameters + + + if (["GET", "HEAD"].includes(method)) { + url = addQueryParameters(url, remainingParameters); + } else { + if ("data" in remainingParameters) { + body = remainingParameters.data; + } else { + if (Object.keys(remainingParameters).length) { + body = remainingParameters; + } else { + headers["content-length"] = 0; + } + } + } // default content-type for JSON if body is set + + + if (!headers["content-type"] && typeof body !== "undefined") { + headers["content-type"] = "application/json; charset=utf-8"; + } // GitHub expects 'content-length: 0' header for PUT/PATCH requests without body. + // fetch does not allow to set `content-length` header, but we can set body to an empty string + + + if (["PATCH", "PUT"].includes(method) && typeof body === "undefined") { + body = ""; + } // Only return body/request keys if present + + + return Object.assign({ + method, + url, + headers + }, typeof body !== "undefined" ? { + body + } : null, options.request ? { + request: options.request + } : null); +} + +function endpointWithDefaults(defaults, route, options) { + return parse(merge(defaults, route, options)); +} + +function withDefaults(oldDefaults, newDefaults) { + const DEFAULTS = merge(oldDefaults, newDefaults); + const endpoint = endpointWithDefaults.bind(null, DEFAULTS); + return Object.assign(endpoint, { + DEFAULTS, + defaults: withDefaults.bind(null, DEFAULTS), + merge: merge.bind(null, DEFAULTS), + parse + }); +} + +const VERSION = "6.0.12"; + +const userAgent = `octokit-endpoint.js/${VERSION} ${universalUserAgent.getUserAgent()}`; // DEFAULTS has all properties set that EndpointOptions has, except url. +// So we use RequestParameters and add method as additional required property. + +const DEFAULTS = { + method: "GET", + baseUrl: "https://api.github.com", + headers: { + accept: "application/vnd.github.v3+json", + "user-agent": userAgent + }, + mediaType: { + format: "", + previews: [] + } +}; + +const endpoint = withDefaults(null, DEFAULTS); + +exports.endpoint = endpoint; +//# sourceMappingURL=index.js.map + + +/***/ }), + +/***/ 6422: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + + +Object.defineProperty(exports, "__esModule", ({ value: true })); + +var request = __nccwpck_require__(9353); +var universalUserAgent = __nccwpck_require__(5030); + +const VERSION = "4.8.0"; + +function _buildMessageForResponseErrors(data) { + return `Request failed due to following response errors:\n` + data.errors.map(e => ` - ${e.message}`).join("\n"); +} + +class GraphqlResponseError extends Error { + constructor(request, headers, response) { + super(_buildMessageForResponseErrors(response)); + this.request = request; + this.headers = headers; + this.response = response; + this.name = "GraphqlResponseError"; // Expose the errors and response data in their shorthand properties. + + this.errors = response.errors; + this.data = response.data; // Maintains proper stack trace (only available on V8) + + /* istanbul ignore next */ + + if (Error.captureStackTrace) { + Error.captureStackTrace(this, this.constructor); + } + } + +} + +const NON_VARIABLE_OPTIONS = ["method", "baseUrl", "url", "headers", "request", "query", "mediaType"]; +const FORBIDDEN_VARIABLE_OPTIONS = ["query", "method", "url"]; +const GHES_V3_SUFFIX_REGEX = /\/api\/v3\/?$/; +function graphql(request, query, options) { + if (options) { + if (typeof query === "string" && "query" in options) { + return Promise.reject(new Error(`[@octokit/graphql] "query" cannot be used as variable name`)); + } + + for (const key in options) { + if (!FORBIDDEN_VARIABLE_OPTIONS.includes(key)) continue; + return Promise.reject(new Error(`[@octokit/graphql] "${key}" cannot be used as variable name`)); + } + } + + const parsedOptions = typeof query === "string" ? Object.assign({ + query + }, options) : query; + const requestOptions = Object.keys(parsedOptions).reduce((result, key) => { + if (NON_VARIABLE_OPTIONS.includes(key)) { + result[key] = parsedOptions[key]; + return result; + } + + if (!result.variables) { + result.variables = {}; + } + + result.variables[key] = parsedOptions[key]; + return result; + }, {}); // workaround for GitHub Enterprise baseUrl set with /api/v3 suffix + // https://github.com/octokit/auth-app.js/issues/111#issuecomment-657610451 + + const baseUrl = parsedOptions.baseUrl || request.endpoint.DEFAULTS.baseUrl; + + if (GHES_V3_SUFFIX_REGEX.test(baseUrl)) { + requestOptions.url = baseUrl.replace(GHES_V3_SUFFIX_REGEX, "/api/graphql"); + } + + return request(requestOptions).then(response => { + if (response.data.errors) { + const headers = {}; + + for (const key of Object.keys(response.headers)) { + headers[key] = response.headers[key]; + } + + throw new GraphqlResponseError(requestOptions, headers, 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.GraphqlResponseError = GraphqlResponseError; +exports.graphql = graphql$1; +exports.withCustomRequest = withCustomRequest; +//# sourceMappingURL=index.js.map + + +/***/ }), + +/***/ 7471: +/***/ ((__unused_webpack_module, exports, __nccwpck_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 = __nccwpck_require__(8932); +var once = _interopDefault(__nccwpck_require__(1223)); + +const logOnceCode = once(deprecation => console.warn(deprecation)); +const logOnceHeaders = once(deprecation => console.warn(deprecation)); +/** + * Error with extra properties to help with debugging + */ + +class RequestError extends Error { + constructor(message, statusCode, options) { + super(message); // Maintains proper stack trace (only available on V8) + + /* istanbul ignore next */ + + if (Error.captureStackTrace) { + Error.captureStackTrace(this, this.constructor); + } + + this.name = "HttpError"; + this.status = statusCode; + let headers; + + if ("headers" in options && typeof options.headers !== "undefined") { + headers = options.headers; + } + + if ("response" in options) { + this.response = options.response; + headers = options.response.headers; + } // redact request credentials without mutating original request options + + + const requestCopy = Object.assign({}, options.request); + + if (options.request.headers.authorization) { + requestCopy.headers = Object.assign({}, options.request.headers, { + authorization: options.request.headers.authorization.replace(/ .*$/, " [REDACTED]") + }); + } + + requestCopy.url = requestCopy.url // client_id & client_secret can be passed as URL query parameters to increase rate limit + // see https://developer.github.com/v3/#increasing-the-unauthenticated-rate-limit-for-oauth-applications + .replace(/\bclient_secret=\w+/g, "client_secret=[REDACTED]") // OAuth tokens can be passed as URL query parameters, although it is not recommended + // see https://developer.github.com/v3/#oauth2-token-sent-in-a-header + .replace(/\baccess_token=\w+/g, "access_token=[REDACTED]"); + this.request = requestCopy; // deprecations + + Object.defineProperty(this, "code", { + get() { + logOnceCode(new deprecation.Deprecation("[@octokit/request-error] `error.code` is deprecated, use `error.status`.")); + return statusCode; + } + + }); + Object.defineProperty(this, "headers", { + get() { + logOnceHeaders(new deprecation.Deprecation("[@octokit/request-error] `error.headers` is deprecated, use `error.response.headers`.")); + return headers || {}; + } + + }); + } + +} + +exports.RequestError = RequestError; +//# sourceMappingURL=index.js.map + + +/***/ }), + +/***/ 9353: +/***/ ((__unused_webpack_module, exports, __nccwpck_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 = __nccwpck_require__(8713); +var universalUserAgent = __nccwpck_require__(5030); +var isPlainObject = __nccwpck_require__(3287); +var nodeFetch = _interopDefault(__nccwpck_require__(467)); +var requestError = __nccwpck_require__(7471); + +const VERSION = "5.6.3"; + +function getBufferResponse(response) { + return response.arrayBuffer(); +} + +function fetchWrapper(requestOptions) { + const log = requestOptions.request && requestOptions.request.log ? requestOptions.request.log : console; + + if (isPlainObject.isPlainObject(requestOptions.body) || Array.isArray(requestOptions.body)) { + requestOptions.body = JSON.stringify(requestOptions.body); + } + + let headers = {}; + let status; + let url; + const fetch = requestOptions.request && requestOptions.request.fetch || nodeFetch; + return fetch(requestOptions.url, Object.assign({ + method: requestOptions.method, + body: requestOptions.body, + headers: requestOptions.headers, + redirect: requestOptions.redirect + }, // `requestOptions.request.agent` type is incompatible + // see https://github.com/octokit/types.ts/pull/264 + requestOptions.request)).then(async response => { + url = response.url; + status = response.status; + + for (const keyAndValue of response.headers) { + headers[keyAndValue[0]] = keyAndValue[1]; + } + + if ("deprecation" in headers) { + const matches = headers.link && headers.link.match(/<([^>]+)>; rel="deprecation"/); + const deprecationLink = matches && matches.pop(); + log.warn(`[@octokit/request] "${requestOptions.method} ${requestOptions.url}" is deprecated. It is scheduled to be removed on ${headers.sunset}${deprecationLink ? `. See ${deprecationLink}` : ""}`); + } + + if (status === 204 || status === 205) { + return; + } // GitHub API returns 200 for HEAD requests + + + if (requestOptions.method === "HEAD") { + if (status < 400) { + return; + } + + throw new requestError.RequestError(response.statusText, status, { + response: { + url, + status, + headers, + data: undefined + }, + request: requestOptions + }); + } + + if (status === 304) { + throw new requestError.RequestError("Not modified", status, { + response: { + url, + status, + headers, + data: await getResponseData(response) + }, + request: requestOptions + }); + } + + if (status >= 400) { + const data = await getResponseData(response); + const error = new requestError.RequestError(toErrorMessage(data), status, { + response: { + url, + status, + headers, + data + }, + request: requestOptions + }); + throw error; + } + + return getResponseData(response); + }).then(data => { + return { + status, + url, + headers, + data + }; + }).catch(error => { + if (error instanceof requestError.RequestError) throw error; + throw new requestError.RequestError(error.message, 500, { + request: requestOptions + }); + }); +} + +async function getResponseData(response) { + const contentType = response.headers.get("content-type"); + + if (/application\/json/.test(contentType)) { + return response.json(); + } + + if (!contentType || /^text\/|charset=utf-8$/.test(contentType)) { + return response.text(); + } + + return getBufferResponse(response); +} + +function toErrorMessage(data) { + if (typeof data === "string") return data; // istanbul ignore else - just in case + + if ("message" in data) { + if (Array.isArray(data.errors)) { + return `${data.message}: ${data.errors.map(JSON.stringify).join(", ")}`; + } + + return data.message; + } // istanbul ignore next - just in case + + + return `Unknown error: ${JSON.stringify(data)}`; +} + +function withDefaults(oldEndpoint, newDefaults) { + const endpoint = oldEndpoint.defaults(newDefaults); + + const newApi = function (route, parameters) { + const endpointOptions = endpoint.merge(route, parameters); + + if (!endpointOptions.request || !endpointOptions.request.hook) { + return fetchWrapper(endpoint.parse(endpointOptions)); + } + + const request = (route, parameters) => { + return fetchWrapper(endpoint.parse(endpoint.merge(route, parameters))); + }; + + Object.assign(request, { + endpoint, + defaults: withDefaults.bind(null, endpoint) + }); + return endpointOptions.request.hook(request, endpointOptions); + }; + + return Object.assign(newApi, { + endpoint, + defaults: withDefaults.bind(null, endpoint) + }); +} + +const request = withDefaults(endpoint.endpoint, { + headers: { + "user-agent": `octokit-request.js/${VERSION} ${universalUserAgent.getUserAgent()}` + } +}); + +exports.request = request; +//# sourceMappingURL=index.js.map + + +/***/ }), + +/***/ 8090: +/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { + +"use strict"; + +var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { + function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); } + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +}; +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.hashFiles = exports.create = void 0; +const internal_globber_1 = __nccwpck_require__(8298); +const internal_hash_files_1 = __nccwpck_require__(2448); +/** + * Constructs a globber + * + * @param patterns Patterns separated by newlines + * @param options Glob options + */ +function create(patterns, options) { + return __awaiter(this, void 0, void 0, function* () { + return yield internal_globber_1.DefaultGlobber.create(patterns, options); + }); +} +exports.create = create; +/** + * Computes the sha256 hash of a glob + * + * @param patterns Patterns separated by newlines + * @param currentWorkspace Workspace used when matching files + * @param options Glob options + * @param verbose Enables verbose logging + */ +function hashFiles(patterns, currentWorkspace = '', options, verbose = false) { + return __awaiter(this, void 0, void 0, function* () { + let followSymbolicLinks = true; + if (options && typeof options.followSymbolicLinks === 'boolean') { + followSymbolicLinks = options.followSymbolicLinks; + } + const globber = yield create(patterns, { followSymbolicLinks }); + return internal_hash_files_1.hashFiles(globber, currentWorkspace, verbose); + }); +} +exports.hashFiles = hashFiles; +//# sourceMappingURL=glob.js.map + +/***/ }), + +/***/ 1026: +/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { + +"use strict"; + +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } }); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); +}) : function(o, v) { + o["default"] = v; +}); +var __importStar = (this && this.__importStar) || function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k in mod) if (k !== "default" && Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k); + __setModuleDefault(result, mod); + return result; +}; +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.getOptions = void 0; +const core = __importStar(__nccwpck_require__(2186)); +/** + * Returns a copy with defaults filled in. + */ +function getOptions(copy) { + const result = { + followSymbolicLinks: true, + implicitDescendants: true, + matchDirectories: true, + omitBrokenSymbolicLinks: true + }; + if (copy) { + if (typeof copy.followSymbolicLinks === 'boolean') { + result.followSymbolicLinks = copy.followSymbolicLinks; + core.debug(`followSymbolicLinks '${result.followSymbolicLinks}'`); + } + if (typeof copy.implicitDescendants === 'boolean') { + result.implicitDescendants = copy.implicitDescendants; + core.debug(`implicitDescendants '${result.implicitDescendants}'`); + } + if (typeof copy.matchDirectories === 'boolean') { + result.matchDirectories = copy.matchDirectories; + core.debug(`matchDirectories '${result.matchDirectories}'`); + } + if (typeof copy.omitBrokenSymbolicLinks === 'boolean') { + result.omitBrokenSymbolicLinks = copy.omitBrokenSymbolicLinks; + core.debug(`omitBrokenSymbolicLinks '${result.omitBrokenSymbolicLinks}'`); + } + } + return result; +} +exports.getOptions = getOptions; +//# sourceMappingURL=internal-glob-options-helper.js.map + +/***/ }), + +/***/ 8298: +/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { + +"use strict"; + +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } }); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); +}) : function(o, v) { + o["default"] = v; +}); +var __importStar = (this && this.__importStar) || function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k in mod) if (k !== "default" && Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k); + __setModuleDefault(result, mod); + return result; +}; +var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { + function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); } + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +}; +var __asyncValues = (this && this.__asyncValues) || function (o) { + if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined."); + var m = o[Symbol.asyncIterator], i; + return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i); + function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; } + function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); } +}; +var __await = (this && this.__await) || function (v) { return this instanceof __await ? (this.v = v, this) : new __await(v); } +var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) { + if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined."); + var g = generator.apply(thisArg, _arguments || []), i, q = []; + return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i; + function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; } + function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } } + function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); } + function fulfill(value) { resume("next", value); } + function reject(value) { resume("throw", value); } + function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); } +}; +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.DefaultGlobber = void 0; +const core = __importStar(__nccwpck_require__(2186)); +const fs = __importStar(__nccwpck_require__(7147)); +const globOptionsHelper = __importStar(__nccwpck_require__(1026)); +const path = __importStar(__nccwpck_require__(1017)); +const patternHelper = __importStar(__nccwpck_require__(9005)); +const internal_match_kind_1 = __nccwpck_require__(1063); +const internal_pattern_1 = __nccwpck_require__(4536); +const internal_search_state_1 = __nccwpck_require__(9117); +const IS_WINDOWS = process.platform === 'win32'; +class DefaultGlobber { + constructor(options) { + this.patterns = []; + this.searchPaths = []; + this.options = globOptionsHelper.getOptions(options); + } + getSearchPaths() { + // Return a copy + return this.searchPaths.slice(); + } + glob() { + var e_1, _a; + return __awaiter(this, void 0, void 0, function* () { + const result = []; + try { + for (var _b = __asyncValues(this.globGenerator()), _c; _c = yield _b.next(), !_c.done;) { + const itemPath = _c.value; + result.push(itemPath); + } + } + catch (e_1_1) { e_1 = { error: e_1_1 }; } + finally { + try { + if (_c && !_c.done && (_a = _b.return)) yield _a.call(_b); + } + finally { if (e_1) throw e_1.error; } + } + return result; + }); + } + globGenerator() { + return __asyncGenerator(this, arguments, function* globGenerator_1() { + // Fill in defaults options + const options = globOptionsHelper.getOptions(this.options); + // Implicit descendants? + const patterns = []; + for (const pattern of this.patterns) { + patterns.push(pattern); + if (options.implicitDescendants && + (pattern.trailingSeparator || + pattern.segments[pattern.segments.length - 1] !== '**')) { + patterns.push(new internal_pattern_1.Pattern(pattern.negate, true, pattern.segments.concat('**'))); + } + } + // Push the search paths + const stack = []; + for (const searchPath of patternHelper.getSearchPaths(patterns)) { + core.debug(`Search path '${searchPath}'`); + // Exists? + try { + // Intentionally using lstat. Detection for broken symlink + // will be performed later (if following symlinks). + yield __await(fs.promises.lstat(searchPath)); + } + catch (err) { + if (err.code === 'ENOENT') { + continue; + } + throw err; + } + stack.unshift(new internal_search_state_1.SearchState(searchPath, 1)); + } + // Search + const traversalChain = []; // used to detect cycles + while (stack.length) { + // Pop + const item = stack.pop(); + // Match? + const match = patternHelper.match(patterns, item.path); + const partialMatch = !!match || patternHelper.partialMatch(patterns, item.path); + if (!match && !partialMatch) { + continue; + } + // Stat + const stats = yield __await(DefaultGlobber.stat(item, options, traversalChain) + // Broken symlink, or symlink cycle detected, or no longer exists + ); + // Broken symlink, or symlink cycle detected, or no longer exists + if (!stats) { + continue; + } + // Directory + if (stats.isDirectory()) { + // Matched + if (match & internal_match_kind_1.MatchKind.Directory && options.matchDirectories) { + yield yield __await(item.path); + } + // Descend? + else if (!partialMatch) { + continue; + } + // Push the child items in reverse + const childLevel = item.level + 1; + const childItems = (yield __await(fs.promises.readdir(item.path))).map(x => new internal_search_state_1.SearchState(path.join(item.path, x), childLevel)); + stack.push(...childItems.reverse()); + } + // File + else if (match & internal_match_kind_1.MatchKind.File) { + yield yield __await(item.path); + } + } + }); + } + /** + * Constructs a DefaultGlobber + */ + static create(patterns, options) { + return __awaiter(this, void 0, void 0, function* () { + const result = new DefaultGlobber(options); + if (IS_WINDOWS) { + patterns = patterns.replace(/\r\n/g, '\n'); + patterns = patterns.replace(/\r/g, '\n'); + } + const lines = patterns.split('\n').map(x => x.trim()); + for (const line of lines) { + // Empty or comment + if (!line || line.startsWith('#')) { + continue; + } + // Pattern + else { + result.patterns.push(new internal_pattern_1.Pattern(line)); + } + } + result.searchPaths.push(...patternHelper.getSearchPaths(result.patterns)); + return result; + }); + } + static stat(item, options, traversalChain) { + return __awaiter(this, void 0, void 0, function* () { + // Note: + // `stat` returns info about the target of a symlink (or symlink chain) + // `lstat` returns info about a symlink itself + let stats; + if (options.followSymbolicLinks) { + try { + // Use `stat` (following symlinks) + stats = yield fs.promises.stat(item.path); + } + catch (err) { + if (err.code === 'ENOENT') { + if (options.omitBrokenSymbolicLinks) { + core.debug(`Broken symlink '${item.path}'`); + return undefined; + } + throw new Error(`No information found for the path '${item.path}'. This may indicate a broken symbolic link.`); + } + throw err; + } + } + else { + // Use `lstat` (not following symlinks) + stats = yield fs.promises.lstat(item.path); + } + // Note, isDirectory() returns false for the lstat of a symlink + if (stats.isDirectory() && options.followSymbolicLinks) { + // Get the realpath + const realPath = yield fs.promises.realpath(item.path); + // Fixup the traversal chain to match the item level + while (traversalChain.length >= item.level) { + traversalChain.pop(); + } + // Test for a cycle + if (traversalChain.some((x) => x === realPath)) { + core.debug(`Symlink cycle detected for path '${item.path}' and realpath '${realPath}'`); + return undefined; + } + // Update the traversal chain + traversalChain.push(realPath); + } + return stats; + }); + } +} +exports.DefaultGlobber = DefaultGlobber; +//# sourceMappingURL=internal-globber.js.map + +/***/ }), + +/***/ 2448: +/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { + +"use strict"; + +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } }); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); +}) : function(o, v) { + o["default"] = v; +}); +var __importStar = (this && this.__importStar) || function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k in mod) if (k !== "default" && Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k); + __setModuleDefault(result, mod); + return result; +}; +var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { + function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); } + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +}; +var __asyncValues = (this && this.__asyncValues) || function (o) { + if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined."); + var m = o[Symbol.asyncIterator], i; + return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i); + function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; } + function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); } +}; +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.hashFiles = void 0; +const crypto = __importStar(__nccwpck_require__(6113)); +const core = __importStar(__nccwpck_require__(2186)); +const fs = __importStar(__nccwpck_require__(7147)); +const stream = __importStar(__nccwpck_require__(2781)); +const util = __importStar(__nccwpck_require__(3837)); +const path = __importStar(__nccwpck_require__(1017)); +function hashFiles(globber, currentWorkspace, verbose = false) { + var e_1, _a; + var _b; + return __awaiter(this, void 0, void 0, function* () { + const writeDelegate = verbose ? core.info : core.debug; + let hasMatch = false; + const githubWorkspace = currentWorkspace + ? currentWorkspace + : (_b = process.env['GITHUB_WORKSPACE']) !== null && _b !== void 0 ? _b : process.cwd(); + const result = crypto.createHash('sha256'); + let count = 0; + try { + for (var _c = __asyncValues(globber.globGenerator()), _d; _d = yield _c.next(), !_d.done;) { + const file = _d.value; + writeDelegate(file); + if (!file.startsWith(`${githubWorkspace}${path.sep}`)) { + writeDelegate(`Ignore '${file}' since it is not under GITHUB_WORKSPACE.`); + continue; + } + if (fs.statSync(file).isDirectory()) { + writeDelegate(`Skip directory '${file}'.`); + continue; + } + const hash = crypto.createHash('sha256'); + const pipeline = util.promisify(stream.pipeline); + yield pipeline(fs.createReadStream(file), hash); + result.write(hash.digest()); + count++; + if (!hasMatch) { + hasMatch = true; + } + } + } + catch (e_1_1) { e_1 = { error: e_1_1 }; } + finally { + try { + if (_d && !_d.done && (_a = _c.return)) yield _a.call(_c); + } + finally { if (e_1) throw e_1.error; } + } + result.end(); + if (hasMatch) { + writeDelegate(`Found ${count} files to hash.`); + return result.digest('hex'); + } + else { + writeDelegate(`No matches found for glob`); + return ''; + } + }); +} +exports.hashFiles = hashFiles; +//# sourceMappingURL=internal-hash-files.js.map + +/***/ }), + +/***/ 1063: +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.MatchKind = void 0; +/** + * Indicates whether a pattern matches a path + */ +var MatchKind; +(function (MatchKind) { + /** Not matched */ + MatchKind[MatchKind["None"] = 0] = "None"; + /** Matched if the path is a directory */ + MatchKind[MatchKind["Directory"] = 1] = "Directory"; + /** Matched if the path is a regular file */ + MatchKind[MatchKind["File"] = 2] = "File"; + /** Matched */ + MatchKind[MatchKind["All"] = 3] = "All"; +})(MatchKind = exports.MatchKind || (exports.MatchKind = {})); +//# sourceMappingURL=internal-match-kind.js.map + +/***/ }), + +/***/ 1849: +/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { + +"use strict"; + +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } }); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); +}) : function(o, v) { + o["default"] = v; +}); +var __importStar = (this && this.__importStar) || function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k in mod) if (k !== "default" && Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k); + __setModuleDefault(result, mod); + return result; +}; +var __importDefault = (this && this.__importDefault) || function (mod) { + return (mod && mod.__esModule) ? mod : { "default": mod }; +}; +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.safeTrimTrailingSeparator = exports.normalizeSeparators = exports.hasRoot = exports.hasAbsoluteRoot = exports.ensureAbsoluteRoot = exports.dirname = void 0; +const path = __importStar(__nccwpck_require__(1017)); +const assert_1 = __importDefault(__nccwpck_require__(9491)); +const IS_WINDOWS = process.platform === 'win32'; +/** + * Similar to path.dirname except normalizes the path separators and slightly better handling for Windows UNC paths. + * + * For example, on Linux/macOS: + * - `/ => /` + * - `/hello => /` + * + * For example, on Windows: + * - `C:\ => C:\` + * - `C:\hello => C:\` + * - `C: => C:` + * - `C:hello => C:` + * - `\ => \` + * - `\hello => \` + * - `\\hello => \\hello` + * - `\\hello\world => \\hello\world` + */ +function dirname(p) { + // Normalize slashes and trim unnecessary trailing slash + p = safeTrimTrailingSeparator(p); + // Windows UNC root, e.g. \\hello or \\hello\world + if (IS_WINDOWS && /^\\\\[^\\]+(\\[^\\]+)?$/.test(p)) { + return p; + } + // Get dirname + let result = path.dirname(p); + // Trim trailing slash for Windows UNC root, e.g. \\hello\world\ + if (IS_WINDOWS && /^\\\\[^\\]+\\[^\\]+\\$/.test(result)) { + result = safeTrimTrailingSeparator(result); + } + return result; +} +exports.dirname = dirname; +/** + * Roots the path if not already rooted. On Windows, relative roots like `\` + * or `C:` are expanded based on the current working directory. + */ +function ensureAbsoluteRoot(root, itemPath) { + assert_1.default(root, `ensureAbsoluteRoot parameter 'root' must not be empty`); + assert_1.default(itemPath, `ensureAbsoluteRoot parameter 'itemPath' must not be empty`); + // Already rooted + if (hasAbsoluteRoot(itemPath)) { + return itemPath; + } + // Windows + if (IS_WINDOWS) { + // Check for itemPath like C: or C:foo + if (itemPath.match(/^[A-Z]:[^\\/]|^[A-Z]:$/i)) { + let cwd = process.cwd(); + assert_1.default(cwd.match(/^[A-Z]:\\/i), `Expected current directory to start with an absolute drive root. Actual '${cwd}'`); + // Drive letter matches cwd? Expand to cwd + if (itemPath[0].toUpperCase() === cwd[0].toUpperCase()) { + // Drive only, e.g. C: + if (itemPath.length === 2) { + // Preserve specified drive letter case (upper or lower) + return `${itemPath[0]}:\\${cwd.substr(3)}`; + } + // Drive + path, e.g. C:foo + else { + if (!cwd.endsWith('\\')) { + cwd += '\\'; + } + // Preserve specified drive letter case (upper or lower) + return `${itemPath[0]}:\\${cwd.substr(3)}${itemPath.substr(2)}`; + } + } + // Different drive + else { + return `${itemPath[0]}:\\${itemPath.substr(2)}`; + } + } + // Check for itemPath like \ or \foo + else if (normalizeSeparators(itemPath).match(/^\\$|^\\[^\\]/)) { + const cwd = process.cwd(); + assert_1.default(cwd.match(/^[A-Z]:\\/i), `Expected current directory to start with an absolute drive root. Actual '${cwd}'`); + return `${cwd[0]}:\\${itemPath.substr(1)}`; + } + } + assert_1.default(hasAbsoluteRoot(root), `ensureAbsoluteRoot parameter 'root' must have an absolute root`); + // Otherwise ensure root ends with a separator + if (root.endsWith('/') || (IS_WINDOWS && root.endsWith('\\'))) { + // Intentionally empty + } + else { + // Append separator + root += path.sep; + } + return root + itemPath; +} +exports.ensureAbsoluteRoot = ensureAbsoluteRoot; +/** + * On Linux/macOS, true if path starts with `/`. On Windows, true for paths like: + * `\\hello\share` and `C:\hello` (and using alternate separator). + */ +function hasAbsoluteRoot(itemPath) { + assert_1.default(itemPath, `hasAbsoluteRoot parameter 'itemPath' must not be empty`); + // Normalize separators + itemPath = normalizeSeparators(itemPath); + // Windows + if (IS_WINDOWS) { + // E.g. \\hello\share or C:\hello + return itemPath.startsWith('\\\\') || /^[A-Z]:\\/i.test(itemPath); + } + // E.g. /hello + return itemPath.startsWith('/'); +} +exports.hasAbsoluteRoot = hasAbsoluteRoot; +/** + * On Linux/macOS, true if path starts with `/`. On Windows, true for paths like: + * `\`, `\hello`, `\\hello\share`, `C:`, and `C:\hello` (and using alternate separator). + */ +function hasRoot(itemPath) { + assert_1.default(itemPath, `isRooted parameter 'itemPath' must not be empty`); + // Normalize separators + itemPath = normalizeSeparators(itemPath); + // Windows + if (IS_WINDOWS) { + // E.g. \ or \hello or \\hello + // E.g. C: or C:\hello + return itemPath.startsWith('\\') || /^[A-Z]:/i.test(itemPath); + } + // E.g. /hello + return itemPath.startsWith('/'); +} +exports.hasRoot = hasRoot; +/** + * Removes redundant slashes and converts `/` to `\` on Windows + */ +function normalizeSeparators(p) { + p = p || ''; + // Windows + if (IS_WINDOWS) { + // Convert slashes on Windows + p = p.replace(/\//g, '\\'); + // Remove redundant slashes + const isUnc = /^\\\\+[^\\]/.test(p); // e.g. \\hello + return (isUnc ? '\\' : '') + p.replace(/\\\\+/g, '\\'); // preserve leading \\ for UNC + } + // Remove redundant slashes + return p.replace(/\/\/+/g, '/'); +} +exports.normalizeSeparators = normalizeSeparators; +/** + * Normalizes the path separators and trims the trailing separator (when safe). + * For example, `/foo/ => /foo` but `/ => /` + */ +function safeTrimTrailingSeparator(p) { + // Short-circuit if empty + if (!p) { + return ''; + } + // Normalize separators + p = normalizeSeparators(p); + // No trailing slash + if (!p.endsWith(path.sep)) { + return p; + } + // Check '/' on Linux/macOS and '\' on Windows + if (p === path.sep) { + return p; + } + // On Windows check if drive root. E.g. C:\ + if (IS_WINDOWS && /^[A-Z]:\\$/i.test(p)) { + return p; + } + // Otherwise trim trailing slash + return p.substr(0, p.length - 1); +} +exports.safeTrimTrailingSeparator = safeTrimTrailingSeparator; +//# sourceMappingURL=internal-path-helper.js.map + +/***/ }), + +/***/ 6836: +/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { + +"use strict"; + +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } }); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); +}) : function(o, v) { + o["default"] = v; +}); +var __importStar = (this && this.__importStar) || function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k in mod) if (k !== "default" && Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k); + __setModuleDefault(result, mod); + return result; +}; +var __importDefault = (this && this.__importDefault) || function (mod) { + return (mod && mod.__esModule) ? mod : { "default": mod }; +}; +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.Path = void 0; +const path = __importStar(__nccwpck_require__(1017)); +const pathHelper = __importStar(__nccwpck_require__(1849)); +const assert_1 = __importDefault(__nccwpck_require__(9491)); +const IS_WINDOWS = process.platform === 'win32'; +/** + * Helper class for parsing paths into segments + */ +class Path { + /** + * Constructs a Path + * @param itemPath Path or array of segments + */ + constructor(itemPath) { + this.segments = []; + // String + if (typeof itemPath === 'string') { + assert_1.default(itemPath, `Parameter 'itemPath' must not be empty`); + // Normalize slashes and trim unnecessary trailing slash + itemPath = pathHelper.safeTrimTrailingSeparator(itemPath); + // Not rooted + if (!pathHelper.hasRoot(itemPath)) { + this.segments = itemPath.split(path.sep); + } + // Rooted + else { + // Add all segments, while not at the root + let remaining = itemPath; + let dir = pathHelper.dirname(remaining); + while (dir !== remaining) { + // Add the segment + const basename = path.basename(remaining); + this.segments.unshift(basename); + // Truncate the last segment + remaining = dir; + dir = pathHelper.dirname(remaining); + } + // Remainder is the root + this.segments.unshift(remaining); + } + } + // Array + else { + // Must not be empty + assert_1.default(itemPath.length > 0, `Parameter 'itemPath' must not be an empty array`); + // Each segment + for (let i = 0; i < itemPath.length; i++) { + let segment = itemPath[i]; + // Must not be empty + assert_1.default(segment, `Parameter 'itemPath' must not contain any empty segments`); + // Normalize slashes + segment = pathHelper.normalizeSeparators(itemPath[i]); + // Root segment + if (i === 0 && pathHelper.hasRoot(segment)) { + segment = pathHelper.safeTrimTrailingSeparator(segment); + assert_1.default(segment === pathHelper.dirname(segment), `Parameter 'itemPath' root segment contains information for multiple segments`); + this.segments.push(segment); + } + // All other segments + else { + // Must not contain slash + assert_1.default(!segment.includes(path.sep), `Parameter 'itemPath' contains unexpected path separators`); + this.segments.push(segment); + } + } + } + } + /** + * Converts the path to it's string representation + */ + toString() { + // First segment + let result = this.segments[0]; + // All others + let skipSlash = result.endsWith(path.sep) || (IS_WINDOWS && /^[A-Z]:$/i.test(result)); + for (let i = 1; i < this.segments.length; i++) { + if (skipSlash) { + skipSlash = false; + } + else { + result += path.sep; + } + result += this.segments[i]; + } + return result; + } +} +exports.Path = Path; +//# sourceMappingURL=internal-path.js.map + +/***/ }), + +/***/ 9005: +/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { + +"use strict"; + +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } }); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); +}) : function(o, v) { + o["default"] = v; +}); +var __importStar = (this && this.__importStar) || function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k in mod) if (k !== "default" && Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k); + __setModuleDefault(result, mod); + return result; +}; +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.partialMatch = exports.match = exports.getSearchPaths = void 0; +const pathHelper = __importStar(__nccwpck_require__(1849)); +const internal_match_kind_1 = __nccwpck_require__(1063); +const IS_WINDOWS = process.platform === 'win32'; +/** + * Given an array of patterns, returns an array of paths to search. + * Duplicates and paths under other included paths are filtered out. + */ +function getSearchPaths(patterns) { + // Ignore negate patterns + patterns = patterns.filter(x => !x.negate); + // Create a map of all search paths + const searchPathMap = {}; + for (const pattern of patterns) { + const key = IS_WINDOWS + ? pattern.searchPath.toUpperCase() + : pattern.searchPath; + searchPathMap[key] = 'candidate'; + } + const result = []; + for (const pattern of patterns) { + // Check if already included + const key = IS_WINDOWS + ? pattern.searchPath.toUpperCase() + : pattern.searchPath; + if (searchPathMap[key] === 'included') { + continue; + } + // Check for an ancestor search path + let foundAncestor = false; + let tempKey = key; + let parent = pathHelper.dirname(tempKey); + while (parent !== tempKey) { + if (searchPathMap[parent]) { + foundAncestor = true; + break; + } + tempKey = parent; + parent = pathHelper.dirname(tempKey); + } + // Include the search pattern in the result + if (!foundAncestor) { + result.push(pattern.searchPath); + searchPathMap[key] = 'included'; + } + } + return result; +} +exports.getSearchPaths = getSearchPaths; +/** + * Matches the patterns against the path + */ +function match(patterns, itemPath) { + let result = internal_match_kind_1.MatchKind.None; + for (const pattern of patterns) { + if (pattern.negate) { + result &= ~pattern.match(itemPath); + } + else { + result |= pattern.match(itemPath); + } + } + return result; +} +exports.match = match; +/** + * Checks whether to descend further into the directory + */ +function partialMatch(patterns, itemPath) { + return patterns.some(x => !x.negate && x.partialMatch(itemPath)); +} +exports.partialMatch = partialMatch; +//# sourceMappingURL=internal-pattern-helper.js.map + +/***/ }), + +/***/ 4536: +/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { + +"use strict"; + +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } }); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); +}) : function(o, v) { + o["default"] = v; +}); +var __importStar = (this && this.__importStar) || function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k in mod) if (k !== "default" && Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k); + __setModuleDefault(result, mod); + return result; +}; +var __importDefault = (this && this.__importDefault) || function (mod) { + return (mod && mod.__esModule) ? mod : { "default": mod }; +}; +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.Pattern = void 0; +const os = __importStar(__nccwpck_require__(2037)); +const path = __importStar(__nccwpck_require__(1017)); +const pathHelper = __importStar(__nccwpck_require__(1849)); +const assert_1 = __importDefault(__nccwpck_require__(9491)); +const minimatch_1 = __nccwpck_require__(3973); +const internal_match_kind_1 = __nccwpck_require__(1063); +const internal_path_1 = __nccwpck_require__(6836); +const IS_WINDOWS = process.platform === 'win32'; +class Pattern { + constructor(patternOrNegate, isImplicitPattern = false, segments, homedir) { + /** + * Indicates whether matches should be excluded from the result set + */ + this.negate = false; + // Pattern overload + let pattern; + if (typeof patternOrNegate === 'string') { + pattern = patternOrNegate.trim(); + } + // Segments overload + else { + // Convert to pattern + segments = segments || []; + assert_1.default(segments.length, `Parameter 'segments' must not empty`); + const root = Pattern.getLiteral(segments[0]); + assert_1.default(root && pathHelper.hasAbsoluteRoot(root), `Parameter 'segments' first element must be a root path`); + pattern = new internal_path_1.Path(segments).toString().trim(); + if (patternOrNegate) { + pattern = `!${pattern}`; + } + } + // Negate + while (pattern.startsWith('!')) { + this.negate = !this.negate; + pattern = pattern.substr(1).trim(); + } + // Normalize slashes and ensures absolute root + pattern = Pattern.fixupPattern(pattern, homedir); + // Segments + this.segments = new internal_path_1.Path(pattern).segments; + // Trailing slash indicates the pattern should only match directories, not regular files + this.trailingSeparator = pathHelper + .normalizeSeparators(pattern) + .endsWith(path.sep); + pattern = pathHelper.safeTrimTrailingSeparator(pattern); + // Search path (literal path prior to the first glob segment) + let foundGlob = false; + const searchSegments = this.segments + .map(x => Pattern.getLiteral(x)) + .filter(x => !foundGlob && !(foundGlob = x === '')); + this.searchPath = new internal_path_1.Path(searchSegments).toString(); + // Root RegExp (required when determining partial match) + this.rootRegExp = new RegExp(Pattern.regExpEscape(searchSegments[0]), IS_WINDOWS ? 'i' : ''); + this.isImplicitPattern = isImplicitPattern; + // Create minimatch + const minimatchOptions = { + dot: true, + nobrace: true, + nocase: IS_WINDOWS, + nocomment: true, + noext: true, + nonegate: true + }; + pattern = IS_WINDOWS ? pattern.replace(/\\/g, '/') : pattern; + this.minimatch = new minimatch_1.Minimatch(pattern, minimatchOptions); + } + /** + * Matches the pattern against the specified path + */ + match(itemPath) { + // Last segment is globstar? + if (this.segments[this.segments.length - 1] === '**') { + // Normalize slashes + itemPath = pathHelper.normalizeSeparators(itemPath); + // Append a trailing slash. Otherwise Minimatch will not match the directory immediately + // preceding the globstar. For example, given the pattern `/foo/**`, Minimatch returns + // false for `/foo` but returns true for `/foo/`. Append a trailing slash to handle that quirk. + if (!itemPath.endsWith(path.sep) && this.isImplicitPattern === false) { + // Note, this is safe because the constructor ensures the pattern has an absolute root. + // For example, formats like C: and C:foo on Windows are resolved to an absolute root. + itemPath = `${itemPath}${path.sep}`; + } + } + else { + // Normalize slashes and trim unnecessary trailing slash + itemPath = pathHelper.safeTrimTrailingSeparator(itemPath); + } + // Match + if (this.minimatch.match(itemPath)) { + return this.trailingSeparator ? internal_match_kind_1.MatchKind.Directory : internal_match_kind_1.MatchKind.All; + } + return internal_match_kind_1.MatchKind.None; + } + /** + * Indicates whether the pattern may match descendants of the specified path + */ + partialMatch(itemPath) { + // Normalize slashes and trim unnecessary trailing slash + itemPath = pathHelper.safeTrimTrailingSeparator(itemPath); + // matchOne does not handle root path correctly + if (pathHelper.dirname(itemPath) === itemPath) { + return this.rootRegExp.test(itemPath); + } + return this.minimatch.matchOne(itemPath.split(IS_WINDOWS ? /\\+/ : /\/+/), this.minimatch.set[0], true); + } + /** + * Escapes glob patterns within a path + */ + static globEscape(s) { + return (IS_WINDOWS ? s : s.replace(/\\/g, '\\\\')) // escape '\' on Linux/macOS + .replace(/(\[)(?=[^/]+\])/g, '[[]') // escape '[' when ']' follows within the path segment + .replace(/\?/g, '[?]') // escape '?' + .replace(/\*/g, '[*]'); // escape '*' + } + /** + * Normalizes slashes and ensures absolute root + */ + static fixupPattern(pattern, homedir) { + // Empty + assert_1.default(pattern, 'pattern cannot be empty'); + // Must not contain `.` segment, unless first segment + // Must not contain `..` segment + const literalSegments = new internal_path_1.Path(pattern).segments.map(x => Pattern.getLiteral(x)); + assert_1.default(literalSegments.every((x, i) => (x !== '.' || i === 0) && x !== '..'), `Invalid pattern '${pattern}'. Relative pathing '.' and '..' is not allowed.`); + // Must not contain globs in root, e.g. Windows UNC path \\foo\b*r + assert_1.default(!pathHelper.hasRoot(pattern) || literalSegments[0], `Invalid pattern '${pattern}'. Root segment must not contain globs.`); + // Normalize slashes + pattern = pathHelper.normalizeSeparators(pattern); + // Replace leading `.` segment + if (pattern === '.' || pattern.startsWith(`.${path.sep}`)) { + pattern = Pattern.globEscape(process.cwd()) + pattern.substr(1); + } + // Replace leading `~` segment + else if (pattern === '~' || pattern.startsWith(`~${path.sep}`)) { + homedir = homedir || os.homedir(); + assert_1.default(homedir, 'Unable to determine HOME directory'); + assert_1.default(pathHelper.hasAbsoluteRoot(homedir), `Expected HOME directory to be a rooted path. Actual '${homedir}'`); + pattern = Pattern.globEscape(homedir) + pattern.substr(1); + } + // Replace relative drive root, e.g. pattern is C: or C:foo + else if (IS_WINDOWS && + (pattern.match(/^[A-Z]:$/i) || pattern.match(/^[A-Z]:[^\\]/i))) { + let root = pathHelper.ensureAbsoluteRoot('C:\\dummy-root', pattern.substr(0, 2)); + if (pattern.length > 2 && !root.endsWith('\\')) { + root += '\\'; + } + pattern = Pattern.globEscape(root) + pattern.substr(2); + } + // Replace relative root, e.g. pattern is \ or \foo + else if (IS_WINDOWS && (pattern === '\\' || pattern.match(/^\\[^\\]/))) { + let root = pathHelper.ensureAbsoluteRoot('C:\\dummy-root', '\\'); + if (!root.endsWith('\\')) { + root += '\\'; + } + pattern = Pattern.globEscape(root) + pattern.substr(1); + } + // Otherwise ensure absolute root + else { + pattern = pathHelper.ensureAbsoluteRoot(Pattern.globEscape(process.cwd()), pattern); + } + return pathHelper.normalizeSeparators(pattern); + } + /** + * Attempts to unescape a pattern segment to create a literal path segment. + * Otherwise returns empty string. + */ + static getLiteral(segment) { + let literal = ''; + for (let i = 0; i < segment.length; i++) { + const c = segment[i]; + // Escape + if (c === '\\' && !IS_WINDOWS && i + 1 < segment.length) { + literal += segment[++i]; + continue; + } + // Wildcard + else if (c === '*' || c === '?') { + return ''; + } + // Character set + else if (c === '[' && i + 1 < segment.length) { + let set = ''; + let closed = -1; + for (let i2 = i + 1; i2 < segment.length; i2++) { + const c2 = segment[i2]; + // Escape + if (c2 === '\\' && !IS_WINDOWS && i2 + 1 < segment.length) { + set += segment[++i2]; + continue; + } + // Closed + else if (c2 === ']') { + closed = i2; + break; + } + // Otherwise + else { + set += c2; + } + } + // Closed? + if (closed >= 0) { + // Cannot convert + if (set.length > 1) { + return ''; + } + // Convert to literal + if (set) { + literal += set; + i = closed; + continue; + } + } + // Otherwise fall thru + } + // Append + literal += c; + } + return literal; + } + /** + * Escapes regexp special characters + * https://javascript.info/regexp-escaping + */ + static regExpEscape(s) { + return s.replace(/[[\\^$.|?*+()]/g, '\\$&'); + } +} +exports.Pattern = Pattern; +//# sourceMappingURL=internal-pattern.js.map + +/***/ }), + +/***/ 9117: +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.SearchState = void 0; +class SearchState { + constructor(path, level) { + this.path = path; + this.level = level; + } +} +exports.SearchState = SearchState; +//# sourceMappingURL=internal-search-state.js.map + +/***/ }), + +/***/ 5526: +/***/ (function(__unused_webpack_module, exports) { + +"use strict"; + +var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { + function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); } + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +}; +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.PersonalAccessTokenCredentialHandler = exports.BearerCredentialHandler = exports.BasicCredentialHandler = void 0; +class BasicCredentialHandler { + constructor(username, password) { + this.username = username; + this.password = password; + } + prepareRequest(options) { + if (!options.headers) { + throw Error('The request has no headers'); + } + options.headers['Authorization'] = `Basic ${Buffer.from(`${this.username}:${this.password}`).toString('base64')}`; + } + // This handler cannot handle 401 + canHandleAuthentication() { + return false; + } + handleAuthentication() { + return __awaiter(this, void 0, void 0, function* () { + throw new Error('not implemented'); + }); + } +} +exports.BasicCredentialHandler = BasicCredentialHandler; +class BearerCredentialHandler { + constructor(token) { + this.token = token; + } + // currently implements pre-authorization + // TODO: support preAuth = false where it hooks on 401 + prepareRequest(options) { + if (!options.headers) { + throw Error('The request has no headers'); + } + options.headers['Authorization'] = `Bearer ${this.token}`; + } + // This handler cannot handle 401 + canHandleAuthentication() { + return false; + } + handleAuthentication() { + return __awaiter(this, void 0, void 0, function* () { + throw new Error('not implemented'); + }); + } +} +exports.BearerCredentialHandler = BearerCredentialHandler; +class PersonalAccessTokenCredentialHandler { + constructor(token) { + this.token = token; + } + // currently implements pre-authorization + // TODO: support preAuth = false where it hooks on 401 + prepareRequest(options) { + if (!options.headers) { + throw Error('The request has no headers'); + } + options.headers['Authorization'] = `Basic ${Buffer.from(`PAT:${this.token}`).toString('base64')}`; + } + // This handler cannot handle 401 + canHandleAuthentication() { + return false; + } + handleAuthentication() { + return __awaiter(this, void 0, void 0, function* () { + throw new Error('not implemented'); + }); + } +} +exports.PersonalAccessTokenCredentialHandler = PersonalAccessTokenCredentialHandler; +//# sourceMappingURL=auth.js.map + +/***/ }), + +/***/ 6255: +/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { + +"use strict"; + +/* eslint-disable @typescript-eslint/no-explicit-any */ +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } }); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); +}) : function(o, v) { + o["default"] = v; +}); +var __importStar = (this && this.__importStar) || function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k in mod) if (k !== "default" && Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k); + __setModuleDefault(result, mod); + return result; +}; +var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { + function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); } + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +}; +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.HttpClient = exports.isHttps = exports.HttpClientResponse = exports.HttpClientError = exports.getProxyUrl = exports.MediaTypes = exports.Headers = exports.HttpCodes = void 0; +const http = __importStar(__nccwpck_require__(3685)); +const https = __importStar(__nccwpck_require__(5687)); +const pm = __importStar(__nccwpck_require__(9835)); +const tunnel = __importStar(__nccwpck_require__(4294)); +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) { + const proxyUrl = pm.getProxyUrl(new URL(serverUrl)); + return proxyUrl ? proxyUrl.href : ''; +} +exports.getProxyUrl = getProxyUrl; +const HttpRedirectCodes = [ + HttpCodes.MovedPermanently, + HttpCodes.ResourceMoved, + HttpCodes.SeeOther, + HttpCodes.TemporaryRedirect, + HttpCodes.PermanentRedirect +]; +const HttpResponseRetryCodes = [ + HttpCodes.BadGateway, + HttpCodes.ServiceUnavailable, + HttpCodes.GatewayTimeout +]; +const RetryableHttpVerbs = ['OPTIONS', 'GET', 'DELETE', 'HEAD']; +const ExponentialBackoffCeiling = 10; +const ExponentialBackoffTimeSlice = 5; +class HttpClientError extends Error { + constructor(message, statusCode) { + super(message); + this.name = 'HttpClientError'; + this.statusCode = statusCode; + Object.setPrototypeOf(this, HttpClientError.prototype); + } +} +exports.HttpClientError = HttpClientError; +class HttpClientResponse { + constructor(message) { + this.message = message; + } + readBody() { + return __awaiter(this, void 0, void 0, function* () { + return new Promise((resolve) => __awaiter(this, void 0, void 0, function* () { + 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) { + const parsedUrl = new URL(requestUrl); + return parsedUrl.protocol === 'https:'; +} +exports.isHttps = isHttps; +class HttpClient { + constructor(userAgent, handlers, requestOptions) { + this._ignoreSslError = false; + this._allowRedirects = true; + this._allowRedirectDowngrade = false; + this._maxRedirects = 50; + this._allowRetries = false; + this._maxRetries = 1; + this._keepAlive = false; + this._disposed = false; + this.userAgent = userAgent; + this.handlers = handlers || []; + this.requestOptions = requestOptions; + if (requestOptions) { + if (requestOptions.ignoreSslError != null) { + this._ignoreSslError = requestOptions.ignoreSslError; + } + this._socketTimeout = requestOptions.socketTimeout; + if (requestOptions.allowRedirects != null) { + this._allowRedirects = requestOptions.allowRedirects; + } + if (requestOptions.allowRedirectDowngrade != null) { + this._allowRedirectDowngrade = requestOptions.allowRedirectDowngrade; + } + if (requestOptions.maxRedirects != null) { + this._maxRedirects = Math.max(requestOptions.maxRedirects, 0); + } + if (requestOptions.keepAlive != null) { + this._keepAlive = requestOptions.keepAlive; + } + if (requestOptions.allowRetries != null) { + this._allowRetries = requestOptions.allowRetries; + } + if (requestOptions.maxRetries != null) { + this._maxRetries = requestOptions.maxRetries; + } + } + } + options(requestUrl, additionalHeaders) { + return __awaiter(this, void 0, void 0, function* () { + return this.request('OPTIONS', requestUrl, null, additionalHeaders || {}); + }); + } + get(requestUrl, additionalHeaders) { + return __awaiter(this, void 0, void 0, function* () { + return this.request('GET', requestUrl, null, additionalHeaders || {}); + }); + } + del(requestUrl, additionalHeaders) { + return __awaiter(this, void 0, void 0, function* () { + return this.request('DELETE', requestUrl, null, additionalHeaders || {}); + }); + } + post(requestUrl, data, additionalHeaders) { + return __awaiter(this, void 0, void 0, function* () { + return this.request('POST', requestUrl, data, additionalHeaders || {}); + }); + } + patch(requestUrl, data, additionalHeaders) { + return __awaiter(this, void 0, void 0, function* () { + return this.request('PATCH', requestUrl, data, additionalHeaders || {}); + }); + } + put(requestUrl, data, additionalHeaders) { + return __awaiter(this, void 0, void 0, function* () { + return this.request('PUT', requestUrl, data, additionalHeaders || {}); + }); + } + head(requestUrl, additionalHeaders) { + return __awaiter(this, void 0, void 0, function* () { + return this.request('HEAD', requestUrl, null, additionalHeaders || {}); + }); + } + sendStream(verb, requestUrl, stream, additionalHeaders) { + return __awaiter(this, void 0, void 0, function* () { + 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 + */ + getJson(requestUrl, additionalHeaders = {}) { + return __awaiter(this, void 0, void 0, function* () { + additionalHeaders[Headers.Accept] = this._getExistingOrDefaultHeader(additionalHeaders, Headers.Accept, MediaTypes.ApplicationJson); + const res = yield this.get(requestUrl, additionalHeaders); + return this._processResponse(res, this.requestOptions); + }); + } + postJson(requestUrl, obj, additionalHeaders = {}) { + return __awaiter(this, void 0, void 0, function* () { + const 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); + const res = yield this.post(requestUrl, data, additionalHeaders); + return this._processResponse(res, this.requestOptions); + }); + } + putJson(requestUrl, obj, additionalHeaders = {}) { + return __awaiter(this, void 0, void 0, function* () { + const 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); + const res = yield this.put(requestUrl, data, additionalHeaders); + return this._processResponse(res, this.requestOptions); + }); + } + patchJson(requestUrl, obj, additionalHeaders = {}) { + return __awaiter(this, void 0, void 0, function* () { + const 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); + const res = yield 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 + */ + request(verb, requestUrl, data, headers) { + return __awaiter(this, void 0, void 0, function* () { + if (this._disposed) { + throw new Error('Client has already been disposed.'); + } + const parsedUrl = new URL(requestUrl); + let info = this._prepareRequest(verb, parsedUrl, headers); + // Only perform retries on reads since writes may not be idempotent. + const maxTries = this._allowRetries && RetryableHttpVerbs.includes(verb) + ? this._maxRetries + 1 + : 1; + let numTries = 0; + let response; + do { + response = yield this.requestRaw(info, data); + // Check if it's an authentication challenge + if (response && + response.message && + response.message.statusCode === HttpCodes.Unauthorized) { + let authenticationHandler; + for (const handler of this.handlers) { + if (handler.canHandleAuthentication(response)) { + authenticationHandler = handler; + 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 (response.message.statusCode && + HttpRedirectCodes.includes(response.message.statusCode) && + this._allowRedirects && + redirectsRemaining > 0) { + const redirectUrl = response.message.headers['location']; + if (!redirectUrl) { + // if there's no location to redirect to, we won't + break; + } + const parsedRedirectUrl = new URL(redirectUrl); + if (parsedUrl.protocol === 'https:' && + parsedUrl.protocol !== parsedRedirectUrl.protocol && + !this._allowRedirectDowngrade) { + throw new Error('Redirect from HTTPS to HTTP protocol. This downgrade is not allowed for security reasons. If you want to allow this behavior, set the allowRedirectDowngrade option to true.'); + } + // we need to finish reading the response before reassigning response + // which will leak the open socket. + yield response.readBody(); + // strip authorization header if redirected to a different hostname + if (parsedRedirectUrl.hostname !== parsedUrl.hostname) { + for (const header in headers) { + // header names are case insensitive + if (header.toLowerCase() === 'authorization') { + delete headers[header]; + } + } + } + // let's make the request with the new redirectUrl + info = this._prepareRequest(verb, parsedRedirectUrl, headers); + response = yield this.requestRaw(info, data); + redirectsRemaining--; + } + if (!response.message.statusCode || + !HttpResponseRetryCodes.includes(response.message.statusCode)) { + // If not a retry code, return immediately instead of retrying + return response; + } + numTries += 1; + if (numTries < maxTries) { + yield response.readBody(); + yield this._performExponentialBackoff(numTries); + } + } while (numTries < maxTries); + 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 __awaiter(this, void 0, void 0, function* () { + return new Promise((resolve, reject) => { + function callbackForResult(err, res) { + if (err) { + reject(err); + } + else if (!res) { + // If `err` is not passed, then `res` must be passed. + reject(new Error('Unknown error')); + } + else { + resolve(res); + } + } + this.requestRawWithCallback(info, data, callbackForResult); + }); + }); + } + /** + * Raw request with callback. + * @param info + * @param data + * @param onResult + */ + requestRawWithCallback(info, data, onResult) { + if (typeof data === 'string') { + if (!info.options.headers) { + info.options.headers = {}; + } + info.options.headers['Content-Length'] = Buffer.byteLength(data, 'utf8'); + } + let callbackCalled = false; + function handleResult(err, res) { + if (!callbackCalled) { + callbackCalled = true; + onResult(err, res); + } + } + const req = info.httpModule.request(info.options, (msg) => { + const res = new HttpClientResponse(msg); + handleResult(undefined, res); + }); + let socket; + 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}`)); + }); + req.on('error', function (err) { + // err has statusCode property + // res should have headers + handleResult(err); + }); + 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) { + const parsedUrl = new URL(serverUrl); + return this._getAgent(parsedUrl); + } + _prepareRequest(method, requestUrl, headers) { + const info = {}; + info.parsedUrl = requestUrl; + const usingSsl = info.parsedUrl.protocol === 'https:'; + info.httpModule = usingSsl ? https : http; + const defaultPort = usingSsl ? 443 : 80; + info.options = {}; + info.options.host = info.parsedUrl.hostname; + info.options.port = info.parsedUrl.port + ? parseInt(info.parsedUrl.port) + : defaultPort; + info.options.path = + (info.parsedUrl.pathname || '') + (info.parsedUrl.search || ''); + info.options.method = method; + info.options.headers = this._mergeHeaders(headers); + if (this.userAgent != null) { + info.options.headers['user-agent'] = this.userAgent; + } + info.options.agent = this._getAgent(info.parsedUrl); + // gives handlers an opportunity to participate + if (this.handlers) { + for (const handler of this.handlers) { + handler.prepareRequest(info.options); + } + } + return info; + } + _mergeHeaders(headers) { + if (this.requestOptions && this.requestOptions.headers) { + return Object.assign({}, lowercaseKeys(this.requestOptions.headers), lowercaseKeys(headers || {})); + } + return lowercaseKeys(headers || {}); + } + _getExistingOrDefaultHeader(additionalHeaders, header, _default) { + let clientHeader; + if (this.requestOptions && this.requestOptions.headers) { + clientHeader = lowercaseKeys(this.requestOptions.headers)[header]; + } + return additionalHeaders[header] || clientHeader || _default; + } + _getAgent(parsedUrl) { + let agent; + const proxyUrl = pm.getProxyUrl(parsedUrl); + const 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; + } + // This is `useProxy` again, but we need to check `proxyURl` directly for TypeScripts's flow analysis. + if (proxyUrl && proxyUrl.hostname) { + const agentOptions = { + maxSockets, + keepAlive: this._keepAlive, + proxy: Object.assign(Object.assign({}, ((proxyUrl.username || proxyUrl.password) && { + proxyAuth: `${proxyUrl.username}:${proxyUrl.password}` + })), { host: proxyUrl.hostname, port: proxyUrl.port }) + }; + let tunnelAgent; + const overHttps = proxyUrl.protocol === 'https:'; + if (usingSsl) { + tunnelAgent = overHttps ? tunnel.httpsOverHttps : tunnel.httpsOverHttp; + } + else { + tunnelAgent = overHttps ? tunnel.httpOverHttps : tunnel.httpOverHttp; + } + agent = tunnelAgent(agentOptions); + this._proxyAgent = agent; + } + // if reusing agent across request and tunneling agent isn't assigned create a new agent + if (this._keepAlive && !agent) { + const options = { keepAlive: this._keepAlive, maxSockets }; + 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) { + return __awaiter(this, void 0, void 0, function* () { + retryNumber = Math.min(ExponentialBackoffCeiling, retryNumber); + const ms = ExponentialBackoffTimeSlice * Math.pow(2, retryNumber); + return new Promise(resolve => setTimeout(() => resolve(), ms)); + }); + } + _processResponse(res, options) { + return __awaiter(this, void 0, void 0, function* () { + return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () { + const statusCode = res.message.statusCode || 0; + const response = { + statusCode, + result: null, + headers: {} + }; + // not found leads to null obj returned + if (statusCode === HttpCodes.NotFound) { + resolve(response); + } + // get the result from the body + function dateTimeDeserializer(key, value) { + if (typeof value === 'string') { + const a = new Date(value); + if (!isNaN(a.valueOf())) { + return a; + } + } + return value; + } + let obj; + let contents; + try { + contents = yield res.readBody(); + if (contents && contents.length > 0) { + if (options && options.deserializeDates) { + obj = JSON.parse(contents, 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})`; + } + const err = new HttpClientError(msg, statusCode); + err.result = response.result; + reject(err); + } + else { + resolve(response); + } + })); + }); + } +} +exports.HttpClient = HttpClient; +const lowercaseKeys = (obj) => Object.keys(obj).reduce((c, k) => ((c[k.toLowerCase()] = obj[k]), c), {}); +//# sourceMappingURL=index.js.map + +/***/ }), + +/***/ 9835: +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.checkBypass = exports.getProxyUrl = void 0; +function getProxyUrl(reqUrl) { + const usingSsl = reqUrl.protocol === 'https:'; + if (checkBypass(reqUrl)) { + return undefined; + } + const proxyVar = (() => { + if (usingSsl) { + return process.env['https_proxy'] || process.env['HTTPS_PROXY']; + } + else { + return process.env['http_proxy'] || process.env['HTTP_PROXY']; + } + })(); + if (proxyVar) { + return new URL(proxyVar); + } + else { + return undefined; + } +} +exports.getProxyUrl = getProxyUrl; +function checkBypass(reqUrl) { + if (!reqUrl.hostname) { + return false; + } + const reqHost = reqUrl.hostname; + if (isLoopbackAddress(reqHost)) { + return true; + } + const 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 + const upperReqHosts = [reqUrl.hostname.toUpperCase()]; + if (typeof reqPort === 'number') { + upperReqHosts.push(`${upperReqHosts[0]}:${reqPort}`); + } + // Compare request host against noproxy + for (const upperNoProxyItem of noProxy + .split(',') + .map(x => x.trim().toUpperCase()) + .filter(x => x)) { + if (upperNoProxyItem === '*' || + upperReqHosts.some(x => x === upperNoProxyItem || + x.endsWith(`.${upperNoProxyItem}`) || + (upperNoProxyItem.startsWith('.') && + x.endsWith(`${upperNoProxyItem}`)))) { + return true; + } + } + return false; +} +exports.checkBypass = checkBypass; +function isLoopbackAddress(host) { + const hostLower = host.toLowerCase(); + return (hostLower === 'localhost' || + hostLower.startsWith('127.') || + hostLower.startsWith('[::1]') || + hostLower.startsWith('[0:0:0:0:0:0:0:1]')); +} +//# sourceMappingURL=proxy.js.map + +/***/ }), + +/***/ 334: +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + + +Object.defineProperty(exports, "__esModule", ({ value: true })); + +const REGEX_IS_INSTALLATION_LEGACY = /^v1\./; +const REGEX_IS_INSTALLATION = /^ghs_/; +const REGEX_IS_USER_TO_SERVER = /^ghu_/; +async function auth(token) { + const isApp = token.split(/\./).length === 3; + const isInstallation = REGEX_IS_INSTALLATION_LEGACY.test(token) || REGEX_IS_INSTALLATION.test(token); + const isUserToServer = REGEX_IS_USER_TO_SERVER.test(token); + const tokenType = isApp ? "app" : isInstallation ? "installation" : isUserToServer ? "user-to-server" : "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 + + +/***/ }), + +/***/ 6762: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + + +Object.defineProperty(exports, "__esModule", ({ value: true })); + +var universalUserAgent = __nccwpck_require__(5030); +var beforeAfterHook = __nccwpck_require__(3682); +var request = __nccwpck_require__(6234); +var graphql = __nccwpck_require__(8467); +var authToken = __nccwpck_require__(334); + +const VERSION = "4.2.0"; + +class Octokit { + constructor(options = {}) { + const hook = new beforeAfterHook.Collection(); + const requestDefaults = { + baseUrl: request.request.endpoint.DEFAULTS.baseUrl, + headers: {}, + request: Object.assign({}, options.request, { + // @ts-ignore internal usage only, no need to type + hook: hook.bind(null, "request") + }), + mediaType: { + previews: [], + format: "" + } + }; // prepend default user agent with `options.userAgent` if set + + requestDefaults.headers["user-agent"] = [options.userAgent, `octokit-core.js/${VERSION} ${universalUserAgent.getUserAgent()}`].filter(Boolean).join(" "); + + if (options.baseUrl) { + requestDefaults.baseUrl = options.baseUrl; + } + + if (options.previews) { + requestDefaults.mediaType.previews = options.previews; + } + + if (options.timeZone) { + requestDefaults.headers["time-zone"] = options.timeZone; + } + + this.request = request.request.defaults(requestDefaults); + this.graphql = graphql.withCustomRequest(this.request).defaults(requestDefaults); + this.log = Object.assign({ + debug: () => {}, + info: () => {}, + warn: console.warn.bind(console), + error: console.error.bind(console) + }, options.log); + this.hook = hook; // (1) If neither `options.authStrategy` nor `options.auth` are set, the `octokit` instance + // is unauthenticated. The `this.auth()` method is a no-op and no request hook is registered. + // (2) If only `options.auth` is set, use the default token authentication strategy. + // (3) If `options.authStrategy` is set then use it and pass in `options.auth`. Always pass own request as many strategies accept a custom request instance. + // TODO: type `options.auth` based on `options.authStrategy`. + + if (!options.authStrategy) { + if (!options.auth) { + // (1) + this.auth = async () => ({ + type: "unauthenticated" + }); + } else { + // (2) + const auth = authToken.createTokenAuth(options.auth); // @ts-ignore ¯\_(ツ)_/¯ + + hook.wrap("request", auth.hook); + this.auth = auth; + } + } else { + const { + authStrategy, + ...otherOptions + } = options; + const auth = authStrategy(Object.assign({ + request: this.request, + log: this.log, + // we pass the current octokit instance as well as its constructor options + // to allow for authentication strategies that return a new octokit instance + // that shares the same internal state as the current one. The original + // requirement for this was the "event-octokit" authentication strategy + // of https://github.com/probot/octokit-auth-probot. + octokit: this, + octokitOptions: otherOptions + }, options.auth)); // @ts-ignore ¯\_(ツ)_/¯ + + hook.wrap("request", auth.hook); + this.auth = auth; + } // apply plugins + // https://stackoverflow.com/a/16345172 + + + const classConstructor = this.constructor; + classConstructor.plugins.forEach(plugin => { + Object.assign(this, plugin(this, options)); + }); + } + + static defaults(defaults) { + const OctokitWithDefaults = class extends this { + constructor(...args) { + const options = args[0] || {}; + + if (typeof defaults === "function") { + super(defaults(options)); + return; + } + + super(Object.assign({}, defaults, options, options.userAgent && defaults.userAgent ? { + userAgent: `${options.userAgent} ${defaults.userAgent}` + } : null)); + } + + }; + return OctokitWithDefaults; + } + /** + * Attach a plugin (or many) to your Octokit instance. + * + * @example + * const API = Octokit.plugin(plugin1, plugin2, plugin3, ...) + */ + + + static plugin(...newPlugins) { + var _a; + + const currentPlugins = this.plugins; + const NewOctokit = (_a = class extends this {}, _a.plugins = currentPlugins.concat(newPlugins.filter(plugin => !currentPlugins.includes(plugin))), _a); + return NewOctokit; + } + +} +Octokit.VERSION = VERSION; +Octokit.plugins = []; + +exports.Octokit = Octokit; +//# sourceMappingURL=index.js.map + + +/***/ }), + +/***/ 9440: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + + +Object.defineProperty(exports, "__esModule", ({ value: true })); + +var isPlainObject = __nccwpck_require__(3287); +var universalUserAgent = __nccwpck_require__(5030); + +function lowercaseKeys(object) { + if (!object) { + return {}; + } + return Object.keys(object).reduce((newObj, key) => { + newObj[key.toLowerCase()] = object[key]; + return newObj; + }, {}); +} + +function mergeDeep(defaults, options) { + const result = Object.assign({}, defaults); + Object.keys(options).forEach(key => { + if (isPlainObject.isPlainObject(options[key])) { + if (!(key in defaults)) Object.assign(result, { + [key]: options[key] + });else result[key] = mergeDeep(defaults[key], options[key]); + } else { + Object.assign(result, { + [key]: options[key] + }); + } + }); + return result; +} + +function removeUndefinedProperties(obj) { + for (const key in obj) { + if (obj[key] === undefined) { + delete obj[key]; + } + } + return obj; +} + +function merge(defaults, route, options) { + if (typeof route === "string") { + let [method, url] = route.split(" "); + options = Object.assign(url ? { + method, + url + } : { + url: method + }, options); + } else { + options = Object.assign({}, route); + } + // lowercase header names before merging with defaults to avoid duplicates + options.headers = lowercaseKeys(options.headers); + // remove properties with undefined values before merging + removeUndefinedProperties(options); + removeUndefinedProperties(options.headers); + const mergedOptions = mergeDeep(defaults || {}, options); + // mediaType.previews arrays are merged, instead of overwritten + if (defaults && defaults.mediaType.previews.length) { + mergedOptions.mediaType.previews = defaults.mediaType.previews.filter(preview => !mergedOptions.mediaType.previews.includes(preview)).concat(mergedOptions.mediaType.previews); + } + mergedOptions.mediaType.previews = mergedOptions.mediaType.previews.map(preview => preview.replace(/-preview/, "")); + return mergedOptions; +} + +function addQueryParameters(url, parameters) { + const separator = /\?/.test(url) ? "&" : "?"; + const names = Object.keys(parameters); + if (names.length === 0) { + return url; + } + return url + separator + names.map(name => { + if (name === "q") { + return "q=" + parameters.q.split("+").map(encodeURIComponent).join("+"); + } + return `${name}=${encodeURIComponent(parameters[name])}`; + }).join("&"); +} + +const urlVariableRegex = /\{[^}]+\}/g; +function removeNonChars(variableName) { + return variableName.replace(/^\W+|\W+$/g, "").split(/,/); +} +function extractUrlVariableNames(url) { + const matches = url.match(urlVariableRegex); + if (!matches) { + return []; + } + return matches.map(removeNonChars).reduce((a, b) => a.concat(b), []); +} + +function omit(object, keysToOmit) { + return Object.keys(object).filter(option => !keysToOmit.includes(option)).reduce((obj, key) => { + obj[key] = object[key]; + return obj; + }, {}); +} + +// Based on https://github.com/bramstein/url-template, licensed under BSD +// TODO: create separate package. +// +// Copyright (c) 2012-2014, Bram Stein +// All rights reserved. +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions +// are met: +// 1. Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// 2. Redistributions in binary form must reproduce the above copyright +// notice, this list of conditions and the following disclaimer in the +// documentation and/or other materials provided with the distribution. +// 3. The name of the author may not be used to endorse or promote products +// derived from this software without specific prior written permission. +// THIS SOFTWARE IS PROVIDED BY THE AUTHOR "AS IS" AND ANY EXPRESS OR IMPLIED +// WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF +// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO +// EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, +// INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, +// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY +// OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING +// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, +// EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +/* istanbul ignore file */ +function encodeReserved(str) { + return str.split(/(%[0-9A-Fa-f]{2})/g).map(function (part) { + if (!/%[0-9A-Fa-f]/.test(part)) { + part = encodeURI(part).replace(/%5B/g, "[").replace(/%5D/g, "]"); + } + return part; + }).join(""); +} +function encodeUnreserved(str) { + return encodeURIComponent(str).replace(/[!'()*]/g, function (c) { + return "%" + c.charCodeAt(0).toString(16).toUpperCase(); + }); +} +function encodeValue(operator, value, key) { + value = operator === "+" || operator === "#" ? encodeReserved(value) : encodeUnreserved(value); + if (key) { + return encodeUnreserved(key) + "=" + value; + } else { + return value; + } +} +function isDefined(value) { + return value !== undefined && value !== null; +} +function isKeyOperator(operator) { + return operator === ";" || operator === "&" || operator === "?"; +} +function getValues(context, operator, key, modifier) { + var value = context[key], + result = []; + if (isDefined(value) && value !== "") { + if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") { + value = value.toString(); + if (modifier && modifier !== "*") { + value = value.substring(0, parseInt(modifier, 10)); + } + result.push(encodeValue(operator, value, isKeyOperator(operator) ? key : "")); + } else { + if (modifier === "*") { + if (Array.isArray(value)) { + value.filter(isDefined).forEach(function (value) { + result.push(encodeValue(operator, value, isKeyOperator(operator) ? key : "")); + }); + } else { + Object.keys(value).forEach(function (k) { + if (isDefined(value[k])) { + result.push(encodeValue(operator, value[k], k)); + } + }); + } + } else { + const tmp = []; + if (Array.isArray(value)) { + value.filter(isDefined).forEach(function (value) { + tmp.push(encodeValue(operator, value)); + }); + } else { + Object.keys(value).forEach(function (k) { + if (isDefined(value[k])) { + tmp.push(encodeUnreserved(k)); + tmp.push(encodeValue(operator, value[k].toString())); + } + }); + } + if (isKeyOperator(operator)) { + result.push(encodeUnreserved(key) + "=" + tmp.join(",")); + } else if (tmp.length !== 0) { + result.push(tmp.join(",")); + } + } + } + } else { + if (operator === ";") { + if (isDefined(value)) { + result.push(encodeUnreserved(key)); + } + } else if (value === "" && (operator === "&" || operator === "?")) { + result.push(encodeUnreserved(key) + "="); + } else if (value === "") { + result.push(""); + } + } + return result; +} +function parseUrl(template) { + return { + expand: expand.bind(null, template) + }; +} +function expand(template, context) { + var operators = ["+", "#", ".", "/", ";", "?", "&"]; + return template.replace(/\{([^\{\}]+)\}|([^\{\}]+)/g, function (_, expression, literal) { + if (expression) { + let operator = ""; + const values = []; + if (operators.indexOf(expression.charAt(0)) !== -1) { + operator = expression.charAt(0); + expression = expression.substr(1); + } + expression.split(/,/g).forEach(function (variable) { + var tmp = /([^:\*]*)(?::(\d+)|(\*))?/.exec(variable); + values.push(getValues(context, operator, tmp[1], tmp[2] || tmp[3])); + }); + if (operator && operator !== "+") { + var separator = ","; + if (operator === "?") { + separator = "&"; + } else if (operator !== "#") { + separator = operator; + } + return (values.length !== 0 ? operator : "") + values.join(separator); + } else { + return values.join(","); + } + } else { + return encodeReserved(literal); + } + }); +} + +function parse(options) { + // https://fetch.spec.whatwg.org/#methods + let method = options.method.toUpperCase(); + // replace :varname with {varname} to make it RFC 6570 compatible + let url = (options.url || "/").replace(/:([a-z]\w+)/g, "{$1}"); + let headers = Object.assign({}, options.headers); + let body; + let parameters = omit(options, ["method", "baseUrl", "url", "headers", "request", "mediaType"]); + // extract variable names from URL to calculate remaining variables later + const urlVariableNames = extractUrlVariableNames(url); + url = parseUrl(url).expand(parameters); + if (!/^http/.test(url)) { + url = options.baseUrl + url; + } + const omittedParameters = Object.keys(options).filter(option => urlVariableNames.includes(option)).concat("baseUrl"); + const remainingParameters = omit(parameters, omittedParameters); + const isBinaryRequest = /application\/octet-stream/i.test(headers.accept); + if (!isBinaryRequest) { + if (options.mediaType.format) { + // e.g. application/vnd.github.v3+json => application/vnd.github.v3.raw + headers.accept = headers.accept.split(/,/).map(preview => preview.replace(/application\/vnd(\.\w+)(\.v3)?(\.\w+)?(\+json)?$/, `application/vnd$1$2.${options.mediaType.format}`)).join(","); + } + if (options.mediaType.previews.length) { + const previewsFromAcceptHeader = headers.accept.match(/[\w-]+(?=-preview)/g) || []; + headers.accept = previewsFromAcceptHeader.concat(options.mediaType.previews).map(preview => { + const format = options.mediaType.format ? `.${options.mediaType.format}` : "+json"; + return `application/vnd.github.${preview}-preview${format}`; + }).join(","); + } + } + // for GET/HEAD requests, set URL query parameters from remaining parameters + // for PATCH/POST/PUT/DELETE requests, set request body from remaining parameters + if (["GET", "HEAD"].includes(method)) { + url = addQueryParameters(url, remainingParameters); + } else { + if ("data" in remainingParameters) { + body = remainingParameters.data; + } else { + if (Object.keys(remainingParameters).length) { + body = remainingParameters; + } + } + } + // 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 = "7.0.5"; + +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 + + +/***/ }), + +/***/ 8467: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + + +Object.defineProperty(exports, "__esModule", ({ value: true })); + +var request = __nccwpck_require__(6234); +var universalUserAgent = __nccwpck_require__(5030); + +const VERSION = "5.0.5"; + +function _buildMessageForResponseErrors(data) { + return `Request failed due to following response errors:\n` + data.errors.map(e => ` - ${e.message}`).join("\n"); +} +class GraphqlResponseError extends Error { + constructor(request, headers, response) { + super(_buildMessageForResponseErrors(response)); + this.request = request; + this.headers = headers; + this.response = response; + this.name = "GraphqlResponseError"; + // Expose the errors and response data in their shorthand properties. + this.errors = response.errors; + this.data = response.data; + // Maintains proper stack trace (only available on V8) + /* istanbul ignore next */ + if (Error.captureStackTrace) { + Error.captureStackTrace(this, this.constructor); + } + } +} + +const NON_VARIABLE_OPTIONS = ["method", "baseUrl", "url", "headers", "request", "query", "mediaType"]; +const FORBIDDEN_VARIABLE_OPTIONS = ["query", "method", "url"]; +const GHES_V3_SUFFIX_REGEX = /\/api\/v3\/?$/; +function graphql(request, query, options) { + if (options) { + if (typeof query === "string" && "query" in options) { + return Promise.reject(new Error(`[@octokit/graphql] "query" cannot be used as variable name`)); + } + for (const key in options) { + if (!FORBIDDEN_VARIABLE_OPTIONS.includes(key)) continue; + return Promise.reject(new Error(`[@octokit/graphql] "${key}" cannot be used as variable name`)); + } + } + const parsedOptions = typeof query === "string" ? Object.assign({ + query + }, options) : query; + const requestOptions = Object.keys(parsedOptions).reduce((result, key) => { + if (NON_VARIABLE_OPTIONS.includes(key)) { + result[key] = parsedOptions[key]; + return result; + } + if (!result.variables) { + result.variables = {}; + } + result.variables[key] = parsedOptions[key]; + return result; + }, {}); + // workaround for GitHub Enterprise baseUrl set with /api/v3 suffix + // https://github.com/octokit/auth-app.js/issues/111#issuecomment-657610451 + const baseUrl = parsedOptions.baseUrl || request.endpoint.DEFAULTS.baseUrl; + if (GHES_V3_SUFFIX_REGEX.test(baseUrl)) { + requestOptions.url = baseUrl.replace(GHES_V3_SUFFIX_REGEX, "/api/graphql"); + } + return request(requestOptions).then(response => { + if (response.data.errors) { + const headers = {}; + for (const key of Object.keys(response.headers)) { + headers[key] = response.headers[key]; + } + throw new GraphqlResponseError(requestOptions, headers, response.data); + } + return response.data.data; + }); +} + +function withDefaults(request, newDefaults) { + const newRequest = request.defaults(newDefaults); + const newApi = (query, options) => { + return graphql(newRequest, query, options); + }; + return Object.assign(newApi, { + defaults: withDefaults.bind(null, newRequest), + endpoint: newRequest.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.GraphqlResponseError = GraphqlResponseError; +exports.graphql = graphql$1; +exports.withCustomRequest = withCustomRequest; +//# sourceMappingURL=index.js.map + + +/***/ }), + +/***/ 4193: +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + + +Object.defineProperty(exports, "__esModule", ({ value: true })); + +const VERSION = "2.21.3"; + +function ownKeys(object, enumerableOnly) { + var keys = Object.keys(object); + + if (Object.getOwnPropertySymbols) { + var symbols = Object.getOwnPropertySymbols(object); + enumerableOnly && (symbols = symbols.filter(function (sym) { + return Object.getOwnPropertyDescriptor(object, sym).enumerable; + })), keys.push.apply(keys, symbols); + } + + return keys; +} + +function _objectSpread2(target) { + for (var i = 1; i < arguments.length; i++) { + var source = null != arguments[i] ? arguments[i] : {}; + i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { + _defineProperty(target, key, source[key]); + }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { + Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); + }); + } + + return target; +} + +function _defineProperty(obj, key, value) { + if (key in obj) { + Object.defineProperty(obj, key, { + value: value, + enumerable: true, + configurable: true, + writable: true + }); + } else { + obj[key] = value; + } + + return obj; +} + +/** + * Some “list” response that can be paginated have a different response structure + * + * They have a `total_count` key in the response (search also has `incomplete_results`, + * /installation/repositories also has `repository_selection`), as well as a key with + * the list of the items which name varies from endpoint to endpoint. + * + * Octokit normalizes these responses so that paginated results are always returned following + * the same structure. One challenge is that if the list response has only one page, no Link + * header is provided, so this header alone is not sufficient to check wether a response is + * paginated or not. + * + * We check if a "total_count" key is present in the response data, but also make sure that + * a "url" property is not, as the "Get the combined status for a specific ref" endpoint would + * otherwise match: https://developer.github.com/v3/repos/statuses/#get-the-combined-status-for-a-specific-ref + */ +function normalizePaginatedListResponse(response) { + // endpoints can respond with 204 if repository is empty + if (!response.data) { + return _objectSpread2(_objectSpread2({}, response), {}, { + data: [] + }); + } + + const responseNeedsNormalization = "total_count" in response.data && !("url" in response.data); + if (!responseNeedsNormalization) return response; // keep the additional properties intact as there is currently no other way + // to retrieve the same information. + + const incompleteResults = response.data.incomplete_results; + const repositorySelection = response.data.repository_selection; + const totalCount = response.data.total_count; + delete response.data.incomplete_results; + delete response.data.repository_selection; + delete response.data.total_count; + const namespaceKey = Object.keys(response.data)[0]; + const data = response.data[namespaceKey]; + response.data = data; + + if (typeof incompleteResults !== "undefined") { + response.data.incomplete_results = incompleteResults; + } + + if (typeof repositorySelection !== "undefined") { + response.data.repository_selection = repositorySelection; + } + + response.data.total_count = totalCount; + return response; +} + +function iterator(octokit, route, parameters) { + const options = typeof route === "function" ? route.endpoint(parameters) : octokit.request.endpoint(route, parameters); + const requestMethod = typeof route === "function" ? route : octokit.request; + const method = options.method; + const headers = options.headers; + let url = options.url; + return { + [Symbol.asyncIterator]: () => ({ + async next() { + if (!url) return { + done: true + }; + + try { + const response = await requestMethod({ + method, + url, + headers + }); + const normalizedResponse = normalizePaginatedListResponse(response); // `response.headers.link` format: + // '; rel="next", ; rel="last"' + // sets `url` to undefined if "next" URL is not present or `link` header is not set + + url = ((normalizedResponse.headers.link || "").match(/<([^>]+)>;\s*rel="next"/) || [])[1]; + return { + value: normalizedResponse + }; + } catch (error) { + if (error.status !== 409) throw error; + url = ""; + return { + value: { + status: 200, + headers: {}, + data: [] + } + }; + } + } + + }) + }; +} + +function paginate(octokit, route, parameters, mapFn) { + if (typeof parameters === "function") { + mapFn = parameters; + parameters = undefined; + } + + return gather(octokit, [], iterator(octokit, route, parameters)[Symbol.asyncIterator](), mapFn); +} + +function gather(octokit, results, iterator, mapFn) { + return iterator.next().then(result => { + if (result.done) { + return results; + } + + let earlyExit = false; + + function done() { + earlyExit = true; + } + + results = results.concat(mapFn ? mapFn(result.value, done) : result.value.data); + + if (earlyExit) { + return results; + } + + return gather(octokit, results, iterator, mapFn); + }); +} + +const composePaginateRest = Object.assign(paginate, { + iterator +}); + +const paginatingEndpoints = ["GET /app/hook/deliveries", "GET /app/installations", "GET /applications/grants", "GET /authorizations", "GET /enterprises/{enterprise}/actions/permissions/organizations", "GET /enterprises/{enterprise}/actions/runner-groups", "GET /enterprises/{enterprise}/actions/runner-groups/{runner_group_id}/organizations", "GET /enterprises/{enterprise}/actions/runner-groups/{runner_group_id}/runners", "GET /enterprises/{enterprise}/actions/runners", "GET /enterprises/{enterprise}/audit-log", "GET /enterprises/{enterprise}/secret-scanning/alerts", "GET /enterprises/{enterprise}/settings/billing/advanced-security", "GET /events", "GET /gists", "GET /gists/public", "GET /gists/starred", "GET /gists/{gist_id}/comments", "GET /gists/{gist_id}/commits", "GET /gists/{gist_id}/forks", "GET /installation/repositories", "GET /issues", "GET /licenses", "GET /marketplace_listing/plans", "GET /marketplace_listing/plans/{plan_id}/accounts", "GET /marketplace_listing/stubbed/plans", "GET /marketplace_listing/stubbed/plans/{plan_id}/accounts", "GET /networks/{owner}/{repo}/events", "GET /notifications", "GET /organizations", "GET /orgs/{org}/actions/cache/usage-by-repository", "GET /orgs/{org}/actions/permissions/repositories", "GET /orgs/{org}/actions/runner-groups", "GET /orgs/{org}/actions/runner-groups/{runner_group_id}/repositories", "GET /orgs/{org}/actions/runner-groups/{runner_group_id}/runners", "GET /orgs/{org}/actions/runners", "GET /orgs/{org}/actions/secrets", "GET /orgs/{org}/actions/secrets/{secret_name}/repositories", "GET /orgs/{org}/audit-log", "GET /orgs/{org}/blocks", "GET /orgs/{org}/code-scanning/alerts", "GET /orgs/{org}/codespaces", "GET /orgs/{org}/credential-authorizations", "GET /orgs/{org}/dependabot/secrets", "GET /orgs/{org}/dependabot/secrets/{secret_name}/repositories", "GET /orgs/{org}/events", "GET /orgs/{org}/external-groups", "GET /orgs/{org}/failed_invitations", "GET /orgs/{org}/hooks", "GET /orgs/{org}/hooks/{hook_id}/deliveries", "GET /orgs/{org}/installations", "GET /orgs/{org}/invitations", "GET /orgs/{org}/invitations/{invitation_id}/teams", "GET /orgs/{org}/issues", "GET /orgs/{org}/members", "GET /orgs/{org}/migrations", "GET /orgs/{org}/migrations/{migration_id}/repositories", "GET /orgs/{org}/outside_collaborators", "GET /orgs/{org}/packages", "GET /orgs/{org}/packages/{package_type}/{package_name}/versions", "GET /orgs/{org}/projects", "GET /orgs/{org}/public_members", "GET /orgs/{org}/repos", "GET /orgs/{org}/secret-scanning/alerts", "GET /orgs/{org}/settings/billing/advanced-security", "GET /orgs/{org}/team-sync/groups", "GET /orgs/{org}/teams", "GET /orgs/{org}/teams/{team_slug}/discussions", "GET /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/comments", "GET /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/comments/{comment_number}/reactions", "GET /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/reactions", "GET /orgs/{org}/teams/{team_slug}/invitations", "GET /orgs/{org}/teams/{team_slug}/members", "GET /orgs/{org}/teams/{team_slug}/projects", "GET /orgs/{org}/teams/{team_slug}/repos", "GET /orgs/{org}/teams/{team_slug}/teams", "GET /projects/columns/{column_id}/cards", "GET /projects/{project_id}/collaborators", "GET /projects/{project_id}/columns", "GET /repos/{owner}/{repo}/actions/artifacts", "GET /repos/{owner}/{repo}/actions/caches", "GET /repos/{owner}/{repo}/actions/runners", "GET /repos/{owner}/{repo}/actions/runs", "GET /repos/{owner}/{repo}/actions/runs/{run_id}/artifacts", "GET /repos/{owner}/{repo}/actions/runs/{run_id}/attempts/{attempt_number}/jobs", "GET /repos/{owner}/{repo}/actions/runs/{run_id}/jobs", "GET /repos/{owner}/{repo}/actions/secrets", "GET /repos/{owner}/{repo}/actions/workflows", "GET /repos/{owner}/{repo}/actions/workflows/{workflow_id}/runs", "GET /repos/{owner}/{repo}/assignees", "GET /repos/{owner}/{repo}/branches", "GET /repos/{owner}/{repo}/check-runs/{check_run_id}/annotations", "GET /repos/{owner}/{repo}/check-suites/{check_suite_id}/check-runs", "GET /repos/{owner}/{repo}/code-scanning/alerts", "GET /repos/{owner}/{repo}/code-scanning/alerts/{alert_number}/instances", "GET /repos/{owner}/{repo}/code-scanning/analyses", "GET /repos/{owner}/{repo}/codespaces", "GET /repos/{owner}/{repo}/codespaces/devcontainers", "GET /repos/{owner}/{repo}/codespaces/secrets", "GET /repos/{owner}/{repo}/collaborators", "GET /repos/{owner}/{repo}/comments", "GET /repos/{owner}/{repo}/comments/{comment_id}/reactions", "GET /repos/{owner}/{repo}/commits", "GET /repos/{owner}/{repo}/commits/{commit_sha}/comments", "GET /repos/{owner}/{repo}/commits/{commit_sha}/pulls", "GET /repos/{owner}/{repo}/commits/{ref}/check-runs", "GET /repos/{owner}/{repo}/commits/{ref}/check-suites", "GET /repos/{owner}/{repo}/commits/{ref}/status", "GET /repos/{owner}/{repo}/commits/{ref}/statuses", "GET /repos/{owner}/{repo}/contributors", "GET /repos/{owner}/{repo}/dependabot/secrets", "GET /repos/{owner}/{repo}/deployments", "GET /repos/{owner}/{repo}/deployments/{deployment_id}/statuses", "GET /repos/{owner}/{repo}/environments", "GET /repos/{owner}/{repo}/events", "GET /repos/{owner}/{repo}/forks", "GET /repos/{owner}/{repo}/git/matching-refs/{ref}", "GET /repos/{owner}/{repo}/hooks", "GET /repos/{owner}/{repo}/hooks/{hook_id}/deliveries", "GET /repos/{owner}/{repo}/invitations", "GET /repos/{owner}/{repo}/issues", "GET /repos/{owner}/{repo}/issues/comments", "GET /repos/{owner}/{repo}/issues/comments/{comment_id}/reactions", "GET /repos/{owner}/{repo}/issues/events", "GET /repos/{owner}/{repo}/issues/{issue_number}/comments", "GET /repos/{owner}/{repo}/issues/{issue_number}/events", "GET /repos/{owner}/{repo}/issues/{issue_number}/labels", "GET /repos/{owner}/{repo}/issues/{issue_number}/reactions", "GET /repos/{owner}/{repo}/issues/{issue_number}/timeline", "GET /repos/{owner}/{repo}/keys", "GET /repos/{owner}/{repo}/labels", "GET /repos/{owner}/{repo}/milestones", "GET /repos/{owner}/{repo}/milestones/{milestone_number}/labels", "GET /repos/{owner}/{repo}/notifications", "GET /repos/{owner}/{repo}/pages/builds", "GET /repos/{owner}/{repo}/projects", "GET /repos/{owner}/{repo}/pulls", "GET /repos/{owner}/{repo}/pulls/comments", "GET /repos/{owner}/{repo}/pulls/comments/{comment_id}/reactions", "GET /repos/{owner}/{repo}/pulls/{pull_number}/comments", "GET /repos/{owner}/{repo}/pulls/{pull_number}/commits", "GET /repos/{owner}/{repo}/pulls/{pull_number}/files", "GET /repos/{owner}/{repo}/pulls/{pull_number}/requested_reviewers", "GET /repos/{owner}/{repo}/pulls/{pull_number}/reviews", "GET /repos/{owner}/{repo}/pulls/{pull_number}/reviews/{review_id}/comments", "GET /repos/{owner}/{repo}/releases", "GET /repos/{owner}/{repo}/releases/{release_id}/assets", "GET /repos/{owner}/{repo}/releases/{release_id}/reactions", "GET /repos/{owner}/{repo}/secret-scanning/alerts", "GET /repos/{owner}/{repo}/secret-scanning/alerts/{alert_number}/locations", "GET /repos/{owner}/{repo}/stargazers", "GET /repos/{owner}/{repo}/subscribers", "GET /repos/{owner}/{repo}/tags", "GET /repos/{owner}/{repo}/teams", "GET /repos/{owner}/{repo}/topics", "GET /repositories", "GET /repositories/{repository_id}/environments/{environment_name}/secrets", "GET /search/code", "GET /search/commits", "GET /search/issues", "GET /search/labels", "GET /search/repositories", "GET /search/topics", "GET /search/users", "GET /teams/{team_id}/discussions", "GET /teams/{team_id}/discussions/{discussion_number}/comments", "GET /teams/{team_id}/discussions/{discussion_number}/comments/{comment_number}/reactions", "GET /teams/{team_id}/discussions/{discussion_number}/reactions", "GET /teams/{team_id}/invitations", "GET /teams/{team_id}/members", "GET /teams/{team_id}/projects", "GET /teams/{team_id}/repos", "GET /teams/{team_id}/teams", "GET /user/blocks", "GET /user/codespaces", "GET /user/codespaces/secrets", "GET /user/emails", "GET /user/followers", "GET /user/following", "GET /user/gpg_keys", "GET /user/installations", "GET /user/installations/{installation_id}/repositories", "GET /user/issues", "GET /user/keys", "GET /user/marketplace_purchases", "GET /user/marketplace_purchases/stubbed", "GET /user/memberships/orgs", "GET /user/migrations", "GET /user/migrations/{migration_id}/repositories", "GET /user/orgs", "GET /user/packages", "GET /user/packages/{package_type}/{package_name}/versions", "GET /user/public_emails", "GET /user/repos", "GET /user/repository_invitations", "GET /user/starred", "GET /user/subscriptions", "GET /user/teams", "GET /users", "GET /users/{username}/events", "GET /users/{username}/events/orgs/{org}", "GET /users/{username}/events/public", "GET /users/{username}/followers", "GET /users/{username}/following", "GET /users/{username}/gists", "GET /users/{username}/gpg_keys", "GET /users/{username}/keys", "GET /users/{username}/orgs", "GET /users/{username}/packages", "GET /users/{username}/projects", "GET /users/{username}/received_events", "GET /users/{username}/received_events/public", "GET /users/{username}/repos", "GET /users/{username}/starred", "GET /users/{username}/subscriptions"]; + +function isPaginatingEndpoint(arg) { + if (typeof arg === "string") { + return paginatingEndpoints.includes(arg); + } else { + return false; + } +} + +/** + * @param octokit Octokit instance + * @param options Options passed to Octokit constructor + */ + +function paginateRest(octokit) { + return { + paginate: Object.assign(paginate.bind(null, octokit), { + iterator: iterator.bind(null, octokit) + }) + }; +} +paginateRest.VERSION = VERSION; + +exports.composePaginateRest = composePaginateRest; +exports.isPaginatingEndpoint = isPaginatingEndpoint; +exports.paginateRest = paginateRest; +exports.paginatingEndpoints = paginatingEndpoints; +//# sourceMappingURL=index.js.map + + +/***/ }), + +/***/ 8883: +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + + +Object.defineProperty(exports, "__esModule", ({ value: true })); + +const VERSION = "1.0.4"; + +/** + * @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 + + +/***/ }), + +/***/ 3044: +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + + +Object.defineProperty(exports, "__esModule", ({ value: true })); + +function ownKeys(object, enumerableOnly) { + var keys = Object.keys(object); + + if (Object.getOwnPropertySymbols) { + var symbols = Object.getOwnPropertySymbols(object); + + if (enumerableOnly) { + symbols = symbols.filter(function (sym) { + return Object.getOwnPropertyDescriptor(object, sym).enumerable; + }); + } + + keys.push.apply(keys, symbols); + } + + return keys; +} + +function _objectSpread2(target) { + for (var i = 1; i < arguments.length; i++) { + var source = arguments[i] != null ? arguments[i] : {}; + + if (i % 2) { + ownKeys(Object(source), true).forEach(function (key) { + _defineProperty(target, key, source[key]); + }); + } else if (Object.getOwnPropertyDescriptors) { + Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); + } else { + ownKeys(Object(source)).forEach(function (key) { + Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); + }); + } + } + + return target; +} + +function _defineProperty(obj, key, value) { + if (key in obj) { + Object.defineProperty(obj, key, { + value: value, + enumerable: true, + configurable: true, + writable: true + }); + } else { + obj[key] = value; + } + + return obj; +} + +const Endpoints = { + actions: { + addCustomLabelsToSelfHostedRunnerForOrg: ["POST /orgs/{org}/actions/runners/{runner_id}/labels"], + addCustomLabelsToSelfHostedRunnerForRepo: ["POST /repos/{owner}/{repo}/actions/runners/{runner_id}/labels"], + addSelectedRepoToOrgSecret: ["PUT /orgs/{org}/actions/secrets/{secret_name}/repositories/{repository_id}"], + approveWorkflowRun: ["POST /repos/{owner}/{repo}/actions/runs/{run_id}/approve"], + cancelWorkflowRun: ["POST /repos/{owner}/{repo}/actions/runs/{run_id}/cancel"], + createOrUpdateEnvironmentSecret: ["PUT /repositories/{repository_id}/environments/{environment_name}/secrets/{secret_name}"], + createOrUpdateOrgSecret: ["PUT /orgs/{org}/actions/secrets/{secret_name}"], + createOrUpdateRepoSecret: ["PUT /repos/{owner}/{repo}/actions/secrets/{secret_name}"], + createRegistrationTokenForOrg: ["POST /orgs/{org}/actions/runners/registration-token"], + createRegistrationTokenForRepo: ["POST /repos/{owner}/{repo}/actions/runners/registration-token"], + createRemoveTokenForOrg: ["POST /orgs/{org}/actions/runners/remove-token"], + createRemoveTokenForRepo: ["POST /repos/{owner}/{repo}/actions/runners/remove-token"], + createWorkflowDispatch: ["POST /repos/{owner}/{repo}/actions/workflows/{workflow_id}/dispatches"], + deleteActionsCacheById: ["DELETE /repos/{owner}/{repo}/actions/caches/{cache_id}"], + deleteActionsCacheByKey: ["DELETE /repos/{owner}/{repo}/actions/caches{?key,ref}"], + deleteArtifact: ["DELETE /repos/{owner}/{repo}/actions/artifacts/{artifact_id}"], + deleteEnvironmentSecret: ["DELETE /repositories/{repository_id}/environments/{environment_name}/secrets/{secret_name}"], + deleteOrgSecret: ["DELETE /orgs/{org}/actions/secrets/{secret_name}"], + deleteRepoSecret: ["DELETE /repos/{owner}/{repo}/actions/secrets/{secret_name}"], + deleteSelfHostedRunnerFromOrg: ["DELETE /orgs/{org}/actions/runners/{runner_id}"], + deleteSelfHostedRunnerFromRepo: ["DELETE /repos/{owner}/{repo}/actions/runners/{runner_id}"], + deleteWorkflowRun: ["DELETE /repos/{owner}/{repo}/actions/runs/{run_id}"], + deleteWorkflowRunLogs: ["DELETE /repos/{owner}/{repo}/actions/runs/{run_id}/logs"], + disableSelectedRepositoryGithubActionsOrganization: ["DELETE /orgs/{org}/actions/permissions/repositories/{repository_id}"], + disableWorkflow: ["PUT /repos/{owner}/{repo}/actions/workflows/{workflow_id}/disable"], + downloadArtifact: ["GET /repos/{owner}/{repo}/actions/artifacts/{artifact_id}/{archive_format}"], + downloadJobLogsForWorkflowRun: ["GET /repos/{owner}/{repo}/actions/jobs/{job_id}/logs"], + downloadWorkflowRunAttemptLogs: ["GET /repos/{owner}/{repo}/actions/runs/{run_id}/attempts/{attempt_number}/logs"], + downloadWorkflowRunLogs: ["GET /repos/{owner}/{repo}/actions/runs/{run_id}/logs"], + enableSelectedRepositoryGithubActionsOrganization: ["PUT /orgs/{org}/actions/permissions/repositories/{repository_id}"], + enableWorkflow: ["PUT /repos/{owner}/{repo}/actions/workflows/{workflow_id}/enable"], + getActionsCacheList: ["GET /repos/{owner}/{repo}/actions/caches"], + getActionsCacheUsage: ["GET /repos/{owner}/{repo}/actions/cache/usage"], + getActionsCacheUsageByRepoForOrg: ["GET /orgs/{org}/actions/cache/usage-by-repository"], + getActionsCacheUsageForEnterprise: ["GET /enterprises/{enterprise}/actions/cache/usage"], + getActionsCacheUsageForOrg: ["GET /orgs/{org}/actions/cache/usage"], + getAllowedActionsOrganization: ["GET /orgs/{org}/actions/permissions/selected-actions"], + getAllowedActionsRepository: ["GET /repos/{owner}/{repo}/actions/permissions/selected-actions"], + getArtifact: ["GET /repos/{owner}/{repo}/actions/artifacts/{artifact_id}"], + getEnvironmentPublicKey: ["GET /repositories/{repository_id}/environments/{environment_name}/secrets/public-key"], + getEnvironmentSecret: ["GET /repositories/{repository_id}/environments/{environment_name}/secrets/{secret_name}"], + getGithubActionsDefaultWorkflowPermissionsEnterprise: ["GET /enterprises/{enterprise}/actions/permissions/workflow"], + getGithubActionsDefaultWorkflowPermissionsOrganization: ["GET /orgs/{org}/actions/permissions/workflow"], + getGithubActionsDefaultWorkflowPermissionsRepository: ["GET /repos/{owner}/{repo}/actions/permissions/workflow"], + getGithubActionsPermissionsOrganization: ["GET /orgs/{org}/actions/permissions"], + getGithubActionsPermissionsRepository: ["GET /repos/{owner}/{repo}/actions/permissions"], + getJobForWorkflowRun: ["GET /repos/{owner}/{repo}/actions/jobs/{job_id}"], + getOrgPublicKey: ["GET /orgs/{org}/actions/secrets/public-key"], + getOrgSecret: ["GET /orgs/{org}/actions/secrets/{secret_name}"], + getPendingDeploymentsForRun: ["GET /repos/{owner}/{repo}/actions/runs/{run_id}/pending_deployments"], + getRepoPermissions: ["GET /repos/{owner}/{repo}/actions/permissions", {}, { + renamed: ["actions", "getGithubActionsPermissionsRepository"] + }], + getRepoPublicKey: ["GET /repos/{owner}/{repo}/actions/secrets/public-key"], + getRepoSecret: ["GET /repos/{owner}/{repo}/actions/secrets/{secret_name}"], + getReviewsForRun: ["GET /repos/{owner}/{repo}/actions/runs/{run_id}/approvals"], + getSelfHostedRunnerForOrg: ["GET /orgs/{org}/actions/runners/{runner_id}"], + getSelfHostedRunnerForRepo: ["GET /repos/{owner}/{repo}/actions/runners/{runner_id}"], + getWorkflow: ["GET /repos/{owner}/{repo}/actions/workflows/{workflow_id}"], + getWorkflowAccessToRepository: ["GET /repos/{owner}/{repo}/actions/permissions/access"], + getWorkflowRun: ["GET /repos/{owner}/{repo}/actions/runs/{run_id}"], + getWorkflowRunAttempt: ["GET /repos/{owner}/{repo}/actions/runs/{run_id}/attempts/{attempt_number}"], + getWorkflowRunUsage: ["GET /repos/{owner}/{repo}/actions/runs/{run_id}/timing"], + getWorkflowUsage: ["GET /repos/{owner}/{repo}/actions/workflows/{workflow_id}/timing"], + listArtifactsForRepo: ["GET /repos/{owner}/{repo}/actions/artifacts"], + listEnvironmentSecrets: ["GET /repositories/{repository_id}/environments/{environment_name}/secrets"], + listJobsForWorkflowRun: ["GET /repos/{owner}/{repo}/actions/runs/{run_id}/jobs"], + listJobsForWorkflowRunAttempt: ["GET /repos/{owner}/{repo}/actions/runs/{run_id}/attempts/{attempt_number}/jobs"], + listLabelsForSelfHostedRunnerForOrg: ["GET /orgs/{org}/actions/runners/{runner_id}/labels"], + listLabelsForSelfHostedRunnerForRepo: ["GET /repos/{owner}/{repo}/actions/runners/{runner_id}/labels"], + listOrgSecrets: ["GET /orgs/{org}/actions/secrets"], + listRepoSecrets: ["GET /repos/{owner}/{repo}/actions/secrets"], + listRepoWorkflows: ["GET /repos/{owner}/{repo}/actions/workflows"], + listRunnerApplicationsForOrg: ["GET /orgs/{org}/actions/runners/downloads"], + listRunnerApplicationsForRepo: ["GET /repos/{owner}/{repo}/actions/runners/downloads"], + listSelectedReposForOrgSecret: ["GET /orgs/{org}/actions/secrets/{secret_name}/repositories"], + listSelectedRepositoriesEnabledGithubActionsOrganization: ["GET /orgs/{org}/actions/permissions/repositories"], + listSelfHostedRunnersForOrg: ["GET /orgs/{org}/actions/runners"], + listSelfHostedRunnersForRepo: ["GET /repos/{owner}/{repo}/actions/runners"], + listWorkflowRunArtifacts: ["GET /repos/{owner}/{repo}/actions/runs/{run_id}/artifacts"], + listWorkflowRuns: ["GET /repos/{owner}/{repo}/actions/workflows/{workflow_id}/runs"], + listWorkflowRunsForRepo: ["GET /repos/{owner}/{repo}/actions/runs"], + reRunJobForWorkflowRun: ["POST /repos/{owner}/{repo}/actions/jobs/{job_id}/rerun"], + reRunWorkflow: ["POST /repos/{owner}/{repo}/actions/runs/{run_id}/rerun"], + reRunWorkflowFailedJobs: ["POST /repos/{owner}/{repo}/actions/runs/{run_id}/rerun-failed-jobs"], + removeAllCustomLabelsFromSelfHostedRunnerForOrg: ["DELETE /orgs/{org}/actions/runners/{runner_id}/labels"], + removeAllCustomLabelsFromSelfHostedRunnerForRepo: ["DELETE /repos/{owner}/{repo}/actions/runners/{runner_id}/labels"], + removeCustomLabelFromSelfHostedRunnerForOrg: ["DELETE /orgs/{org}/actions/runners/{runner_id}/labels/{name}"], + removeCustomLabelFromSelfHostedRunnerForRepo: ["DELETE /repos/{owner}/{repo}/actions/runners/{runner_id}/labels/{name}"], + removeSelectedRepoFromOrgSecret: ["DELETE /orgs/{org}/actions/secrets/{secret_name}/repositories/{repository_id}"], + reviewPendingDeploymentsForRun: ["POST /repos/{owner}/{repo}/actions/runs/{run_id}/pending_deployments"], + setAllowedActionsOrganization: ["PUT /orgs/{org}/actions/permissions/selected-actions"], + setAllowedActionsRepository: ["PUT /repos/{owner}/{repo}/actions/permissions/selected-actions"], + setCustomLabelsForSelfHostedRunnerForOrg: ["PUT /orgs/{org}/actions/runners/{runner_id}/labels"], + setCustomLabelsForSelfHostedRunnerForRepo: ["PUT /repos/{owner}/{repo}/actions/runners/{runner_id}/labels"], + setGithubActionsDefaultWorkflowPermissionsEnterprise: ["PUT /enterprises/{enterprise}/actions/permissions/workflow"], + setGithubActionsDefaultWorkflowPermissionsOrganization: ["PUT /orgs/{org}/actions/permissions/workflow"], + setGithubActionsDefaultWorkflowPermissionsRepository: ["PUT /repos/{owner}/{repo}/actions/permissions/workflow"], + setGithubActionsPermissionsOrganization: ["PUT /orgs/{org}/actions/permissions"], + setGithubActionsPermissionsRepository: ["PUT /repos/{owner}/{repo}/actions/permissions"], + setSelectedReposForOrgSecret: ["PUT /orgs/{org}/actions/secrets/{secret_name}/repositories"], + setSelectedRepositoriesEnabledGithubActionsOrganization: ["PUT /orgs/{org}/actions/permissions/repositories"], + setWorkflowAccessToRepository: ["PUT /repos/{owner}/{repo}/actions/permissions/access"] + }, + activity: { + checkRepoIsStarredByAuthenticatedUser: ["GET /user/starred/{owner}/{repo}"], + deleteRepoSubscription: ["DELETE /repos/{owner}/{repo}/subscription"], + deleteThreadSubscription: ["DELETE /notifications/threads/{thread_id}/subscription"], + getFeeds: ["GET /feeds"], + getRepoSubscription: ["GET /repos/{owner}/{repo}/subscription"], + getThread: ["GET /notifications/threads/{thread_id}"], + getThreadSubscriptionForAuthenticatedUser: ["GET /notifications/threads/{thread_id}/subscription"], + listEventsForAuthenticatedUser: ["GET /users/{username}/events"], + listNotificationsForAuthenticatedUser: ["GET /notifications"], + listOrgEventsForAuthenticatedUser: ["GET /users/{username}/events/orgs/{org}"], + listPublicEvents: ["GET /events"], + listPublicEventsForRepoNetwork: ["GET /networks/{owner}/{repo}/events"], + listPublicEventsForUser: ["GET /users/{username}/events/public"], + listPublicOrgEvents: ["GET /orgs/{org}/events"], + listReceivedEventsForUser: ["GET /users/{username}/received_events"], + listReceivedPublicEventsForUser: ["GET /users/{username}/received_events/public"], + listRepoEvents: ["GET /repos/{owner}/{repo}/events"], + listRepoNotificationsForAuthenticatedUser: ["GET /repos/{owner}/{repo}/notifications"], + listReposStarredByAuthenticatedUser: ["GET /user/starred"], + listReposStarredByUser: ["GET /users/{username}/starred"], + listReposWatchedByUser: ["GET /users/{username}/subscriptions"], + listStargazersForRepo: ["GET /repos/{owner}/{repo}/stargazers"], + listWatchedReposForAuthenticatedUser: ["GET /user/subscriptions"], + listWatchersForRepo: ["GET /repos/{owner}/{repo}/subscribers"], + markNotificationsAsRead: ["PUT /notifications"], + markRepoNotificationsAsRead: ["PUT /repos/{owner}/{repo}/notifications"], + markThreadAsRead: ["PATCH /notifications/threads/{thread_id}"], + setRepoSubscription: ["PUT /repos/{owner}/{repo}/subscription"], + setThreadSubscription: ["PUT /notifications/threads/{thread_id}/subscription"], + starRepoForAuthenticatedUser: ["PUT /user/starred/{owner}/{repo}"], + unstarRepoForAuthenticatedUser: ["DELETE /user/starred/{owner}/{repo}"] + }, + apps: { + addRepoToInstallation: ["PUT /user/installations/{installation_id}/repositories/{repository_id}", {}, { + renamed: ["apps", "addRepoToInstallationForAuthenticatedUser"] + }], + addRepoToInstallationForAuthenticatedUser: ["PUT /user/installations/{installation_id}/repositories/{repository_id}"], + checkToken: ["POST /applications/{client_id}/token"], + createFromManifest: ["POST /app-manifests/{code}/conversions"], + createInstallationAccessToken: ["POST /app/installations/{installation_id}/access_tokens"], + deleteAuthorization: ["DELETE /applications/{client_id}/grant"], + deleteInstallation: ["DELETE /app/installations/{installation_id}"], + deleteToken: ["DELETE /applications/{client_id}/token"], + getAuthenticated: ["GET /app"], + getBySlug: ["GET /apps/{app_slug}"], + getInstallation: ["GET /app/installations/{installation_id}"], + getOrgInstallation: ["GET /orgs/{org}/installation"], + getRepoInstallation: ["GET /repos/{owner}/{repo}/installation"], + getSubscriptionPlanForAccount: ["GET /marketplace_listing/accounts/{account_id}"], + getSubscriptionPlanForAccountStubbed: ["GET /marketplace_listing/stubbed/accounts/{account_id}"], + getUserInstallation: ["GET /users/{username}/installation"], + getWebhookConfigForApp: ["GET /app/hook/config"], + getWebhookDelivery: ["GET /app/hook/deliveries/{delivery_id}"], + listAccountsForPlan: ["GET /marketplace_listing/plans/{plan_id}/accounts"], + listAccountsForPlanStubbed: ["GET /marketplace_listing/stubbed/plans/{plan_id}/accounts"], + listInstallationReposForAuthenticatedUser: ["GET /user/installations/{installation_id}/repositories"], + listInstallations: ["GET /app/installations"], + listInstallationsForAuthenticatedUser: ["GET /user/installations"], + listPlans: ["GET /marketplace_listing/plans"], + listPlansStubbed: ["GET /marketplace_listing/stubbed/plans"], + listReposAccessibleToInstallation: ["GET /installation/repositories"], + listSubscriptionsForAuthenticatedUser: ["GET /user/marketplace_purchases"], + listSubscriptionsForAuthenticatedUserStubbed: ["GET /user/marketplace_purchases/stubbed"], + listWebhookDeliveries: ["GET /app/hook/deliveries"], + redeliverWebhookDelivery: ["POST /app/hook/deliveries/{delivery_id}/attempts"], + removeRepoFromInstallation: ["DELETE /user/installations/{installation_id}/repositories/{repository_id}", {}, { + renamed: ["apps", "removeRepoFromInstallationForAuthenticatedUser"] + }], + removeRepoFromInstallationForAuthenticatedUser: ["DELETE /user/installations/{installation_id}/repositories/{repository_id}"], + resetToken: ["PATCH /applications/{client_id}/token"], + revokeInstallationAccessToken: ["DELETE /installation/token"], + scopeToken: ["POST /applications/{client_id}/token/scoped"], + suspendInstallation: ["PUT /app/installations/{installation_id}/suspended"], + unsuspendInstallation: ["DELETE /app/installations/{installation_id}/suspended"], + updateWebhookConfigForApp: ["PATCH /app/hook/config"] + }, + billing: { + getGithubActionsBillingOrg: ["GET /orgs/{org}/settings/billing/actions"], + getGithubActionsBillingUser: ["GET /users/{username}/settings/billing/actions"], + getGithubAdvancedSecurityBillingGhe: ["GET /enterprises/{enterprise}/settings/billing/advanced-security"], + getGithubAdvancedSecurityBillingOrg: ["GET /orgs/{org}/settings/billing/advanced-security"], + getGithubPackagesBillingOrg: ["GET /orgs/{org}/settings/billing/packages"], + getGithubPackagesBillingUser: ["GET /users/{username}/settings/billing/packages"], + getSharedStorageBillingOrg: ["GET /orgs/{org}/settings/billing/shared-storage"], + getSharedStorageBillingUser: ["GET /users/{username}/settings/billing/shared-storage"] + }, + checks: { + create: ["POST /repos/{owner}/{repo}/check-runs"], + createSuite: ["POST /repos/{owner}/{repo}/check-suites"], + get: ["GET /repos/{owner}/{repo}/check-runs/{check_run_id}"], + getSuite: ["GET /repos/{owner}/{repo}/check-suites/{check_suite_id}"], + listAnnotations: ["GET /repos/{owner}/{repo}/check-runs/{check_run_id}/annotations"], + listForRef: ["GET /repos/{owner}/{repo}/commits/{ref}/check-runs"], + listForSuite: ["GET /repos/{owner}/{repo}/check-suites/{check_suite_id}/check-runs"], + listSuitesForRef: ["GET /repos/{owner}/{repo}/commits/{ref}/check-suites"], + rerequestRun: ["POST /repos/{owner}/{repo}/check-runs/{check_run_id}/rerequest"], + rerequestSuite: ["POST /repos/{owner}/{repo}/check-suites/{check_suite_id}/rerequest"], + setSuitesPreferences: ["PATCH /repos/{owner}/{repo}/check-suites/preferences"], + update: ["PATCH /repos/{owner}/{repo}/check-runs/{check_run_id}"] + }, + codeScanning: { + deleteAnalysis: ["DELETE /repos/{owner}/{repo}/code-scanning/analyses/{analysis_id}{?confirm_delete}"], + getAlert: ["GET /repos/{owner}/{repo}/code-scanning/alerts/{alert_number}", {}, { + renamedParameters: { + alert_id: "alert_number" + } + }], + getAnalysis: ["GET /repos/{owner}/{repo}/code-scanning/analyses/{analysis_id}"], + getSarif: ["GET /repos/{owner}/{repo}/code-scanning/sarifs/{sarif_id}"], + listAlertInstances: ["GET /repos/{owner}/{repo}/code-scanning/alerts/{alert_number}/instances"], + listAlertsForOrg: ["GET /orgs/{org}/code-scanning/alerts"], + listAlertsForRepo: ["GET /repos/{owner}/{repo}/code-scanning/alerts"], + listAlertsInstances: ["GET /repos/{owner}/{repo}/code-scanning/alerts/{alert_number}/instances", {}, { + renamed: ["codeScanning", "listAlertInstances"] + }], + listRecentAnalyses: ["GET /repos/{owner}/{repo}/code-scanning/analyses"], + updateAlert: ["PATCH /repos/{owner}/{repo}/code-scanning/alerts/{alert_number}"], + uploadSarif: ["POST /repos/{owner}/{repo}/code-scanning/sarifs"] + }, + codesOfConduct: { + getAllCodesOfConduct: ["GET /codes_of_conduct"], + getConductCode: ["GET /codes_of_conduct/{key}"] + }, + codespaces: { + addRepositoryForSecretForAuthenticatedUser: ["PUT /user/codespaces/secrets/{secret_name}/repositories/{repository_id}"], + codespaceMachinesForAuthenticatedUser: ["GET /user/codespaces/{codespace_name}/machines"], + createForAuthenticatedUser: ["POST /user/codespaces"], + createOrUpdateRepoSecret: ["PUT /repos/{owner}/{repo}/codespaces/secrets/{secret_name}"], + createOrUpdateSecretForAuthenticatedUser: ["PUT /user/codespaces/secrets/{secret_name}"], + createWithPrForAuthenticatedUser: ["POST /repos/{owner}/{repo}/pulls/{pull_number}/codespaces"], + createWithRepoForAuthenticatedUser: ["POST /repos/{owner}/{repo}/codespaces"], + deleteForAuthenticatedUser: ["DELETE /user/codespaces/{codespace_name}"], + deleteFromOrganization: ["DELETE /orgs/{org}/members/{username}/codespaces/{codespace_name}"], + deleteRepoSecret: ["DELETE /repos/{owner}/{repo}/codespaces/secrets/{secret_name}"], + deleteSecretForAuthenticatedUser: ["DELETE /user/codespaces/secrets/{secret_name}"], + exportForAuthenticatedUser: ["POST /user/codespaces/{codespace_name}/exports"], + getExportDetailsForAuthenticatedUser: ["GET /user/codespaces/{codespace_name}/exports/{export_id}"], + getForAuthenticatedUser: ["GET /user/codespaces/{codespace_name}"], + getPublicKeyForAuthenticatedUser: ["GET /user/codespaces/secrets/public-key"], + getRepoPublicKey: ["GET /repos/{owner}/{repo}/codespaces/secrets/public-key"], + getRepoSecret: ["GET /repos/{owner}/{repo}/codespaces/secrets/{secret_name}"], + getSecretForAuthenticatedUser: ["GET /user/codespaces/secrets/{secret_name}"], + listDevcontainersInRepositoryForAuthenticatedUser: ["GET /repos/{owner}/{repo}/codespaces/devcontainers"], + listForAuthenticatedUser: ["GET /user/codespaces"], + listInOrganization: ["GET /orgs/{org}/codespaces", {}, { + renamedParameters: { + org_id: "org" + } + }], + listInRepositoryForAuthenticatedUser: ["GET /repos/{owner}/{repo}/codespaces"], + listRepoSecrets: ["GET /repos/{owner}/{repo}/codespaces/secrets"], + listRepositoriesForSecretForAuthenticatedUser: ["GET /user/codespaces/secrets/{secret_name}/repositories"], + listSecretsForAuthenticatedUser: ["GET /user/codespaces/secrets"], + removeRepositoryForSecretForAuthenticatedUser: ["DELETE /user/codespaces/secrets/{secret_name}/repositories/{repository_id}"], + repoMachinesForAuthenticatedUser: ["GET /repos/{owner}/{repo}/codespaces/machines"], + setRepositoriesForSecretForAuthenticatedUser: ["PUT /user/codespaces/secrets/{secret_name}/repositories"], + startForAuthenticatedUser: ["POST /user/codespaces/{codespace_name}/start"], + stopForAuthenticatedUser: ["POST /user/codespaces/{codespace_name}/stop"], + stopInOrganization: ["POST /orgs/{org}/members/{username}/codespaces/{codespace_name}/stop"], + updateForAuthenticatedUser: ["PATCH /user/codespaces/{codespace_name}"] + }, + dependabot: { + addSelectedRepoToOrgSecret: ["PUT /orgs/{org}/dependabot/secrets/{secret_name}/repositories/{repository_id}"], + createOrUpdateOrgSecret: ["PUT /orgs/{org}/dependabot/secrets/{secret_name}"], + createOrUpdateRepoSecret: ["PUT /repos/{owner}/{repo}/dependabot/secrets/{secret_name}"], + deleteOrgSecret: ["DELETE /orgs/{org}/dependabot/secrets/{secret_name}"], + deleteRepoSecret: ["DELETE /repos/{owner}/{repo}/dependabot/secrets/{secret_name}"], + getOrgPublicKey: ["GET /orgs/{org}/dependabot/secrets/public-key"], + getOrgSecret: ["GET /orgs/{org}/dependabot/secrets/{secret_name}"], + getRepoPublicKey: ["GET /repos/{owner}/{repo}/dependabot/secrets/public-key"], + getRepoSecret: ["GET /repos/{owner}/{repo}/dependabot/secrets/{secret_name}"], + listOrgSecrets: ["GET /orgs/{org}/dependabot/secrets"], + listRepoSecrets: ["GET /repos/{owner}/{repo}/dependabot/secrets"], + listSelectedReposForOrgSecret: ["GET /orgs/{org}/dependabot/secrets/{secret_name}/repositories"], + removeSelectedRepoFromOrgSecret: ["DELETE /orgs/{org}/dependabot/secrets/{secret_name}/repositories/{repository_id}"], + setSelectedReposForOrgSecret: ["PUT /orgs/{org}/dependabot/secrets/{secret_name}/repositories"] + }, + dependencyGraph: { + createRepositorySnapshot: ["POST /repos/{owner}/{repo}/dependency-graph/snapshots"], + diffRange: ["GET /repos/{owner}/{repo}/dependency-graph/compare/{basehead}"] + }, + emojis: { + get: ["GET /emojis"] + }, + enterpriseAdmin: { + addCustomLabelsToSelfHostedRunnerForEnterprise: ["POST /enterprises/{enterprise}/actions/runners/{runner_id}/labels"], + disableSelectedOrganizationGithubActionsEnterprise: ["DELETE /enterprises/{enterprise}/actions/permissions/organizations/{org_id}"], + enableSelectedOrganizationGithubActionsEnterprise: ["PUT /enterprises/{enterprise}/actions/permissions/organizations/{org_id}"], + getAllowedActionsEnterprise: ["GET /enterprises/{enterprise}/actions/permissions/selected-actions"], + getGithubActionsPermissionsEnterprise: ["GET /enterprises/{enterprise}/actions/permissions"], + getServerStatistics: ["GET /enterprise-installation/{enterprise_or_org}/server-statistics"], + listLabelsForSelfHostedRunnerForEnterprise: ["GET /enterprises/{enterprise}/actions/runners/{runner_id}/labels"], + listSelectedOrganizationsEnabledGithubActionsEnterprise: ["GET /enterprises/{enterprise}/actions/permissions/organizations"], + removeAllCustomLabelsFromSelfHostedRunnerForEnterprise: ["DELETE /enterprises/{enterprise}/actions/runners/{runner_id}/labels"], + removeCustomLabelFromSelfHostedRunnerForEnterprise: ["DELETE /enterprises/{enterprise}/actions/runners/{runner_id}/labels/{name}"], + setAllowedActionsEnterprise: ["PUT /enterprises/{enterprise}/actions/permissions/selected-actions"], + setCustomLabelsForSelfHostedRunnerForEnterprise: ["PUT /enterprises/{enterprise}/actions/runners/{runner_id}/labels"], + setGithubActionsPermissionsEnterprise: ["PUT /enterprises/{enterprise}/actions/permissions"], + setSelectedOrganizationsEnabledGithubActionsEnterprise: ["PUT /enterprises/{enterprise}/actions/permissions/organizations"] + }, + gists: { + checkIsStarred: ["GET /gists/{gist_id}/star"], + create: ["POST /gists"], + createComment: ["POST /gists/{gist_id}/comments"], + delete: ["DELETE /gists/{gist_id}"], + deleteComment: ["DELETE /gists/{gist_id}/comments/{comment_id}"], + fork: ["POST /gists/{gist_id}/forks"], + get: ["GET /gists/{gist_id}"], + getComment: ["GET /gists/{gist_id}/comments/{comment_id}"], + getRevision: ["GET /gists/{gist_id}/{sha}"], + list: ["GET /gists"], + listComments: ["GET /gists/{gist_id}/comments"], + listCommits: ["GET /gists/{gist_id}/commits"], + listForUser: ["GET /users/{username}/gists"], + listForks: ["GET /gists/{gist_id}/forks"], + listPublic: ["GET /gists/public"], + listStarred: ["GET /gists/starred"], + star: ["PUT /gists/{gist_id}/star"], + unstar: ["DELETE /gists/{gist_id}/star"], + update: ["PATCH /gists/{gist_id}"], + updateComment: ["PATCH /gists/{gist_id}/comments/{comment_id}"] + }, + git: { + createBlob: ["POST /repos/{owner}/{repo}/git/blobs"], + createCommit: ["POST /repos/{owner}/{repo}/git/commits"], + createRef: ["POST /repos/{owner}/{repo}/git/refs"], + createTag: ["POST /repos/{owner}/{repo}/git/tags"], + createTree: ["POST /repos/{owner}/{repo}/git/trees"], + deleteRef: ["DELETE /repos/{owner}/{repo}/git/refs/{ref}"], + getBlob: ["GET /repos/{owner}/{repo}/git/blobs/{file_sha}"], + getCommit: ["GET /repos/{owner}/{repo}/git/commits/{commit_sha}"], + getRef: ["GET /repos/{owner}/{repo}/git/ref/{ref}"], + getTag: ["GET /repos/{owner}/{repo}/git/tags/{tag_sha}"], + getTree: ["GET /repos/{owner}/{repo}/git/trees/{tree_sha}"], + listMatchingRefs: ["GET /repos/{owner}/{repo}/git/matching-refs/{ref}"], + updateRef: ["PATCH /repos/{owner}/{repo}/git/refs/{ref}"] + }, + gitignore: { + getAllTemplates: ["GET /gitignore/templates"], + getTemplate: ["GET /gitignore/templates/{name}"] + }, + interactions: { + getRestrictionsForAuthenticatedUser: ["GET /user/interaction-limits"], + getRestrictionsForOrg: ["GET /orgs/{org}/interaction-limits"], + getRestrictionsForRepo: ["GET /repos/{owner}/{repo}/interaction-limits"], + getRestrictionsForYourPublicRepos: ["GET /user/interaction-limits", {}, { + renamed: ["interactions", "getRestrictionsForAuthenticatedUser"] + }], + removeRestrictionsForAuthenticatedUser: ["DELETE /user/interaction-limits"], + removeRestrictionsForOrg: ["DELETE /orgs/{org}/interaction-limits"], + removeRestrictionsForRepo: ["DELETE /repos/{owner}/{repo}/interaction-limits"], + removeRestrictionsForYourPublicRepos: ["DELETE /user/interaction-limits", {}, { + renamed: ["interactions", "removeRestrictionsForAuthenticatedUser"] + }], + setRestrictionsForAuthenticatedUser: ["PUT /user/interaction-limits"], + setRestrictionsForOrg: ["PUT /orgs/{org}/interaction-limits"], + setRestrictionsForRepo: ["PUT /repos/{owner}/{repo}/interaction-limits"], + setRestrictionsForYourPublicRepos: ["PUT /user/interaction-limits", {}, { + renamed: ["interactions", "setRestrictionsForAuthenticatedUser"] + }] + }, + issues: { + addAssignees: ["POST /repos/{owner}/{repo}/issues/{issue_number}/assignees"], + addLabels: ["POST /repos/{owner}/{repo}/issues/{issue_number}/labels"], + checkUserCanBeAssigned: ["GET /repos/{owner}/{repo}/assignees/{assignee}"], + create: ["POST /repos/{owner}/{repo}/issues"], + createComment: ["POST /repos/{owner}/{repo}/issues/{issue_number}/comments"], + createLabel: ["POST /repos/{owner}/{repo}/labels"], + createMilestone: ["POST /repos/{owner}/{repo}/milestones"], + deleteComment: ["DELETE /repos/{owner}/{repo}/issues/comments/{comment_id}"], + deleteLabel: ["DELETE /repos/{owner}/{repo}/labels/{name}"], + deleteMilestone: ["DELETE /repos/{owner}/{repo}/milestones/{milestone_number}"], + get: ["GET /repos/{owner}/{repo}/issues/{issue_number}"], + getComment: ["GET /repos/{owner}/{repo}/issues/comments/{comment_id}"], + getEvent: ["GET /repos/{owner}/{repo}/issues/events/{event_id}"], + getLabel: ["GET /repos/{owner}/{repo}/labels/{name}"], + getMilestone: ["GET /repos/{owner}/{repo}/milestones/{milestone_number}"], + list: ["GET /issues"], + listAssignees: ["GET /repos/{owner}/{repo}/assignees"], + listComments: ["GET /repos/{owner}/{repo}/issues/{issue_number}/comments"], + listCommentsForRepo: ["GET /repos/{owner}/{repo}/issues/comments"], + listEvents: ["GET /repos/{owner}/{repo}/issues/{issue_number}/events"], + listEventsForRepo: ["GET /repos/{owner}/{repo}/issues/events"], + listEventsForTimeline: ["GET /repos/{owner}/{repo}/issues/{issue_number}/timeline"], + listForAuthenticatedUser: ["GET /user/issues"], + listForOrg: ["GET /orgs/{org}/issues"], + listForRepo: ["GET /repos/{owner}/{repo}/issues"], + listLabelsForMilestone: ["GET /repos/{owner}/{repo}/milestones/{milestone_number}/labels"], + listLabelsForRepo: ["GET /repos/{owner}/{repo}/labels"], + listLabelsOnIssue: ["GET /repos/{owner}/{repo}/issues/{issue_number}/labels"], + listMilestones: ["GET /repos/{owner}/{repo}/milestones"], + lock: ["PUT /repos/{owner}/{repo}/issues/{issue_number}/lock"], + removeAllLabels: ["DELETE /repos/{owner}/{repo}/issues/{issue_number}/labels"], + removeAssignees: ["DELETE /repos/{owner}/{repo}/issues/{issue_number}/assignees"], + removeLabel: ["DELETE /repos/{owner}/{repo}/issues/{issue_number}/labels/{name}"], + setLabels: ["PUT /repos/{owner}/{repo}/issues/{issue_number}/labels"], + unlock: ["DELETE /repos/{owner}/{repo}/issues/{issue_number}/lock"], + update: ["PATCH /repos/{owner}/{repo}/issues/{issue_number}"], + updateComment: ["PATCH /repos/{owner}/{repo}/issues/comments/{comment_id}"], + updateLabel: ["PATCH /repos/{owner}/{repo}/labels/{name}"], + updateMilestone: ["PATCH /repos/{owner}/{repo}/milestones/{milestone_number}"] + }, + licenses: { + get: ["GET /licenses/{license}"], + getAllCommonlyUsed: ["GET /licenses"], + getForRepo: ["GET /repos/{owner}/{repo}/license"] + }, + markdown: { + render: ["POST /markdown"], + renderRaw: ["POST /markdown/raw", { + headers: { + "content-type": "text/plain; charset=utf-8" + } + }] + }, + meta: { + get: ["GET /meta"], + getOctocat: ["GET /octocat"], + getZen: ["GET /zen"], + root: ["GET /"] + }, + migrations: { + cancelImport: ["DELETE /repos/{owner}/{repo}/import"], + deleteArchiveForAuthenticatedUser: ["DELETE /user/migrations/{migration_id}/archive"], + deleteArchiveForOrg: ["DELETE /orgs/{org}/migrations/{migration_id}/archive"], + downloadArchiveForOrg: ["GET /orgs/{org}/migrations/{migration_id}/archive"], + getArchiveForAuthenticatedUser: ["GET /user/migrations/{migration_id}/archive"], + getCommitAuthors: ["GET /repos/{owner}/{repo}/import/authors"], + getImportStatus: ["GET /repos/{owner}/{repo}/import"], + getLargeFiles: ["GET /repos/{owner}/{repo}/import/large_files"], + getStatusForAuthenticatedUser: ["GET /user/migrations/{migration_id}"], + getStatusForOrg: ["GET /orgs/{org}/migrations/{migration_id}"], + listForAuthenticatedUser: ["GET /user/migrations"], + listForOrg: ["GET /orgs/{org}/migrations"], + listReposForAuthenticatedUser: ["GET /user/migrations/{migration_id}/repositories"], + listReposForOrg: ["GET /orgs/{org}/migrations/{migration_id}/repositories"], + listReposForUser: ["GET /user/migrations/{migration_id}/repositories", {}, { + renamed: ["migrations", "listReposForAuthenticatedUser"] + }], + mapCommitAuthor: ["PATCH /repos/{owner}/{repo}/import/authors/{author_id}"], + setLfsPreference: ["PATCH /repos/{owner}/{repo}/import/lfs"], + startForAuthenticatedUser: ["POST /user/migrations"], + startForOrg: ["POST /orgs/{org}/migrations"], + startImport: ["PUT /repos/{owner}/{repo}/import"], + unlockRepoForAuthenticatedUser: ["DELETE /user/migrations/{migration_id}/repos/{repo_name}/lock"], + unlockRepoForOrg: ["DELETE /orgs/{org}/migrations/{migration_id}/repos/{repo_name}/lock"], + updateImport: ["PATCH /repos/{owner}/{repo}/import"] + }, + orgs: { + blockUser: ["PUT /orgs/{org}/blocks/{username}"], + cancelInvitation: ["DELETE /orgs/{org}/invitations/{invitation_id}"], + checkBlockedUser: ["GET /orgs/{org}/blocks/{username}"], + checkMembershipForUser: ["GET /orgs/{org}/members/{username}"], + checkPublicMembershipForUser: ["GET /orgs/{org}/public_members/{username}"], + convertMemberToOutsideCollaborator: ["PUT /orgs/{org}/outside_collaborators/{username}"], + createInvitation: ["POST /orgs/{org}/invitations"], + createWebhook: ["POST /orgs/{org}/hooks"], + deleteWebhook: ["DELETE /orgs/{org}/hooks/{hook_id}"], + get: ["GET /orgs/{org}"], + getMembershipForAuthenticatedUser: ["GET /user/memberships/orgs/{org}"], + getMembershipForUser: ["GET /orgs/{org}/memberships/{username}"], + getWebhook: ["GET /orgs/{org}/hooks/{hook_id}"], + getWebhookConfigForOrg: ["GET /orgs/{org}/hooks/{hook_id}/config"], + getWebhookDelivery: ["GET /orgs/{org}/hooks/{hook_id}/deliveries/{delivery_id}"], + list: ["GET /organizations"], + listAppInstallations: ["GET /orgs/{org}/installations"], + listBlockedUsers: ["GET /orgs/{org}/blocks"], + listCustomRoles: ["GET /organizations/{organization_id}/custom_roles"], + listFailedInvitations: ["GET /orgs/{org}/failed_invitations"], + listForAuthenticatedUser: ["GET /user/orgs"], + listForUser: ["GET /users/{username}/orgs"], + listInvitationTeams: ["GET /orgs/{org}/invitations/{invitation_id}/teams"], + listMembers: ["GET /orgs/{org}/members"], + listMembershipsForAuthenticatedUser: ["GET /user/memberships/orgs"], + listOutsideCollaborators: ["GET /orgs/{org}/outside_collaborators"], + listPendingInvitations: ["GET /orgs/{org}/invitations"], + listPublicMembers: ["GET /orgs/{org}/public_members"], + listWebhookDeliveries: ["GET /orgs/{org}/hooks/{hook_id}/deliveries"], + listWebhooks: ["GET /orgs/{org}/hooks"], + pingWebhook: ["POST /orgs/{org}/hooks/{hook_id}/pings"], + redeliverWebhookDelivery: ["POST /orgs/{org}/hooks/{hook_id}/deliveries/{delivery_id}/attempts"], + removeMember: ["DELETE /orgs/{org}/members/{username}"], + removeMembershipForUser: ["DELETE /orgs/{org}/memberships/{username}"], + removeOutsideCollaborator: ["DELETE /orgs/{org}/outside_collaborators/{username}"], + removePublicMembershipForAuthenticatedUser: ["DELETE /orgs/{org}/public_members/{username}"], + setMembershipForUser: ["PUT /orgs/{org}/memberships/{username}"], + setPublicMembershipForAuthenticatedUser: ["PUT /orgs/{org}/public_members/{username}"], + unblockUser: ["DELETE /orgs/{org}/blocks/{username}"], + update: ["PATCH /orgs/{org}"], + updateMembershipForAuthenticatedUser: ["PATCH /user/memberships/orgs/{org}"], + updateWebhook: ["PATCH /orgs/{org}/hooks/{hook_id}"], + updateWebhookConfigForOrg: ["PATCH /orgs/{org}/hooks/{hook_id}/config"] + }, + packages: { + deletePackageForAuthenticatedUser: ["DELETE /user/packages/{package_type}/{package_name}"], + deletePackageForOrg: ["DELETE /orgs/{org}/packages/{package_type}/{package_name}"], + deletePackageForUser: ["DELETE /users/{username}/packages/{package_type}/{package_name}"], + deletePackageVersionForAuthenticatedUser: ["DELETE /user/packages/{package_type}/{package_name}/versions/{package_version_id}"], + deletePackageVersionForOrg: ["DELETE /orgs/{org}/packages/{package_type}/{package_name}/versions/{package_version_id}"], + deletePackageVersionForUser: ["DELETE /users/{username}/packages/{package_type}/{package_name}/versions/{package_version_id}"], + getAllPackageVersionsForAPackageOwnedByAnOrg: ["GET /orgs/{org}/packages/{package_type}/{package_name}/versions", {}, { + renamed: ["packages", "getAllPackageVersionsForPackageOwnedByOrg"] + }], + getAllPackageVersionsForAPackageOwnedByTheAuthenticatedUser: ["GET /user/packages/{package_type}/{package_name}/versions", {}, { + renamed: ["packages", "getAllPackageVersionsForPackageOwnedByAuthenticatedUser"] + }], + getAllPackageVersionsForPackageOwnedByAuthenticatedUser: ["GET /user/packages/{package_type}/{package_name}/versions"], + getAllPackageVersionsForPackageOwnedByOrg: ["GET /orgs/{org}/packages/{package_type}/{package_name}/versions"], + getAllPackageVersionsForPackageOwnedByUser: ["GET /users/{username}/packages/{package_type}/{package_name}/versions"], + getPackageForAuthenticatedUser: ["GET /user/packages/{package_type}/{package_name}"], + getPackageForOrganization: ["GET /orgs/{org}/packages/{package_type}/{package_name}"], + getPackageForUser: ["GET /users/{username}/packages/{package_type}/{package_name}"], + getPackageVersionForAuthenticatedUser: ["GET /user/packages/{package_type}/{package_name}/versions/{package_version_id}"], + getPackageVersionForOrganization: ["GET /orgs/{org}/packages/{package_type}/{package_name}/versions/{package_version_id}"], + getPackageVersionForUser: ["GET /users/{username}/packages/{package_type}/{package_name}/versions/{package_version_id}"], + listPackagesForAuthenticatedUser: ["GET /user/packages"], + listPackagesForOrganization: ["GET /orgs/{org}/packages"], + listPackagesForUser: ["GET /users/{username}/packages"], + restorePackageForAuthenticatedUser: ["POST /user/packages/{package_type}/{package_name}/restore{?token}"], + restorePackageForOrg: ["POST /orgs/{org}/packages/{package_type}/{package_name}/restore{?token}"], + restorePackageForUser: ["POST /users/{username}/packages/{package_type}/{package_name}/restore{?token}"], + restorePackageVersionForAuthenticatedUser: ["POST /user/packages/{package_type}/{package_name}/versions/{package_version_id}/restore"], + restorePackageVersionForOrg: ["POST /orgs/{org}/packages/{package_type}/{package_name}/versions/{package_version_id}/restore"], + restorePackageVersionForUser: ["POST /users/{username}/packages/{package_type}/{package_name}/versions/{package_version_id}/restore"] + }, + projects: { + addCollaborator: ["PUT /projects/{project_id}/collaborators/{username}"], + createCard: ["POST /projects/columns/{column_id}/cards"], + createColumn: ["POST /projects/{project_id}/columns"], + createForAuthenticatedUser: ["POST /user/projects"], + createForOrg: ["POST /orgs/{org}/projects"], + createForRepo: ["POST /repos/{owner}/{repo}/projects"], + delete: ["DELETE /projects/{project_id}"], + deleteCard: ["DELETE /projects/columns/cards/{card_id}"], + deleteColumn: ["DELETE /projects/columns/{column_id}"], + get: ["GET /projects/{project_id}"], + getCard: ["GET /projects/columns/cards/{card_id}"], + getColumn: ["GET /projects/columns/{column_id}"], + getPermissionForUser: ["GET /projects/{project_id}/collaborators/{username}/permission"], + listCards: ["GET /projects/columns/{column_id}/cards"], + listCollaborators: ["GET /projects/{project_id}/collaborators"], + listColumns: ["GET /projects/{project_id}/columns"], + listForOrg: ["GET /orgs/{org}/projects"], + listForRepo: ["GET /repos/{owner}/{repo}/projects"], + listForUser: ["GET /users/{username}/projects"], + moveCard: ["POST /projects/columns/cards/{card_id}/moves"], + moveColumn: ["POST /projects/columns/{column_id}/moves"], + removeCollaborator: ["DELETE /projects/{project_id}/collaborators/{username}"], + update: ["PATCH /projects/{project_id}"], + updateCard: ["PATCH /projects/columns/cards/{card_id}"], + updateColumn: ["PATCH /projects/columns/{column_id}"] + }, + pulls: { + checkIfMerged: ["GET /repos/{owner}/{repo}/pulls/{pull_number}/merge"], + create: ["POST /repos/{owner}/{repo}/pulls"], + createReplyForReviewComment: ["POST /repos/{owner}/{repo}/pulls/{pull_number}/comments/{comment_id}/replies"], + createReview: ["POST /repos/{owner}/{repo}/pulls/{pull_number}/reviews"], + createReviewComment: ["POST /repos/{owner}/{repo}/pulls/{pull_number}/comments"], + deletePendingReview: ["DELETE /repos/{owner}/{repo}/pulls/{pull_number}/reviews/{review_id}"], + deleteReviewComment: ["DELETE /repos/{owner}/{repo}/pulls/comments/{comment_id}"], + dismissReview: ["PUT /repos/{owner}/{repo}/pulls/{pull_number}/reviews/{review_id}/dismissals"], + get: ["GET /repos/{owner}/{repo}/pulls/{pull_number}"], + getReview: ["GET /repos/{owner}/{repo}/pulls/{pull_number}/reviews/{review_id}"], + getReviewComment: ["GET /repos/{owner}/{repo}/pulls/comments/{comment_id}"], + list: ["GET /repos/{owner}/{repo}/pulls"], + listCommentsForReview: ["GET /repos/{owner}/{repo}/pulls/{pull_number}/reviews/{review_id}/comments"], + listCommits: ["GET /repos/{owner}/{repo}/pulls/{pull_number}/commits"], + listFiles: ["GET /repos/{owner}/{repo}/pulls/{pull_number}/files"], + listRequestedReviewers: ["GET /repos/{owner}/{repo}/pulls/{pull_number}/requested_reviewers"], + listReviewComments: ["GET /repos/{owner}/{repo}/pulls/{pull_number}/comments"], + listReviewCommentsForRepo: ["GET /repos/{owner}/{repo}/pulls/comments"], + listReviews: ["GET /repos/{owner}/{repo}/pulls/{pull_number}/reviews"], + merge: ["PUT /repos/{owner}/{repo}/pulls/{pull_number}/merge"], + removeRequestedReviewers: ["DELETE /repos/{owner}/{repo}/pulls/{pull_number}/requested_reviewers"], + requestReviewers: ["POST /repos/{owner}/{repo}/pulls/{pull_number}/requested_reviewers"], + submitReview: ["POST /repos/{owner}/{repo}/pulls/{pull_number}/reviews/{review_id}/events"], + update: ["PATCH /repos/{owner}/{repo}/pulls/{pull_number}"], + updateBranch: ["PUT /repos/{owner}/{repo}/pulls/{pull_number}/update-branch"], + updateReview: ["PUT /repos/{owner}/{repo}/pulls/{pull_number}/reviews/{review_id}"], + updateReviewComment: ["PATCH /repos/{owner}/{repo}/pulls/comments/{comment_id}"] + }, + rateLimit: { + get: ["GET /rate_limit"] + }, + reactions: { + createForCommitComment: ["POST /repos/{owner}/{repo}/comments/{comment_id}/reactions"], + createForIssue: ["POST /repos/{owner}/{repo}/issues/{issue_number}/reactions"], + createForIssueComment: ["POST /repos/{owner}/{repo}/issues/comments/{comment_id}/reactions"], + createForPullRequestReviewComment: ["POST /repos/{owner}/{repo}/pulls/comments/{comment_id}/reactions"], + createForRelease: ["POST /repos/{owner}/{repo}/releases/{release_id}/reactions"], + createForTeamDiscussionCommentInOrg: ["POST /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/comments/{comment_number}/reactions"], + createForTeamDiscussionInOrg: ["POST /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/reactions"], + deleteForCommitComment: ["DELETE /repos/{owner}/{repo}/comments/{comment_id}/reactions/{reaction_id}"], + deleteForIssue: ["DELETE /repos/{owner}/{repo}/issues/{issue_number}/reactions/{reaction_id}"], + deleteForIssueComment: ["DELETE /repos/{owner}/{repo}/issues/comments/{comment_id}/reactions/{reaction_id}"], + deleteForPullRequestComment: ["DELETE /repos/{owner}/{repo}/pulls/comments/{comment_id}/reactions/{reaction_id}"], + deleteForRelease: ["DELETE /repos/{owner}/{repo}/releases/{release_id}/reactions/{reaction_id}"], + deleteForTeamDiscussion: ["DELETE /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/reactions/{reaction_id}"], + deleteForTeamDiscussionComment: ["DELETE /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/comments/{comment_number}/reactions/{reaction_id}"], + listForCommitComment: ["GET /repos/{owner}/{repo}/comments/{comment_id}/reactions"], + listForIssue: ["GET /repos/{owner}/{repo}/issues/{issue_number}/reactions"], + listForIssueComment: ["GET /repos/{owner}/{repo}/issues/comments/{comment_id}/reactions"], + listForPullRequestReviewComment: ["GET /repos/{owner}/{repo}/pulls/comments/{comment_id}/reactions"], + listForRelease: ["GET /repos/{owner}/{repo}/releases/{release_id}/reactions"], + listForTeamDiscussionCommentInOrg: ["GET /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/comments/{comment_number}/reactions"], + listForTeamDiscussionInOrg: ["GET /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/reactions"] + }, + repos: { + acceptInvitation: ["PATCH /user/repository_invitations/{invitation_id}", {}, { + renamed: ["repos", "acceptInvitationForAuthenticatedUser"] + }], + acceptInvitationForAuthenticatedUser: ["PATCH /user/repository_invitations/{invitation_id}"], + addAppAccessRestrictions: ["POST /repos/{owner}/{repo}/branches/{branch}/protection/restrictions/apps", {}, { + mapToData: "apps" + }], + addCollaborator: ["PUT /repos/{owner}/{repo}/collaborators/{username}"], + addStatusCheckContexts: ["POST /repos/{owner}/{repo}/branches/{branch}/protection/required_status_checks/contexts", {}, { + mapToData: "contexts" + }], + addTeamAccessRestrictions: ["POST /repos/{owner}/{repo}/branches/{branch}/protection/restrictions/teams", {}, { + mapToData: "teams" + }], + addUserAccessRestrictions: ["POST /repos/{owner}/{repo}/branches/{branch}/protection/restrictions/users", {}, { + mapToData: "users" + }], + checkCollaborator: ["GET /repos/{owner}/{repo}/collaborators/{username}"], + checkVulnerabilityAlerts: ["GET /repos/{owner}/{repo}/vulnerability-alerts"], + codeownersErrors: ["GET /repos/{owner}/{repo}/codeowners/errors"], + compareCommits: ["GET /repos/{owner}/{repo}/compare/{base}...{head}"], + compareCommitsWithBasehead: ["GET /repos/{owner}/{repo}/compare/{basehead}"], + createAutolink: ["POST /repos/{owner}/{repo}/autolinks"], + createCommitComment: ["POST /repos/{owner}/{repo}/commits/{commit_sha}/comments"], + createCommitSignatureProtection: ["POST /repos/{owner}/{repo}/branches/{branch}/protection/required_signatures"], + createCommitStatus: ["POST /repos/{owner}/{repo}/statuses/{sha}"], + createDeployKey: ["POST /repos/{owner}/{repo}/keys"], + createDeployment: ["POST /repos/{owner}/{repo}/deployments"], + createDeploymentStatus: ["POST /repos/{owner}/{repo}/deployments/{deployment_id}/statuses"], + createDispatchEvent: ["POST /repos/{owner}/{repo}/dispatches"], + createForAuthenticatedUser: ["POST /user/repos"], + createFork: ["POST /repos/{owner}/{repo}/forks"], + createInOrg: ["POST /orgs/{org}/repos"], + createOrUpdateEnvironment: ["PUT /repos/{owner}/{repo}/environments/{environment_name}"], + createOrUpdateFileContents: ["PUT /repos/{owner}/{repo}/contents/{path}"], + createPagesSite: ["POST /repos/{owner}/{repo}/pages"], + createRelease: ["POST /repos/{owner}/{repo}/releases"], + createTagProtection: ["POST /repos/{owner}/{repo}/tags/protection"], + createUsingTemplate: ["POST /repos/{template_owner}/{template_repo}/generate"], + createWebhook: ["POST /repos/{owner}/{repo}/hooks"], + declineInvitation: ["DELETE /user/repository_invitations/{invitation_id}", {}, { + renamed: ["repos", "declineInvitationForAuthenticatedUser"] + }], + declineInvitationForAuthenticatedUser: ["DELETE /user/repository_invitations/{invitation_id}"], + delete: ["DELETE /repos/{owner}/{repo}"], + deleteAccessRestrictions: ["DELETE /repos/{owner}/{repo}/branches/{branch}/protection/restrictions"], + deleteAdminBranchProtection: ["DELETE /repos/{owner}/{repo}/branches/{branch}/protection/enforce_admins"], + deleteAnEnvironment: ["DELETE /repos/{owner}/{repo}/environments/{environment_name}"], + deleteAutolink: ["DELETE /repos/{owner}/{repo}/autolinks/{autolink_id}"], + deleteBranchProtection: ["DELETE /repos/{owner}/{repo}/branches/{branch}/protection"], + deleteCommitComment: ["DELETE /repos/{owner}/{repo}/comments/{comment_id}"], + deleteCommitSignatureProtection: ["DELETE /repos/{owner}/{repo}/branches/{branch}/protection/required_signatures"], + deleteDeployKey: ["DELETE /repos/{owner}/{repo}/keys/{key_id}"], + deleteDeployment: ["DELETE /repos/{owner}/{repo}/deployments/{deployment_id}"], + deleteFile: ["DELETE /repos/{owner}/{repo}/contents/{path}"], + deleteInvitation: ["DELETE /repos/{owner}/{repo}/invitations/{invitation_id}"], + deletePagesSite: ["DELETE /repos/{owner}/{repo}/pages"], + deletePullRequestReviewProtection: ["DELETE /repos/{owner}/{repo}/branches/{branch}/protection/required_pull_request_reviews"], + deleteRelease: ["DELETE /repos/{owner}/{repo}/releases/{release_id}"], + deleteReleaseAsset: ["DELETE /repos/{owner}/{repo}/releases/assets/{asset_id}"], + deleteTagProtection: ["DELETE /repos/{owner}/{repo}/tags/protection/{tag_protection_id}"], + deleteWebhook: ["DELETE /repos/{owner}/{repo}/hooks/{hook_id}"], + disableAutomatedSecurityFixes: ["DELETE /repos/{owner}/{repo}/automated-security-fixes"], + disableLfsForRepo: ["DELETE /repos/{owner}/{repo}/lfs"], + disableVulnerabilityAlerts: ["DELETE /repos/{owner}/{repo}/vulnerability-alerts"], + downloadArchive: ["GET /repos/{owner}/{repo}/zipball/{ref}", {}, { + renamed: ["repos", "downloadZipballArchive"] + }], + downloadTarballArchive: ["GET /repos/{owner}/{repo}/tarball/{ref}"], + downloadZipballArchive: ["GET /repos/{owner}/{repo}/zipball/{ref}"], + enableAutomatedSecurityFixes: ["PUT /repos/{owner}/{repo}/automated-security-fixes"], + enableLfsForRepo: ["PUT /repos/{owner}/{repo}/lfs"], + enableVulnerabilityAlerts: ["PUT /repos/{owner}/{repo}/vulnerability-alerts"], + generateReleaseNotes: ["POST /repos/{owner}/{repo}/releases/generate-notes"], + get: ["GET /repos/{owner}/{repo}"], + getAccessRestrictions: ["GET /repos/{owner}/{repo}/branches/{branch}/protection/restrictions"], + getAdminBranchProtection: ["GET /repos/{owner}/{repo}/branches/{branch}/protection/enforce_admins"], + getAllEnvironments: ["GET /repos/{owner}/{repo}/environments"], + getAllStatusCheckContexts: ["GET /repos/{owner}/{repo}/branches/{branch}/protection/required_status_checks/contexts"], + getAllTopics: ["GET /repos/{owner}/{repo}/topics"], + getAppsWithAccessToProtectedBranch: ["GET /repos/{owner}/{repo}/branches/{branch}/protection/restrictions/apps"], + getAutolink: ["GET /repos/{owner}/{repo}/autolinks/{autolink_id}"], + getBranch: ["GET /repos/{owner}/{repo}/branches/{branch}"], + getBranchProtection: ["GET /repos/{owner}/{repo}/branches/{branch}/protection"], + getClones: ["GET /repos/{owner}/{repo}/traffic/clones"], + getCodeFrequencyStats: ["GET /repos/{owner}/{repo}/stats/code_frequency"], + getCollaboratorPermissionLevel: ["GET /repos/{owner}/{repo}/collaborators/{username}/permission"], + getCombinedStatusForRef: ["GET /repos/{owner}/{repo}/commits/{ref}/status"], + getCommit: ["GET /repos/{owner}/{repo}/commits/{ref}"], + getCommitActivityStats: ["GET /repos/{owner}/{repo}/stats/commit_activity"], + getCommitComment: ["GET /repos/{owner}/{repo}/comments/{comment_id}"], + getCommitSignatureProtection: ["GET /repos/{owner}/{repo}/branches/{branch}/protection/required_signatures"], + getCommunityProfileMetrics: ["GET /repos/{owner}/{repo}/community/profile"], + getContent: ["GET /repos/{owner}/{repo}/contents/{path}"], + getContributorsStats: ["GET /repos/{owner}/{repo}/stats/contributors"], + getDeployKey: ["GET /repos/{owner}/{repo}/keys/{key_id}"], + getDeployment: ["GET /repos/{owner}/{repo}/deployments/{deployment_id}"], + getDeploymentStatus: ["GET /repos/{owner}/{repo}/deployments/{deployment_id}/statuses/{status_id}"], + getEnvironment: ["GET /repos/{owner}/{repo}/environments/{environment_name}"], + getLatestPagesBuild: ["GET /repos/{owner}/{repo}/pages/builds/latest"], + getLatestRelease: ["GET /repos/{owner}/{repo}/releases/latest"], + getPages: ["GET /repos/{owner}/{repo}/pages"], + getPagesBuild: ["GET /repos/{owner}/{repo}/pages/builds/{build_id}"], + getPagesHealthCheck: ["GET /repos/{owner}/{repo}/pages/health"], + getParticipationStats: ["GET /repos/{owner}/{repo}/stats/participation"], + getPullRequestReviewProtection: ["GET /repos/{owner}/{repo}/branches/{branch}/protection/required_pull_request_reviews"], + getPunchCardStats: ["GET /repos/{owner}/{repo}/stats/punch_card"], + getReadme: ["GET /repos/{owner}/{repo}/readme"], + getReadmeInDirectory: ["GET /repos/{owner}/{repo}/readme/{dir}"], + getRelease: ["GET /repos/{owner}/{repo}/releases/{release_id}"], + getReleaseAsset: ["GET /repos/{owner}/{repo}/releases/assets/{asset_id}"], + getReleaseByTag: ["GET /repos/{owner}/{repo}/releases/tags/{tag}"], + getStatusChecksProtection: ["GET /repos/{owner}/{repo}/branches/{branch}/protection/required_status_checks"], + getTeamsWithAccessToProtectedBranch: ["GET /repos/{owner}/{repo}/branches/{branch}/protection/restrictions/teams"], + getTopPaths: ["GET /repos/{owner}/{repo}/traffic/popular/paths"], + getTopReferrers: ["GET /repos/{owner}/{repo}/traffic/popular/referrers"], + getUsersWithAccessToProtectedBranch: ["GET /repos/{owner}/{repo}/branches/{branch}/protection/restrictions/users"], + getViews: ["GET /repos/{owner}/{repo}/traffic/views"], + getWebhook: ["GET /repos/{owner}/{repo}/hooks/{hook_id}"], + getWebhookConfigForRepo: ["GET /repos/{owner}/{repo}/hooks/{hook_id}/config"], + getWebhookDelivery: ["GET /repos/{owner}/{repo}/hooks/{hook_id}/deliveries/{delivery_id}"], + listAutolinks: ["GET /repos/{owner}/{repo}/autolinks"], + listBranches: ["GET /repos/{owner}/{repo}/branches"], + listBranchesForHeadCommit: ["GET /repos/{owner}/{repo}/commits/{commit_sha}/branches-where-head"], + listCollaborators: ["GET /repos/{owner}/{repo}/collaborators"], + listCommentsForCommit: ["GET /repos/{owner}/{repo}/commits/{commit_sha}/comments"], + listCommitCommentsForRepo: ["GET /repos/{owner}/{repo}/comments"], + listCommitStatusesForRef: ["GET /repos/{owner}/{repo}/commits/{ref}/statuses"], + listCommits: ["GET /repos/{owner}/{repo}/commits"], + listContributors: ["GET /repos/{owner}/{repo}/contributors"], + listDeployKeys: ["GET /repos/{owner}/{repo}/keys"], + listDeploymentStatuses: ["GET /repos/{owner}/{repo}/deployments/{deployment_id}/statuses"], + listDeployments: ["GET /repos/{owner}/{repo}/deployments"], + listForAuthenticatedUser: ["GET /user/repos"], + listForOrg: ["GET /orgs/{org}/repos"], + listForUser: ["GET /users/{username}/repos"], + listForks: ["GET /repos/{owner}/{repo}/forks"], + listInvitations: ["GET /repos/{owner}/{repo}/invitations"], + listInvitationsForAuthenticatedUser: ["GET /user/repository_invitations"], + listLanguages: ["GET /repos/{owner}/{repo}/languages"], + listPagesBuilds: ["GET /repos/{owner}/{repo}/pages/builds"], + listPublic: ["GET /repositories"], + listPullRequestsAssociatedWithCommit: ["GET /repos/{owner}/{repo}/commits/{commit_sha}/pulls"], + listReleaseAssets: ["GET /repos/{owner}/{repo}/releases/{release_id}/assets"], + listReleases: ["GET /repos/{owner}/{repo}/releases"], + listTagProtection: ["GET /repos/{owner}/{repo}/tags/protection"], + listTags: ["GET /repos/{owner}/{repo}/tags"], + listTeams: ["GET /repos/{owner}/{repo}/teams"], + listWebhookDeliveries: ["GET /repos/{owner}/{repo}/hooks/{hook_id}/deliveries"], + listWebhooks: ["GET /repos/{owner}/{repo}/hooks"], + merge: ["POST /repos/{owner}/{repo}/merges"], + mergeUpstream: ["POST /repos/{owner}/{repo}/merge-upstream"], + pingWebhook: ["POST /repos/{owner}/{repo}/hooks/{hook_id}/pings"], + redeliverWebhookDelivery: ["POST /repos/{owner}/{repo}/hooks/{hook_id}/deliveries/{delivery_id}/attempts"], + removeAppAccessRestrictions: ["DELETE /repos/{owner}/{repo}/branches/{branch}/protection/restrictions/apps", {}, { + mapToData: "apps" + }], + removeCollaborator: ["DELETE /repos/{owner}/{repo}/collaborators/{username}"], + removeStatusCheckContexts: ["DELETE /repos/{owner}/{repo}/branches/{branch}/protection/required_status_checks/contexts", {}, { + mapToData: "contexts" + }], + removeStatusCheckProtection: ["DELETE /repos/{owner}/{repo}/branches/{branch}/protection/required_status_checks"], + removeTeamAccessRestrictions: ["DELETE /repos/{owner}/{repo}/branches/{branch}/protection/restrictions/teams", {}, { + mapToData: "teams" + }], + removeUserAccessRestrictions: ["DELETE /repos/{owner}/{repo}/branches/{branch}/protection/restrictions/users", {}, { + mapToData: "users" + }], + renameBranch: ["POST /repos/{owner}/{repo}/branches/{branch}/rename"], + replaceAllTopics: ["PUT /repos/{owner}/{repo}/topics"], + requestPagesBuild: ["POST /repos/{owner}/{repo}/pages/builds"], + setAdminBranchProtection: ["POST /repos/{owner}/{repo}/branches/{branch}/protection/enforce_admins"], + setAppAccessRestrictions: ["PUT /repos/{owner}/{repo}/branches/{branch}/protection/restrictions/apps", {}, { + mapToData: "apps" + }], + setStatusCheckContexts: ["PUT /repos/{owner}/{repo}/branches/{branch}/protection/required_status_checks/contexts", {}, { + mapToData: "contexts" + }], + setTeamAccessRestrictions: ["PUT /repos/{owner}/{repo}/branches/{branch}/protection/restrictions/teams", {}, { + mapToData: "teams" + }], + setUserAccessRestrictions: ["PUT /repos/{owner}/{repo}/branches/{branch}/protection/restrictions/users", {}, { + mapToData: "users" + }], + testPushWebhook: ["POST /repos/{owner}/{repo}/hooks/{hook_id}/tests"], + transfer: ["POST /repos/{owner}/{repo}/transfer"], + update: ["PATCH /repos/{owner}/{repo}"], + updateBranchProtection: ["PUT /repos/{owner}/{repo}/branches/{branch}/protection"], + updateCommitComment: ["PATCH /repos/{owner}/{repo}/comments/{comment_id}"], + updateInformationAboutPagesSite: ["PUT /repos/{owner}/{repo}/pages"], + updateInvitation: ["PATCH /repos/{owner}/{repo}/invitations/{invitation_id}"], + updatePullRequestReviewProtection: ["PATCH /repos/{owner}/{repo}/branches/{branch}/protection/required_pull_request_reviews"], + updateRelease: ["PATCH /repos/{owner}/{repo}/releases/{release_id}"], + updateReleaseAsset: ["PATCH /repos/{owner}/{repo}/releases/assets/{asset_id}"], + updateStatusCheckPotection: ["PATCH /repos/{owner}/{repo}/branches/{branch}/protection/required_status_checks", {}, { + renamed: ["repos", "updateStatusCheckProtection"] + }], + updateStatusCheckProtection: ["PATCH /repos/{owner}/{repo}/branches/{branch}/protection/required_status_checks"], + updateWebhook: ["PATCH /repos/{owner}/{repo}/hooks/{hook_id}"], + updateWebhookConfigForRepo: ["PATCH /repos/{owner}/{repo}/hooks/{hook_id}/config"], + uploadReleaseAsset: ["POST /repos/{owner}/{repo}/releases/{release_id}/assets{?name,label}", { + baseUrl: "https://uploads.github.com" + }] + }, + search: { + code: ["GET /search/code"], + commits: ["GET /search/commits"], + issuesAndPullRequests: ["GET /search/issues"], + labels: ["GET /search/labels"], + repos: ["GET /search/repositories"], + topics: ["GET /search/topics"], + users: ["GET /search/users"] + }, + secretScanning: { + getAlert: ["GET /repos/{owner}/{repo}/secret-scanning/alerts/{alert_number}"], + listAlertsForEnterprise: ["GET /enterprises/{enterprise}/secret-scanning/alerts"], + listAlertsForOrg: ["GET /orgs/{org}/secret-scanning/alerts"], + listAlertsForRepo: ["GET /repos/{owner}/{repo}/secret-scanning/alerts"], + listLocationsForAlert: ["GET /repos/{owner}/{repo}/secret-scanning/alerts/{alert_number}/locations"], + updateAlert: ["PATCH /repos/{owner}/{repo}/secret-scanning/alerts/{alert_number}"] + }, + teams: { + addOrUpdateMembershipForUserInOrg: ["PUT /orgs/{org}/teams/{team_slug}/memberships/{username}"], + addOrUpdateProjectPermissionsInOrg: ["PUT /orgs/{org}/teams/{team_slug}/projects/{project_id}"], + addOrUpdateRepoPermissionsInOrg: ["PUT /orgs/{org}/teams/{team_slug}/repos/{owner}/{repo}"], + checkPermissionsForProjectInOrg: ["GET /orgs/{org}/teams/{team_slug}/projects/{project_id}"], + checkPermissionsForRepoInOrg: ["GET /orgs/{org}/teams/{team_slug}/repos/{owner}/{repo}"], + create: ["POST /orgs/{org}/teams"], + createDiscussionCommentInOrg: ["POST /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/comments"], + createDiscussionInOrg: ["POST /orgs/{org}/teams/{team_slug}/discussions"], + deleteDiscussionCommentInOrg: ["DELETE /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/comments/{comment_number}"], + deleteDiscussionInOrg: ["DELETE /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}"], + deleteInOrg: ["DELETE /orgs/{org}/teams/{team_slug}"], + getByName: ["GET /orgs/{org}/teams/{team_slug}"], + getDiscussionCommentInOrg: ["GET /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/comments/{comment_number}"], + getDiscussionInOrg: ["GET /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}"], + getMembershipForUserInOrg: ["GET /orgs/{org}/teams/{team_slug}/memberships/{username}"], + list: ["GET /orgs/{org}/teams"], + listChildInOrg: ["GET /orgs/{org}/teams/{team_slug}/teams"], + listDiscussionCommentsInOrg: ["GET /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/comments"], + listDiscussionsInOrg: ["GET /orgs/{org}/teams/{team_slug}/discussions"], + listForAuthenticatedUser: ["GET /user/teams"], + listMembersInOrg: ["GET /orgs/{org}/teams/{team_slug}/members"], + listPendingInvitationsInOrg: ["GET /orgs/{org}/teams/{team_slug}/invitations"], + listProjectsInOrg: ["GET /orgs/{org}/teams/{team_slug}/projects"], + listReposInOrg: ["GET /orgs/{org}/teams/{team_slug}/repos"], + removeMembershipForUserInOrg: ["DELETE /orgs/{org}/teams/{team_slug}/memberships/{username}"], + removeProjectInOrg: ["DELETE /orgs/{org}/teams/{team_slug}/projects/{project_id}"], + removeRepoInOrg: ["DELETE /orgs/{org}/teams/{team_slug}/repos/{owner}/{repo}"], + updateDiscussionCommentInOrg: ["PATCH /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/comments/{comment_number}"], + updateDiscussionInOrg: ["PATCH /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}"], + updateInOrg: ["PATCH /orgs/{org}/teams/{team_slug}"] + }, + users: { + addEmailForAuthenticated: ["POST /user/emails", {}, { + renamed: ["users", "addEmailForAuthenticatedUser"] + }], + addEmailForAuthenticatedUser: ["POST /user/emails"], + block: ["PUT /user/blocks/{username}"], + checkBlocked: ["GET /user/blocks/{username}"], + checkFollowingForUser: ["GET /users/{username}/following/{target_user}"], + checkPersonIsFollowedByAuthenticated: ["GET /user/following/{username}"], + createGpgKeyForAuthenticated: ["POST /user/gpg_keys", {}, { + renamed: ["users", "createGpgKeyForAuthenticatedUser"] + }], + createGpgKeyForAuthenticatedUser: ["POST /user/gpg_keys"], + createPublicSshKeyForAuthenticated: ["POST /user/keys", {}, { + renamed: ["users", "createPublicSshKeyForAuthenticatedUser"] + }], + createPublicSshKeyForAuthenticatedUser: ["POST /user/keys"], + deleteEmailForAuthenticated: ["DELETE /user/emails", {}, { + renamed: ["users", "deleteEmailForAuthenticatedUser"] + }], + deleteEmailForAuthenticatedUser: ["DELETE /user/emails"], + deleteGpgKeyForAuthenticated: ["DELETE /user/gpg_keys/{gpg_key_id}", {}, { + renamed: ["users", "deleteGpgKeyForAuthenticatedUser"] + }], + deleteGpgKeyForAuthenticatedUser: ["DELETE /user/gpg_keys/{gpg_key_id}"], + deletePublicSshKeyForAuthenticated: ["DELETE /user/keys/{key_id}", {}, { + renamed: ["users", "deletePublicSshKeyForAuthenticatedUser"] + }], + deletePublicSshKeyForAuthenticatedUser: ["DELETE /user/keys/{key_id}"], + follow: ["PUT /user/following/{username}"], + getAuthenticated: ["GET /user"], + getByUsername: ["GET /users/{username}"], + getContextForUser: ["GET /users/{username}/hovercard"], + getGpgKeyForAuthenticated: ["GET /user/gpg_keys/{gpg_key_id}", {}, { + renamed: ["users", "getGpgKeyForAuthenticatedUser"] + }], + getGpgKeyForAuthenticatedUser: ["GET /user/gpg_keys/{gpg_key_id}"], + getPublicSshKeyForAuthenticated: ["GET /user/keys/{key_id}", {}, { + renamed: ["users", "getPublicSshKeyForAuthenticatedUser"] + }], + getPublicSshKeyForAuthenticatedUser: ["GET /user/keys/{key_id}"], + list: ["GET /users"], + listBlockedByAuthenticated: ["GET /user/blocks", {}, { + renamed: ["users", "listBlockedByAuthenticatedUser"] + }], + listBlockedByAuthenticatedUser: ["GET /user/blocks"], + listEmailsForAuthenticated: ["GET /user/emails", {}, { + renamed: ["users", "listEmailsForAuthenticatedUser"] + }], + listEmailsForAuthenticatedUser: ["GET /user/emails"], + listFollowedByAuthenticated: ["GET /user/following", {}, { + renamed: ["users", "listFollowedByAuthenticatedUser"] + }], + listFollowedByAuthenticatedUser: ["GET /user/following"], + listFollowersForAuthenticatedUser: ["GET /user/followers"], + listFollowersForUser: ["GET /users/{username}/followers"], + listFollowingForUser: ["GET /users/{username}/following"], + listGpgKeysForAuthenticated: ["GET /user/gpg_keys", {}, { + renamed: ["users", "listGpgKeysForAuthenticatedUser"] + }], + listGpgKeysForAuthenticatedUser: ["GET /user/gpg_keys"], + listGpgKeysForUser: ["GET /users/{username}/gpg_keys"], + listPublicEmailsForAuthenticated: ["GET /user/public_emails", {}, { + renamed: ["users", "listPublicEmailsForAuthenticatedUser"] + }], + listPublicEmailsForAuthenticatedUser: ["GET /user/public_emails"], + listPublicKeysForUser: ["GET /users/{username}/keys"], + listPublicSshKeysForAuthenticated: ["GET /user/keys", {}, { + renamed: ["users", "listPublicSshKeysForAuthenticatedUser"] + }], + listPublicSshKeysForAuthenticatedUser: ["GET /user/keys"], + setPrimaryEmailVisibilityForAuthenticated: ["PATCH /user/email/visibility", {}, { + renamed: ["users", "setPrimaryEmailVisibilityForAuthenticatedUser"] + }], + setPrimaryEmailVisibilityForAuthenticatedUser: ["PATCH /user/email/visibility"], + unblock: ["DELETE /user/blocks/{username}"], + unfollow: ["DELETE /user/following/{username}"], + updateAuthenticated: ["PATCH /user"] + } +}; + +const VERSION = "5.16.2"; + +function endpointsToMethods(octokit, endpointsMap) { + const newMethods = {}; + + for (const [scope, endpoints] of Object.entries(endpointsMap)) { + for (const [methodName, endpoint] of Object.entries(endpoints)) { + const [route, defaults, decorations] = endpoint; + const [method, url] = route.split(/ /); + const endpointDefaults = Object.assign({ + method, + url + }, defaults); + + if (!newMethods[scope]) { + newMethods[scope] = {}; + } + + const scopeMethods = newMethods[scope]; + + if (decorations) { + scopeMethods[methodName] = decorate(octokit, scope, methodName, endpointDefaults, decorations); + continue; + } + + scopeMethods[methodName] = octokit.request.defaults(endpointDefaults); + } + } + + return newMethods; +} + +function decorate(octokit, scope, methodName, defaults, decorations) { + const requestWithDefaults = octokit.request.defaults(defaults); + /* istanbul ignore next */ + + function withDecorations(...args) { + // @ts-ignore https://github.com/microsoft/TypeScript/issues/25488 + let options = requestWithDefaults.endpoint.merge(...args); // There are currently no other decorations than `.mapToData` + + if (decorations.mapToData) { + options = Object.assign({}, options, { + data: options[decorations.mapToData], + [decorations.mapToData]: undefined + }); + return requestWithDefaults(options); + } + + if (decorations.renamed) { + const [newScope, newMethodName] = decorations.renamed; + octokit.log.warn(`octokit.${scope}.${methodName}() has been renamed to octokit.${newScope}.${newMethodName}()`); + } + + if (decorations.deprecated) { + octokit.log.warn(decorations.deprecated); + } + + if (decorations.renamedParameters) { + // @ts-ignore https://github.com/microsoft/TypeScript/issues/25488 + const options = requestWithDefaults.endpoint.merge(...args); + + for (const [name, alias] of Object.entries(decorations.renamedParameters)) { + if (name in options) { + octokit.log.warn(`"${name}" parameter is deprecated for "octokit.${scope}.${methodName}()". Use "${alias}" instead`); + + if (!(alias in options)) { + options[alias] = options[name]; + } + + delete options[name]; + } + } + + return requestWithDefaults(options); + } // @ts-ignore https://github.com/microsoft/TypeScript/issues/25488 + + + return requestWithDefaults(...args); + } + + return Object.assign(withDecorations, requestWithDefaults); +} + +function restEndpointMethods(octokit) { + const api = endpointsToMethods(octokit, Endpoints); + return { + rest: api + }; +} +restEndpointMethods.VERSION = VERSION; +function legacyRestEndpointMethods(octokit) { + const api = endpointsToMethods(octokit, Endpoints); + return _objectSpread2(_objectSpread2({}, api), {}, { + rest: api + }); +} +legacyRestEndpointMethods.VERSION = VERSION; + +exports.legacyRestEndpointMethods = legacyRestEndpointMethods; +exports.restEndpointMethods = restEndpointMethods; +//# sourceMappingURL=index.js.map + + +/***/ }), + +/***/ 6298: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + + +Object.defineProperty(exports, "__esModule", ({ value: true })); + +function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; } + +var Bottleneck = _interopDefault(__nccwpck_require__(1174)); +var requestError = __nccwpck_require__(537); + +// @ts-ignore +async function errorRequest(octokit, state, error, options) { + if (!error.request || !error.request.request) { + // address https://github.com/octokit/plugin-retry.js/issues/8 + throw error; + } + // retry all >= 400 && not doNotRetry + if (error.status >= 400 && !state.doNotRetry.includes(error.status)) { + const retries = options.request.retries != null ? options.request.retries : state.retries; + const retryAfter = Math.pow((options.request.retryCount || 0) + 1, 2); + throw octokit.retry.retryRequest(error, retries, retryAfter); + } + // Maybe eventually there will be more cases here + throw error; +} + +// @ts-ignore +// @ts-ignore +async function wrapRequest(state, request, options) { + const limiter = new Bottleneck(); + // @ts-ignore + limiter.on("failed", function (error, info) { + const maxRetries = ~~error.request.request.retries; + const after = ~~error.request.request.retryAfter; + options.request.retryCount = info.retryCount + 1; + if (maxRetries > info.retryCount) { + // Returning a number instructs the limiter to retry + // the request after that number of milliseconds have passed + return after * state.retryAfterBaseValue; + } + }); + return limiter.schedule(requestWithGraphqlErrorHandling.bind(null, request), options); +} +// @ts-ignore +async function requestWithGraphqlErrorHandling(request, options) { + const response = await request(request, options); + if (response.data && response.data.errors && /Something went wrong while executing your query/.test(response.data.errors[0].message)) { + // simulate 500 request error for retry handling + const error = new requestError.RequestError(response.data.errors[0].message, 500, { + request: options, + response + }); + throw error; + } + return response; +} + +const VERSION = "4.1.1"; +function retry(octokit, octokitOptions) { + const state = Object.assign({ + enabled: true, + retryAfterBaseValue: 1000, + doNotRetry: [400, 401, 403, 404, 422], + retries: 3 + }, octokitOptions.retry); + if (state.enabled) { + octokit.hook.error("request", errorRequest.bind(null, octokit, state)); + octokit.hook.wrap("request", wrapRequest.bind(null, state)); + } + return { + retry: { + retryRequest: (error, retries, retryAfter) => { + error.request.request = Object.assign({}, error.request.request, { + retries: retries, + retryAfter: retryAfter + }); + return error; + } + } + }; +} +retry.VERSION = VERSION; + +exports.VERSION = VERSION; +exports.retry = retry; +//# sourceMappingURL=index.js.map + + +/***/ }), + +/***/ 537: +/***/ ((__unused_webpack_module, exports, __nccwpck_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 = __nccwpck_require__(8932); +var once = _interopDefault(__nccwpck_require__(1223)); + +const logOnceCode = once(deprecation => console.warn(deprecation)); +const logOnceHeaders = once(deprecation => console.warn(deprecation)); +/** + * Error with extra properties to help with debugging + */ +class RequestError extends Error { + constructor(message, statusCode, options) { + super(message); + // Maintains proper stack trace (only available on V8) + /* istanbul ignore next */ + if (Error.captureStackTrace) { + Error.captureStackTrace(this, this.constructor); + } + this.name = "HttpError"; + this.status = statusCode; + let headers; + if ("headers" in options && typeof options.headers !== "undefined") { + headers = options.headers; + } + if ("response" in options) { + this.response = options.response; + headers = options.response.headers; + } + // redact request credentials without mutating original request options + const requestCopy = Object.assign({}, options.request); + if (options.request.headers.authorization) { + requestCopy.headers = Object.assign({}, options.request.headers, { + authorization: options.request.headers.authorization.replace(/ .*$/, " [REDACTED]") + }); + } + requestCopy.url = requestCopy.url + // client_id & client_secret can be passed as URL query parameters to increase rate limit + // see https://developer.github.com/v3/#increasing-the-unauthenticated-rate-limit-for-oauth-applications + .replace(/\bclient_secret=\w+/g, "client_secret=[REDACTED]") + // OAuth tokens can be passed as URL query parameters, although it is not recommended + // see https://developer.github.com/v3/#oauth2-token-sent-in-a-header + .replace(/\baccess_token=\w+/g, "access_token=[REDACTED]"); + this.request = requestCopy; + // deprecations + Object.defineProperty(this, "code", { + get() { + logOnceCode(new deprecation.Deprecation("[@octokit/request-error] `error.code` is deprecated, use `error.status`.")); + return statusCode; + } + }); + Object.defineProperty(this, "headers", { + get() { + logOnceHeaders(new deprecation.Deprecation("[@octokit/request-error] `error.headers` is deprecated, use `error.response.headers`.")); + return headers || {}; + } + }); + } +} + +exports.RequestError = RequestError; +//# sourceMappingURL=index.js.map + + +/***/ }), + +/***/ 6234: +/***/ ((__unused_webpack_module, exports, __nccwpck_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 = __nccwpck_require__(9440); +var universalUserAgent = __nccwpck_require__(5030); +var isPlainObject = __nccwpck_require__(3287); +var nodeFetch = _interopDefault(__nccwpck_require__(467)); +var requestError = __nccwpck_require__(537); + +const VERSION = "6.2.3"; + +function getBufferResponse(response) { + return response.arrayBuffer(); +} + +function fetchWrapper(requestOptions) { + const log = requestOptions.request && requestOptions.request.log ? requestOptions.request.log : console; + if (isPlainObject.isPlainObject(requestOptions.body) || Array.isArray(requestOptions.body)) { + requestOptions.body = JSON.stringify(requestOptions.body); + } + let headers = {}; + let status; + let url; + const fetch = requestOptions.request && requestOptions.request.fetch || globalThis.fetch || /* istanbul ignore next */nodeFetch; + return fetch(requestOptions.url, Object.assign({ + method: requestOptions.method, + body: requestOptions.body, + headers: requestOptions.headers, + redirect: requestOptions.redirect + }, + // `requestOptions.request.agent` type is incompatible + // see https://github.com/octokit/types.ts/pull/264 + requestOptions.request)).then(async response => { + url = response.url; + status = response.status; + for (const keyAndValue of response.headers) { + headers[keyAndValue[0]] = keyAndValue[1]; + } + if ("deprecation" in headers) { + const matches = headers.link && headers.link.match(/<([^>]+)>; rel="deprecation"/); + const deprecationLink = matches && matches.pop(); + log.warn(`[@octokit/request] "${requestOptions.method} ${requestOptions.url}" is deprecated. It is scheduled to be removed on ${headers.sunset}${deprecationLink ? `. See ${deprecationLink}` : ""}`); + } + if (status === 204 || status === 205) { + return; + } + // GitHub API returns 200 for HEAD requests + if (requestOptions.method === "HEAD") { + if (status < 400) { + return; + } + throw new requestError.RequestError(response.statusText, status, { + response: { + url, + status, + headers, + data: undefined + }, + request: requestOptions + }); + } + if (status === 304) { + throw new requestError.RequestError("Not modified", status, { + response: { + url, + status, + headers, + data: await getResponseData(response) + }, + request: requestOptions + }); + } + if (status >= 400) { + const data = await getResponseData(response); + const error = new requestError.RequestError(toErrorMessage(data), status, { + response: { + url, + status, + headers, + data + }, + request: requestOptions + }); + throw error; + } + return getResponseData(response); + }).then(data => { + return { + status, + url, + headers, + data + }; + }).catch(error => { + if (error instanceof requestError.RequestError) throw error;else if (error.name === "AbortError") throw error; + throw new requestError.RequestError(error.message, 500, { + request: requestOptions + }); + }); +} +async function getResponseData(response) { + const contentType = response.headers.get("content-type"); + if (/application\/json/.test(contentType)) { + return response.json(); + } + if (!contentType || /^text\/|charset=utf-8$/.test(contentType)) { + return response.text(); + } + return getBufferResponse(response); +} +function toErrorMessage(data) { + if (typeof data === "string") return data; + // istanbul ignore else - just in case + if ("message" in data) { + if (Array.isArray(data.errors)) { + return `${data.message}: ${data.errors.map(JSON.stringify).join(", ")}`; + } + return data.message; + } + // istanbul ignore next - just in case + return `Unknown error: ${JSON.stringify(data)}`; +} + +function withDefaults(oldEndpoint, newDefaults) { + const endpoint = oldEndpoint.defaults(newDefaults); + const newApi = function (route, parameters) { + const endpointOptions = endpoint.merge(route, parameters); + if (!endpointOptions.request || !endpointOptions.request.hook) { + return fetchWrapper(endpoint.parse(endpointOptions)); + } + const request = (route, parameters) => { + return fetchWrapper(endpoint.parse(endpoint.merge(route, parameters))); + }; + Object.assign(request, { + endpoint, + defaults: withDefaults.bind(null, endpoint) + }); + return endpointOptions.request.hook(request, endpointOptions); + }; + return Object.assign(newApi, { + endpoint, + defaults: withDefaults.bind(null, endpoint) + }); +} + +const request = withDefaults(endpoint.endpoint, { + headers: { + "user-agent": `octokit-request.js/${VERSION} ${universalUserAgent.getUserAgent()}` + } +}); + +exports.request = request; +//# sourceMappingURL=index.js.map + + +/***/ }), + +/***/ 5375: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + + +Object.defineProperty(exports, "__esModule", ({ value: true })); + +var core = __nccwpck_require__(6762); +var pluginRequestLog = __nccwpck_require__(8883); +var pluginPaginateRest = __nccwpck_require__(606); +var pluginRestEndpointMethods = __nccwpck_require__(4923); + +const VERSION = "19.0.7"; + +const Octokit = core.Octokit.plugin(pluginRequestLog.requestLog, pluginRestEndpointMethods.legacyRestEndpointMethods, pluginPaginateRest.paginateRest).defaults({ + userAgent: `octokit-rest.js/${VERSION}` +}); + +exports.Octokit = Octokit; +//# sourceMappingURL=index.js.map + + +/***/ }), + +/***/ 606: +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + + +Object.defineProperty(exports, "__esModule", ({ value: true })); + +const VERSION = "6.0.0"; + +/** + * Some “list” response that can be paginated have a different response structure + * + * They have a `total_count` key in the response (search also has `incomplete_results`, + * /installation/repositories also has `repository_selection`), as well as a key with + * the list of the items which name varies from endpoint to endpoint. + * + * Octokit normalizes these responses so that paginated results are always returned following + * the same structure. One challenge is that if the list response has only one page, no Link + * header is provided, so this header alone is not sufficient to check wether a response is + * paginated or not. + * + * We check if a "total_count" key is present in the response data, but also make sure that + * a "url" property is not, as the "Get the combined status for a specific ref" endpoint would + * otherwise match: https://developer.github.com/v3/repos/statuses/#get-the-combined-status-for-a-specific-ref + */ +function normalizePaginatedListResponse(response) { + // endpoints can respond with 204 if repository is empty + if (!response.data) { + return { + ...response, + data: [] + }; + } + const responseNeedsNormalization = "total_count" in response.data && !("url" in response.data); + if (!responseNeedsNormalization) return response; + // keep the additional properties intact as there is currently no other way + // to retrieve the same information. + const incompleteResults = response.data.incomplete_results; + const repositorySelection = response.data.repository_selection; + const totalCount = response.data.total_count; + delete response.data.incomplete_results; + delete response.data.repository_selection; + delete response.data.total_count; + const namespaceKey = Object.keys(response.data)[0]; + const data = response.data[namespaceKey]; + response.data = data; + if (typeof incompleteResults !== "undefined") { + response.data.incomplete_results = incompleteResults; + } + if (typeof repositorySelection !== "undefined") { + response.data.repository_selection = repositorySelection; + } + response.data.total_count = totalCount; + return response; +} + +function iterator(octokit, route, parameters) { + const options = typeof route === "function" ? route.endpoint(parameters) : octokit.request.endpoint(route, parameters); + const requestMethod = typeof route === "function" ? route : octokit.request; + const method = options.method; + const headers = options.headers; + let url = options.url; + return { + [Symbol.asyncIterator]: () => ({ + async next() { + if (!url) return { + done: true + }; + try { + const response = await requestMethod({ + method, + url, + headers + }); + const normalizedResponse = normalizePaginatedListResponse(response); + // `response.headers.link` format: + // '; rel="next", ; rel="last"' + // sets `url` to undefined if "next" URL is not present or `link` header is not set + url = ((normalizedResponse.headers.link || "").match(/<([^>]+)>;\s*rel="next"/) || [])[1]; + return { + value: normalizedResponse + }; + } catch (error) { + if (error.status !== 409) throw error; + url = ""; + return { + value: { + status: 200, + headers: {}, + data: [] + } + }; + } + } + }) + }; +} + +function paginate(octokit, route, parameters, mapFn) { + if (typeof parameters === "function") { + mapFn = parameters; + parameters = undefined; + } + return gather(octokit, [], iterator(octokit, route, parameters)[Symbol.asyncIterator](), mapFn); +} +function gather(octokit, results, iterator, mapFn) { + return iterator.next().then(result => { + if (result.done) { + return results; + } + let earlyExit = false; + function done() { + earlyExit = true; + } + results = results.concat(mapFn ? mapFn(result.value, done) : result.value.data); + if (earlyExit) { + return results; + } + return gather(octokit, results, iterator, mapFn); + }); +} + +const composePaginateRest = Object.assign(paginate, { + iterator +}); + +const paginatingEndpoints = ["GET /app/hook/deliveries", "GET /app/installations", "GET /enterprises/{enterprise}/actions/runner-groups", "GET /enterprises/{enterprise}/dependabot/alerts", "GET /enterprises/{enterprise}/secret-scanning/alerts", "GET /events", "GET /gists", "GET /gists/public", "GET /gists/starred", "GET /gists/{gist_id}/comments", "GET /gists/{gist_id}/commits", "GET /gists/{gist_id}/forks", "GET /installation/repositories", "GET /issues", "GET /licenses", "GET /marketplace_listing/plans", "GET /marketplace_listing/plans/{plan_id}/accounts", "GET /marketplace_listing/stubbed/plans", "GET /marketplace_listing/stubbed/plans/{plan_id}/accounts", "GET /networks/{owner}/{repo}/events", "GET /notifications", "GET /organizations", "GET /orgs/{org}/actions/cache/usage-by-repository", "GET /orgs/{org}/actions/permissions/repositories", "GET /orgs/{org}/actions/required_workflows", "GET /orgs/{org}/actions/runner-groups", "GET /orgs/{org}/actions/runner-groups/{runner_group_id}/repositories", "GET /orgs/{org}/actions/runner-groups/{runner_group_id}/runners", "GET /orgs/{org}/actions/runners", "GET /orgs/{org}/actions/secrets", "GET /orgs/{org}/actions/secrets/{secret_name}/repositories", "GET /orgs/{org}/actions/variables", "GET /orgs/{org}/actions/variables/{name}/repositories", "GET /orgs/{org}/blocks", "GET /orgs/{org}/code-scanning/alerts", "GET /orgs/{org}/codespaces", "GET /orgs/{org}/codespaces/secrets", "GET /orgs/{org}/codespaces/secrets/{secret_name}/repositories", "GET /orgs/{org}/dependabot/alerts", "GET /orgs/{org}/dependabot/secrets", "GET /orgs/{org}/dependabot/secrets/{secret_name}/repositories", "GET /orgs/{org}/events", "GET /orgs/{org}/failed_invitations", "GET /orgs/{org}/hooks", "GET /orgs/{org}/hooks/{hook_id}/deliveries", "GET /orgs/{org}/installations", "GET /orgs/{org}/invitations", "GET /orgs/{org}/invitations/{invitation_id}/teams", "GET /orgs/{org}/issues", "GET /orgs/{org}/members", "GET /orgs/{org}/members/{username}/codespaces", "GET /orgs/{org}/migrations", "GET /orgs/{org}/migrations/{migration_id}/repositories", "GET /orgs/{org}/outside_collaborators", "GET /orgs/{org}/packages", "GET /orgs/{org}/packages/{package_type}/{package_name}/versions", "GET /orgs/{org}/projects", "GET /orgs/{org}/public_members", "GET /orgs/{org}/repos", "GET /orgs/{org}/secret-scanning/alerts", "GET /orgs/{org}/teams", "GET /orgs/{org}/teams/{team_slug}/discussions", "GET /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/comments", "GET /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/comments/{comment_number}/reactions", "GET /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/reactions", "GET /orgs/{org}/teams/{team_slug}/invitations", "GET /orgs/{org}/teams/{team_slug}/members", "GET /orgs/{org}/teams/{team_slug}/projects", "GET /orgs/{org}/teams/{team_slug}/repos", "GET /orgs/{org}/teams/{team_slug}/teams", "GET /projects/columns/{column_id}/cards", "GET /projects/{project_id}/collaborators", "GET /projects/{project_id}/columns", "GET /repos/{org}/{repo}/actions/required_workflows", "GET /repos/{owner}/{repo}/actions/artifacts", "GET /repos/{owner}/{repo}/actions/caches", "GET /repos/{owner}/{repo}/actions/required_workflows/{required_workflow_id_for_repo}/runs", "GET /repos/{owner}/{repo}/actions/runners", "GET /repos/{owner}/{repo}/actions/runs", "GET /repos/{owner}/{repo}/actions/runs/{run_id}/artifacts", "GET /repos/{owner}/{repo}/actions/runs/{run_id}/attempts/{attempt_number}/jobs", "GET /repos/{owner}/{repo}/actions/runs/{run_id}/jobs", "GET /repos/{owner}/{repo}/actions/secrets", "GET /repos/{owner}/{repo}/actions/variables", "GET /repos/{owner}/{repo}/actions/workflows", "GET /repos/{owner}/{repo}/actions/workflows/{workflow_id}/runs", "GET /repos/{owner}/{repo}/assignees", "GET /repos/{owner}/{repo}/branches", "GET /repos/{owner}/{repo}/check-runs/{check_run_id}/annotations", "GET /repos/{owner}/{repo}/check-suites/{check_suite_id}/check-runs", "GET /repos/{owner}/{repo}/code-scanning/alerts", "GET /repos/{owner}/{repo}/code-scanning/alerts/{alert_number}/instances", "GET /repos/{owner}/{repo}/code-scanning/analyses", "GET /repos/{owner}/{repo}/codespaces", "GET /repos/{owner}/{repo}/codespaces/devcontainers", "GET /repos/{owner}/{repo}/codespaces/secrets", "GET /repos/{owner}/{repo}/collaborators", "GET /repos/{owner}/{repo}/comments", "GET /repos/{owner}/{repo}/comments/{comment_id}/reactions", "GET /repos/{owner}/{repo}/commits", "GET /repos/{owner}/{repo}/commits/{commit_sha}/comments", "GET /repos/{owner}/{repo}/commits/{commit_sha}/pulls", "GET /repos/{owner}/{repo}/commits/{ref}/check-runs", "GET /repos/{owner}/{repo}/commits/{ref}/check-suites", "GET /repos/{owner}/{repo}/commits/{ref}/status", "GET /repos/{owner}/{repo}/commits/{ref}/statuses", "GET /repos/{owner}/{repo}/contributors", "GET /repos/{owner}/{repo}/dependabot/alerts", "GET /repos/{owner}/{repo}/dependabot/secrets", "GET /repos/{owner}/{repo}/deployments", "GET /repos/{owner}/{repo}/deployments/{deployment_id}/statuses", "GET /repos/{owner}/{repo}/environments", "GET /repos/{owner}/{repo}/environments/{environment_name}/deployment-branch-policies", "GET /repos/{owner}/{repo}/events", "GET /repos/{owner}/{repo}/forks", "GET /repos/{owner}/{repo}/hooks", "GET /repos/{owner}/{repo}/hooks/{hook_id}/deliveries", "GET /repos/{owner}/{repo}/invitations", "GET /repos/{owner}/{repo}/issues", "GET /repos/{owner}/{repo}/issues/comments", "GET /repos/{owner}/{repo}/issues/comments/{comment_id}/reactions", "GET /repos/{owner}/{repo}/issues/events", "GET /repos/{owner}/{repo}/issues/{issue_number}/comments", "GET /repos/{owner}/{repo}/issues/{issue_number}/events", "GET /repos/{owner}/{repo}/issues/{issue_number}/labels", "GET /repos/{owner}/{repo}/issues/{issue_number}/reactions", "GET /repos/{owner}/{repo}/issues/{issue_number}/timeline", "GET /repos/{owner}/{repo}/keys", "GET /repos/{owner}/{repo}/labels", "GET /repos/{owner}/{repo}/milestones", "GET /repos/{owner}/{repo}/milestones/{milestone_number}/labels", "GET /repos/{owner}/{repo}/notifications", "GET /repos/{owner}/{repo}/pages/builds", "GET /repos/{owner}/{repo}/projects", "GET /repos/{owner}/{repo}/pulls", "GET /repos/{owner}/{repo}/pulls/comments", "GET /repos/{owner}/{repo}/pulls/comments/{comment_id}/reactions", "GET /repos/{owner}/{repo}/pulls/{pull_number}/comments", "GET /repos/{owner}/{repo}/pulls/{pull_number}/commits", "GET /repos/{owner}/{repo}/pulls/{pull_number}/files", "GET /repos/{owner}/{repo}/pulls/{pull_number}/reviews", "GET /repos/{owner}/{repo}/pulls/{pull_number}/reviews/{review_id}/comments", "GET /repos/{owner}/{repo}/releases", "GET /repos/{owner}/{repo}/releases/{release_id}/assets", "GET /repos/{owner}/{repo}/releases/{release_id}/reactions", "GET /repos/{owner}/{repo}/secret-scanning/alerts", "GET /repos/{owner}/{repo}/secret-scanning/alerts/{alert_number}/locations", "GET /repos/{owner}/{repo}/stargazers", "GET /repos/{owner}/{repo}/subscribers", "GET /repos/{owner}/{repo}/tags", "GET /repos/{owner}/{repo}/teams", "GET /repos/{owner}/{repo}/topics", "GET /repositories", "GET /repositories/{repository_id}/environments/{environment_name}/secrets", "GET /repositories/{repository_id}/environments/{environment_name}/variables", "GET /search/code", "GET /search/commits", "GET /search/issues", "GET /search/labels", "GET /search/repositories", "GET /search/topics", "GET /search/users", "GET /teams/{team_id}/discussions", "GET /teams/{team_id}/discussions/{discussion_number}/comments", "GET /teams/{team_id}/discussions/{discussion_number}/comments/{comment_number}/reactions", "GET /teams/{team_id}/discussions/{discussion_number}/reactions", "GET /teams/{team_id}/invitations", "GET /teams/{team_id}/members", "GET /teams/{team_id}/projects", "GET /teams/{team_id}/repos", "GET /teams/{team_id}/teams", "GET /user/blocks", "GET /user/codespaces", "GET /user/codespaces/secrets", "GET /user/emails", "GET /user/followers", "GET /user/following", "GET /user/gpg_keys", "GET /user/installations", "GET /user/installations/{installation_id}/repositories", "GET /user/issues", "GET /user/keys", "GET /user/marketplace_purchases", "GET /user/marketplace_purchases/stubbed", "GET /user/memberships/orgs", "GET /user/migrations", "GET /user/migrations/{migration_id}/repositories", "GET /user/orgs", "GET /user/packages", "GET /user/packages/{package_type}/{package_name}/versions", "GET /user/public_emails", "GET /user/repos", "GET /user/repository_invitations", "GET /user/ssh_signing_keys", "GET /user/starred", "GET /user/subscriptions", "GET /user/teams", "GET /users", "GET /users/{username}/events", "GET /users/{username}/events/orgs/{org}", "GET /users/{username}/events/public", "GET /users/{username}/followers", "GET /users/{username}/following", "GET /users/{username}/gists", "GET /users/{username}/gpg_keys", "GET /users/{username}/keys", "GET /users/{username}/orgs", "GET /users/{username}/packages", "GET /users/{username}/projects", "GET /users/{username}/received_events", "GET /users/{username}/received_events/public", "GET /users/{username}/repos", "GET /users/{username}/ssh_signing_keys", "GET /users/{username}/starred", "GET /users/{username}/subscriptions"]; + +function isPaginatingEndpoint(arg) { + if (typeof arg === "string") { + return paginatingEndpoints.includes(arg); + } else { + return false; + } +} + +/** + * @param octokit Octokit instance + * @param options Options passed to Octokit constructor + */ +function paginateRest(octokit) { + return { + paginate: Object.assign(paginate.bind(null, octokit), { + iterator: iterator.bind(null, octokit) + }) + }; +} +paginateRest.VERSION = VERSION; + +exports.composePaginateRest = composePaginateRest; +exports.isPaginatingEndpoint = isPaginatingEndpoint; +exports.paginateRest = paginateRest; +exports.paginatingEndpoints = paginatingEndpoints; +//# sourceMappingURL=index.js.map + + +/***/ }), + +/***/ 4923: +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + + +Object.defineProperty(exports, "__esModule", ({ value: true })); + +const Endpoints = { + actions: { + addCustomLabelsToSelfHostedRunnerForOrg: ["POST /orgs/{org}/actions/runners/{runner_id}/labels"], + addCustomLabelsToSelfHostedRunnerForRepo: ["POST /repos/{owner}/{repo}/actions/runners/{runner_id}/labels"], + addSelectedRepoToOrgSecret: ["PUT /orgs/{org}/actions/secrets/{secret_name}/repositories/{repository_id}"], + addSelectedRepoToOrgVariable: ["PUT /orgs/{org}/actions/variables/{name}/repositories/{repository_id}"], + addSelectedRepoToRequiredWorkflow: ["PUT /orgs/{org}/actions/required_workflows/{required_workflow_id}/repositories/{repository_id}"], + approveWorkflowRun: ["POST /repos/{owner}/{repo}/actions/runs/{run_id}/approve"], + cancelWorkflowRun: ["POST /repos/{owner}/{repo}/actions/runs/{run_id}/cancel"], + createEnvironmentVariable: ["POST /repositories/{repository_id}/environments/{environment_name}/variables"], + createOrUpdateEnvironmentSecret: ["PUT /repositories/{repository_id}/environments/{environment_name}/secrets/{secret_name}"], + createOrUpdateOrgSecret: ["PUT /orgs/{org}/actions/secrets/{secret_name}"], + createOrUpdateRepoSecret: ["PUT /repos/{owner}/{repo}/actions/secrets/{secret_name}"], + createOrgVariable: ["POST /orgs/{org}/actions/variables"], + createRegistrationTokenForOrg: ["POST /orgs/{org}/actions/runners/registration-token"], + createRegistrationTokenForRepo: ["POST /repos/{owner}/{repo}/actions/runners/registration-token"], + createRemoveTokenForOrg: ["POST /orgs/{org}/actions/runners/remove-token"], + createRemoveTokenForRepo: ["POST /repos/{owner}/{repo}/actions/runners/remove-token"], + createRepoVariable: ["POST /repos/{owner}/{repo}/actions/variables"], + createRequiredWorkflow: ["POST /orgs/{org}/actions/required_workflows"], + createWorkflowDispatch: ["POST /repos/{owner}/{repo}/actions/workflows/{workflow_id}/dispatches"], + deleteActionsCacheById: ["DELETE /repos/{owner}/{repo}/actions/caches/{cache_id}"], + deleteActionsCacheByKey: ["DELETE /repos/{owner}/{repo}/actions/caches{?key,ref}"], + deleteArtifact: ["DELETE /repos/{owner}/{repo}/actions/artifacts/{artifact_id}"], + deleteEnvironmentSecret: ["DELETE /repositories/{repository_id}/environments/{environment_name}/secrets/{secret_name}"], + deleteEnvironmentVariable: ["DELETE /repositories/{repository_id}/environments/{environment_name}/variables/{name}"], + deleteOrgSecret: ["DELETE /orgs/{org}/actions/secrets/{secret_name}"], + deleteOrgVariable: ["DELETE /orgs/{org}/actions/variables/{name}"], + deleteRepoSecret: ["DELETE /repos/{owner}/{repo}/actions/secrets/{secret_name}"], + deleteRepoVariable: ["DELETE /repos/{owner}/{repo}/actions/variables/{name}"], + deleteRequiredWorkflow: ["DELETE /orgs/{org}/actions/required_workflows/{required_workflow_id}"], + deleteSelfHostedRunnerFromOrg: ["DELETE /orgs/{org}/actions/runners/{runner_id}"], + deleteSelfHostedRunnerFromRepo: ["DELETE /repos/{owner}/{repo}/actions/runners/{runner_id}"], + deleteWorkflowRun: ["DELETE /repos/{owner}/{repo}/actions/runs/{run_id}"], + deleteWorkflowRunLogs: ["DELETE /repos/{owner}/{repo}/actions/runs/{run_id}/logs"], + disableSelectedRepositoryGithubActionsOrganization: ["DELETE /orgs/{org}/actions/permissions/repositories/{repository_id}"], + disableWorkflow: ["PUT /repos/{owner}/{repo}/actions/workflows/{workflow_id}/disable"], + downloadArtifact: ["GET /repos/{owner}/{repo}/actions/artifacts/{artifact_id}/{archive_format}"], + downloadJobLogsForWorkflowRun: ["GET /repos/{owner}/{repo}/actions/jobs/{job_id}/logs"], + downloadWorkflowRunAttemptLogs: ["GET /repos/{owner}/{repo}/actions/runs/{run_id}/attempts/{attempt_number}/logs"], + downloadWorkflowRunLogs: ["GET /repos/{owner}/{repo}/actions/runs/{run_id}/logs"], + enableSelectedRepositoryGithubActionsOrganization: ["PUT /orgs/{org}/actions/permissions/repositories/{repository_id}"], + enableWorkflow: ["PUT /repos/{owner}/{repo}/actions/workflows/{workflow_id}/enable"], + getActionsCacheList: ["GET /repos/{owner}/{repo}/actions/caches"], + getActionsCacheUsage: ["GET /repos/{owner}/{repo}/actions/cache/usage"], + getActionsCacheUsageByRepoForOrg: ["GET /orgs/{org}/actions/cache/usage-by-repository"], + getActionsCacheUsageForOrg: ["GET /orgs/{org}/actions/cache/usage"], + getAllowedActionsOrganization: ["GET /orgs/{org}/actions/permissions/selected-actions"], + getAllowedActionsRepository: ["GET /repos/{owner}/{repo}/actions/permissions/selected-actions"], + getArtifact: ["GET /repos/{owner}/{repo}/actions/artifacts/{artifact_id}"], + getEnvironmentPublicKey: ["GET /repositories/{repository_id}/environments/{environment_name}/secrets/public-key"], + getEnvironmentSecret: ["GET /repositories/{repository_id}/environments/{environment_name}/secrets/{secret_name}"], + getEnvironmentVariable: ["GET /repositories/{repository_id}/environments/{environment_name}/variables/{name}"], + getGithubActionsDefaultWorkflowPermissionsOrganization: ["GET /orgs/{org}/actions/permissions/workflow"], + getGithubActionsDefaultWorkflowPermissionsRepository: ["GET /repos/{owner}/{repo}/actions/permissions/workflow"], + getGithubActionsPermissionsOrganization: ["GET /orgs/{org}/actions/permissions"], + getGithubActionsPermissionsRepository: ["GET /repos/{owner}/{repo}/actions/permissions"], + getJobForWorkflowRun: ["GET /repos/{owner}/{repo}/actions/jobs/{job_id}"], + getOrgPublicKey: ["GET /orgs/{org}/actions/secrets/public-key"], + getOrgSecret: ["GET /orgs/{org}/actions/secrets/{secret_name}"], + getOrgVariable: ["GET /orgs/{org}/actions/variables/{name}"], + getPendingDeploymentsForRun: ["GET /repos/{owner}/{repo}/actions/runs/{run_id}/pending_deployments"], + getRepoPermissions: ["GET /repos/{owner}/{repo}/actions/permissions", {}, { + renamed: ["actions", "getGithubActionsPermissionsRepository"] + }], + getRepoPublicKey: ["GET /repos/{owner}/{repo}/actions/secrets/public-key"], + getRepoRequiredWorkflow: ["GET /repos/{org}/{repo}/actions/required_workflows/{required_workflow_id_for_repo}"], + getRepoRequiredWorkflowUsage: ["GET /repos/{org}/{repo}/actions/required_workflows/{required_workflow_id_for_repo}/timing"], + getRepoSecret: ["GET /repos/{owner}/{repo}/actions/secrets/{secret_name}"], + getRepoVariable: ["GET /repos/{owner}/{repo}/actions/variables/{name}"], + getRequiredWorkflow: ["GET /orgs/{org}/actions/required_workflows/{required_workflow_id}"], + getReviewsForRun: ["GET /repos/{owner}/{repo}/actions/runs/{run_id}/approvals"], + getSelfHostedRunnerForOrg: ["GET /orgs/{org}/actions/runners/{runner_id}"], + getSelfHostedRunnerForRepo: ["GET /repos/{owner}/{repo}/actions/runners/{runner_id}"], + getWorkflow: ["GET /repos/{owner}/{repo}/actions/workflows/{workflow_id}"], + getWorkflowAccessToRepository: ["GET /repos/{owner}/{repo}/actions/permissions/access"], + getWorkflowRun: ["GET /repos/{owner}/{repo}/actions/runs/{run_id}"], + getWorkflowRunAttempt: ["GET /repos/{owner}/{repo}/actions/runs/{run_id}/attempts/{attempt_number}"], + getWorkflowRunUsage: ["GET /repos/{owner}/{repo}/actions/runs/{run_id}/timing"], + getWorkflowUsage: ["GET /repos/{owner}/{repo}/actions/workflows/{workflow_id}/timing"], + listArtifactsForRepo: ["GET /repos/{owner}/{repo}/actions/artifacts"], + listEnvironmentSecrets: ["GET /repositories/{repository_id}/environments/{environment_name}/secrets"], + listEnvironmentVariables: ["GET /repositories/{repository_id}/environments/{environment_name}/variables"], + listJobsForWorkflowRun: ["GET /repos/{owner}/{repo}/actions/runs/{run_id}/jobs"], + listJobsForWorkflowRunAttempt: ["GET /repos/{owner}/{repo}/actions/runs/{run_id}/attempts/{attempt_number}/jobs"], + listLabelsForSelfHostedRunnerForOrg: ["GET /orgs/{org}/actions/runners/{runner_id}/labels"], + listLabelsForSelfHostedRunnerForRepo: ["GET /repos/{owner}/{repo}/actions/runners/{runner_id}/labels"], + listOrgSecrets: ["GET /orgs/{org}/actions/secrets"], + listOrgVariables: ["GET /orgs/{org}/actions/variables"], + listRepoRequiredWorkflows: ["GET /repos/{org}/{repo}/actions/required_workflows"], + listRepoSecrets: ["GET /repos/{owner}/{repo}/actions/secrets"], + listRepoVariables: ["GET /repos/{owner}/{repo}/actions/variables"], + listRepoWorkflows: ["GET /repos/{owner}/{repo}/actions/workflows"], + listRequiredWorkflowRuns: ["GET /repos/{owner}/{repo}/actions/required_workflows/{required_workflow_id_for_repo}/runs"], + listRequiredWorkflows: ["GET /orgs/{org}/actions/required_workflows"], + listRunnerApplicationsForOrg: ["GET /orgs/{org}/actions/runners/downloads"], + listRunnerApplicationsForRepo: ["GET /repos/{owner}/{repo}/actions/runners/downloads"], + listSelectedReposForOrgSecret: ["GET /orgs/{org}/actions/secrets/{secret_name}/repositories"], + listSelectedReposForOrgVariable: ["GET /orgs/{org}/actions/variables/{name}/repositories"], + listSelectedRepositoriesEnabledGithubActionsOrganization: ["GET /orgs/{org}/actions/permissions/repositories"], + listSelectedRepositoriesRequiredWorkflow: ["GET /orgs/{org}/actions/required_workflows/{required_workflow_id}/repositories"], + listSelfHostedRunnersForOrg: ["GET /orgs/{org}/actions/runners"], + listSelfHostedRunnersForRepo: ["GET /repos/{owner}/{repo}/actions/runners"], + listWorkflowRunArtifacts: ["GET /repos/{owner}/{repo}/actions/runs/{run_id}/artifacts"], + listWorkflowRuns: ["GET /repos/{owner}/{repo}/actions/workflows/{workflow_id}/runs"], + listWorkflowRunsForRepo: ["GET /repos/{owner}/{repo}/actions/runs"], + reRunJobForWorkflowRun: ["POST /repos/{owner}/{repo}/actions/jobs/{job_id}/rerun"], + reRunWorkflow: ["POST /repos/{owner}/{repo}/actions/runs/{run_id}/rerun"], + reRunWorkflowFailedJobs: ["POST /repos/{owner}/{repo}/actions/runs/{run_id}/rerun-failed-jobs"], + removeAllCustomLabelsFromSelfHostedRunnerForOrg: ["DELETE /orgs/{org}/actions/runners/{runner_id}/labels"], + removeAllCustomLabelsFromSelfHostedRunnerForRepo: ["DELETE /repos/{owner}/{repo}/actions/runners/{runner_id}/labels"], + removeCustomLabelFromSelfHostedRunnerForOrg: ["DELETE /orgs/{org}/actions/runners/{runner_id}/labels/{name}"], + removeCustomLabelFromSelfHostedRunnerForRepo: ["DELETE /repos/{owner}/{repo}/actions/runners/{runner_id}/labels/{name}"], + removeSelectedRepoFromOrgSecret: ["DELETE /orgs/{org}/actions/secrets/{secret_name}/repositories/{repository_id}"], + removeSelectedRepoFromOrgVariable: ["DELETE /orgs/{org}/actions/variables/{name}/repositories/{repository_id}"], + removeSelectedRepoFromRequiredWorkflow: ["DELETE /orgs/{org}/actions/required_workflows/{required_workflow_id}/repositories/{repository_id}"], + reviewPendingDeploymentsForRun: ["POST /repos/{owner}/{repo}/actions/runs/{run_id}/pending_deployments"], + setAllowedActionsOrganization: ["PUT /orgs/{org}/actions/permissions/selected-actions"], + setAllowedActionsRepository: ["PUT /repos/{owner}/{repo}/actions/permissions/selected-actions"], + setCustomLabelsForSelfHostedRunnerForOrg: ["PUT /orgs/{org}/actions/runners/{runner_id}/labels"], + setCustomLabelsForSelfHostedRunnerForRepo: ["PUT /repos/{owner}/{repo}/actions/runners/{runner_id}/labels"], + setGithubActionsDefaultWorkflowPermissionsOrganization: ["PUT /orgs/{org}/actions/permissions/workflow"], + setGithubActionsDefaultWorkflowPermissionsRepository: ["PUT /repos/{owner}/{repo}/actions/permissions/workflow"], + setGithubActionsPermissionsOrganization: ["PUT /orgs/{org}/actions/permissions"], + setGithubActionsPermissionsRepository: ["PUT /repos/{owner}/{repo}/actions/permissions"], + setSelectedReposForOrgSecret: ["PUT /orgs/{org}/actions/secrets/{secret_name}/repositories"], + setSelectedReposForOrgVariable: ["PUT /orgs/{org}/actions/variables/{name}/repositories"], + setSelectedReposToRequiredWorkflow: ["PUT /orgs/{org}/actions/required_workflows/{required_workflow_id}/repositories"], + setSelectedRepositoriesEnabledGithubActionsOrganization: ["PUT /orgs/{org}/actions/permissions/repositories"], + setWorkflowAccessToRepository: ["PUT /repos/{owner}/{repo}/actions/permissions/access"], + updateEnvironmentVariable: ["PATCH /repositories/{repository_id}/environments/{environment_name}/variables/{name}"], + updateOrgVariable: ["PATCH /orgs/{org}/actions/variables/{name}"], + updateRepoVariable: ["PATCH /repos/{owner}/{repo}/actions/variables/{name}"], + updateRequiredWorkflow: ["PATCH /orgs/{org}/actions/required_workflows/{required_workflow_id}"] + }, + activity: { + checkRepoIsStarredByAuthenticatedUser: ["GET /user/starred/{owner}/{repo}"], + deleteRepoSubscription: ["DELETE /repos/{owner}/{repo}/subscription"], + deleteThreadSubscription: ["DELETE /notifications/threads/{thread_id}/subscription"], + getFeeds: ["GET /feeds"], + getRepoSubscription: ["GET /repos/{owner}/{repo}/subscription"], + getThread: ["GET /notifications/threads/{thread_id}"], + getThreadSubscriptionForAuthenticatedUser: ["GET /notifications/threads/{thread_id}/subscription"], + listEventsForAuthenticatedUser: ["GET /users/{username}/events"], + listNotificationsForAuthenticatedUser: ["GET /notifications"], + listOrgEventsForAuthenticatedUser: ["GET /users/{username}/events/orgs/{org}"], + listPublicEvents: ["GET /events"], + listPublicEventsForRepoNetwork: ["GET /networks/{owner}/{repo}/events"], + listPublicEventsForUser: ["GET /users/{username}/events/public"], + listPublicOrgEvents: ["GET /orgs/{org}/events"], + listReceivedEventsForUser: ["GET /users/{username}/received_events"], + listReceivedPublicEventsForUser: ["GET /users/{username}/received_events/public"], + listRepoEvents: ["GET /repos/{owner}/{repo}/events"], + listRepoNotificationsForAuthenticatedUser: ["GET /repos/{owner}/{repo}/notifications"], + listReposStarredByAuthenticatedUser: ["GET /user/starred"], + listReposStarredByUser: ["GET /users/{username}/starred"], + listReposWatchedByUser: ["GET /users/{username}/subscriptions"], + listStargazersForRepo: ["GET /repos/{owner}/{repo}/stargazers"], + listWatchedReposForAuthenticatedUser: ["GET /user/subscriptions"], + listWatchersForRepo: ["GET /repos/{owner}/{repo}/subscribers"], + markNotificationsAsRead: ["PUT /notifications"], + markRepoNotificationsAsRead: ["PUT /repos/{owner}/{repo}/notifications"], + markThreadAsRead: ["PATCH /notifications/threads/{thread_id}"], + setRepoSubscription: ["PUT /repos/{owner}/{repo}/subscription"], + setThreadSubscription: ["PUT /notifications/threads/{thread_id}/subscription"], + starRepoForAuthenticatedUser: ["PUT /user/starred/{owner}/{repo}"], + unstarRepoForAuthenticatedUser: ["DELETE /user/starred/{owner}/{repo}"] + }, + apps: { + addRepoToInstallation: ["PUT /user/installations/{installation_id}/repositories/{repository_id}", {}, { + renamed: ["apps", "addRepoToInstallationForAuthenticatedUser"] + }], + addRepoToInstallationForAuthenticatedUser: ["PUT /user/installations/{installation_id}/repositories/{repository_id}"], + checkToken: ["POST /applications/{client_id}/token"], + createFromManifest: ["POST /app-manifests/{code}/conversions"], + createInstallationAccessToken: ["POST /app/installations/{installation_id}/access_tokens"], + deleteAuthorization: ["DELETE /applications/{client_id}/grant"], + deleteInstallation: ["DELETE /app/installations/{installation_id}"], + deleteToken: ["DELETE /applications/{client_id}/token"], + getAuthenticated: ["GET /app"], + getBySlug: ["GET /apps/{app_slug}"], + getInstallation: ["GET /app/installations/{installation_id}"], + getOrgInstallation: ["GET /orgs/{org}/installation"], + getRepoInstallation: ["GET /repos/{owner}/{repo}/installation"], + getSubscriptionPlanForAccount: ["GET /marketplace_listing/accounts/{account_id}"], + getSubscriptionPlanForAccountStubbed: ["GET /marketplace_listing/stubbed/accounts/{account_id}"], + getUserInstallation: ["GET /users/{username}/installation"], + getWebhookConfigForApp: ["GET /app/hook/config"], + getWebhookDelivery: ["GET /app/hook/deliveries/{delivery_id}"], + listAccountsForPlan: ["GET /marketplace_listing/plans/{plan_id}/accounts"], + listAccountsForPlanStubbed: ["GET /marketplace_listing/stubbed/plans/{plan_id}/accounts"], + listInstallationReposForAuthenticatedUser: ["GET /user/installations/{installation_id}/repositories"], + listInstallations: ["GET /app/installations"], + listInstallationsForAuthenticatedUser: ["GET /user/installations"], + listPlans: ["GET /marketplace_listing/plans"], + listPlansStubbed: ["GET /marketplace_listing/stubbed/plans"], + listReposAccessibleToInstallation: ["GET /installation/repositories"], + listSubscriptionsForAuthenticatedUser: ["GET /user/marketplace_purchases"], + listSubscriptionsForAuthenticatedUserStubbed: ["GET /user/marketplace_purchases/stubbed"], + listWebhookDeliveries: ["GET /app/hook/deliveries"], + redeliverWebhookDelivery: ["POST /app/hook/deliveries/{delivery_id}/attempts"], + removeRepoFromInstallation: ["DELETE /user/installations/{installation_id}/repositories/{repository_id}", {}, { + renamed: ["apps", "removeRepoFromInstallationForAuthenticatedUser"] + }], + removeRepoFromInstallationForAuthenticatedUser: ["DELETE /user/installations/{installation_id}/repositories/{repository_id}"], + resetToken: ["PATCH /applications/{client_id}/token"], + revokeInstallationAccessToken: ["DELETE /installation/token"], + scopeToken: ["POST /applications/{client_id}/token/scoped"], + suspendInstallation: ["PUT /app/installations/{installation_id}/suspended"], + unsuspendInstallation: ["DELETE /app/installations/{installation_id}/suspended"], + updateWebhookConfigForApp: ["PATCH /app/hook/config"] + }, + billing: { + getGithubActionsBillingOrg: ["GET /orgs/{org}/settings/billing/actions"], + getGithubActionsBillingUser: ["GET /users/{username}/settings/billing/actions"], + getGithubPackagesBillingOrg: ["GET /orgs/{org}/settings/billing/packages"], + getGithubPackagesBillingUser: ["GET /users/{username}/settings/billing/packages"], + getSharedStorageBillingOrg: ["GET /orgs/{org}/settings/billing/shared-storage"], + getSharedStorageBillingUser: ["GET /users/{username}/settings/billing/shared-storage"] + }, + checks: { + create: ["POST /repos/{owner}/{repo}/check-runs"], + createSuite: ["POST /repos/{owner}/{repo}/check-suites"], + get: ["GET /repos/{owner}/{repo}/check-runs/{check_run_id}"], + getSuite: ["GET /repos/{owner}/{repo}/check-suites/{check_suite_id}"], + listAnnotations: ["GET /repos/{owner}/{repo}/check-runs/{check_run_id}/annotations"], + listForRef: ["GET /repos/{owner}/{repo}/commits/{ref}/check-runs"], + listForSuite: ["GET /repos/{owner}/{repo}/check-suites/{check_suite_id}/check-runs"], + listSuitesForRef: ["GET /repos/{owner}/{repo}/commits/{ref}/check-suites"], + rerequestRun: ["POST /repos/{owner}/{repo}/check-runs/{check_run_id}/rerequest"], + rerequestSuite: ["POST /repos/{owner}/{repo}/check-suites/{check_suite_id}/rerequest"], + setSuitesPreferences: ["PATCH /repos/{owner}/{repo}/check-suites/preferences"], + update: ["PATCH /repos/{owner}/{repo}/check-runs/{check_run_id}"] + }, + codeScanning: { + deleteAnalysis: ["DELETE /repos/{owner}/{repo}/code-scanning/analyses/{analysis_id}{?confirm_delete}"], + getAlert: ["GET /repos/{owner}/{repo}/code-scanning/alerts/{alert_number}", {}, { + renamedParameters: { + alert_id: "alert_number" + } + }], + getAnalysis: ["GET /repos/{owner}/{repo}/code-scanning/analyses/{analysis_id}"], + getCodeqlDatabase: ["GET /repos/{owner}/{repo}/code-scanning/codeql/databases/{language}"], + getSarif: ["GET /repos/{owner}/{repo}/code-scanning/sarifs/{sarif_id}"], + listAlertInstances: ["GET /repos/{owner}/{repo}/code-scanning/alerts/{alert_number}/instances"], + listAlertsForOrg: ["GET /orgs/{org}/code-scanning/alerts"], + listAlertsForRepo: ["GET /repos/{owner}/{repo}/code-scanning/alerts"], + listAlertsInstances: ["GET /repos/{owner}/{repo}/code-scanning/alerts/{alert_number}/instances", {}, { + renamed: ["codeScanning", "listAlertInstances"] + }], + listCodeqlDatabases: ["GET /repos/{owner}/{repo}/code-scanning/codeql/databases"], + listRecentAnalyses: ["GET /repos/{owner}/{repo}/code-scanning/analyses"], + updateAlert: ["PATCH /repos/{owner}/{repo}/code-scanning/alerts/{alert_number}"], + uploadSarif: ["POST /repos/{owner}/{repo}/code-scanning/sarifs"] + }, + codesOfConduct: { + getAllCodesOfConduct: ["GET /codes_of_conduct"], + getConductCode: ["GET /codes_of_conduct/{key}"] + }, + codespaces: { + addRepositoryForSecretForAuthenticatedUser: ["PUT /user/codespaces/secrets/{secret_name}/repositories/{repository_id}"], + addSelectedRepoToOrgSecret: ["PUT /orgs/{org}/codespaces/secrets/{secret_name}/repositories/{repository_id}"], + codespaceMachinesForAuthenticatedUser: ["GET /user/codespaces/{codespace_name}/machines"], + createForAuthenticatedUser: ["POST /user/codespaces"], + createOrUpdateOrgSecret: ["PUT /orgs/{org}/codespaces/secrets/{secret_name}"], + createOrUpdateRepoSecret: ["PUT /repos/{owner}/{repo}/codespaces/secrets/{secret_name}"], + createOrUpdateSecretForAuthenticatedUser: ["PUT /user/codespaces/secrets/{secret_name}"], + createWithPrForAuthenticatedUser: ["POST /repos/{owner}/{repo}/pulls/{pull_number}/codespaces"], + createWithRepoForAuthenticatedUser: ["POST /repos/{owner}/{repo}/codespaces"], + deleteForAuthenticatedUser: ["DELETE /user/codespaces/{codespace_name}"], + deleteFromOrganization: ["DELETE /orgs/{org}/members/{username}/codespaces/{codespace_name}"], + deleteOrgSecret: ["DELETE /orgs/{org}/codespaces/secrets/{secret_name}"], + deleteRepoSecret: ["DELETE /repos/{owner}/{repo}/codespaces/secrets/{secret_name}"], + deleteSecretForAuthenticatedUser: ["DELETE /user/codespaces/secrets/{secret_name}"], + exportForAuthenticatedUser: ["POST /user/codespaces/{codespace_name}/exports"], + getCodespacesForUserInOrg: ["GET /orgs/{org}/members/{username}/codespaces"], + getExportDetailsForAuthenticatedUser: ["GET /user/codespaces/{codespace_name}/exports/{export_id}"], + getForAuthenticatedUser: ["GET /user/codespaces/{codespace_name}"], + getOrgPublicKey: ["GET /orgs/{org}/codespaces/secrets/public-key"], + getOrgSecret: ["GET /orgs/{org}/codespaces/secrets/{secret_name}"], + getPublicKeyForAuthenticatedUser: ["GET /user/codespaces/secrets/public-key"], + getRepoPublicKey: ["GET /repos/{owner}/{repo}/codespaces/secrets/public-key"], + getRepoSecret: ["GET /repos/{owner}/{repo}/codespaces/secrets/{secret_name}"], + getSecretForAuthenticatedUser: ["GET /user/codespaces/secrets/{secret_name}"], + listDevcontainersInRepositoryForAuthenticatedUser: ["GET /repos/{owner}/{repo}/codespaces/devcontainers"], + listForAuthenticatedUser: ["GET /user/codespaces"], + listInOrganization: ["GET /orgs/{org}/codespaces", {}, { + renamedParameters: { + org_id: "org" + } + }], + listInRepositoryForAuthenticatedUser: ["GET /repos/{owner}/{repo}/codespaces"], + listOrgSecrets: ["GET /orgs/{org}/codespaces/secrets"], + listRepoSecrets: ["GET /repos/{owner}/{repo}/codespaces/secrets"], + listRepositoriesForSecretForAuthenticatedUser: ["GET /user/codespaces/secrets/{secret_name}/repositories"], + listSecretsForAuthenticatedUser: ["GET /user/codespaces/secrets"], + listSelectedReposForOrgSecret: ["GET /orgs/{org}/codespaces/secrets/{secret_name}/repositories"], + preFlightWithRepoForAuthenticatedUser: ["GET /repos/{owner}/{repo}/codespaces/new"], + publishForAuthenticatedUser: ["POST /user/codespaces/{codespace_name}/publish"], + removeRepositoryForSecretForAuthenticatedUser: ["DELETE /user/codespaces/secrets/{secret_name}/repositories/{repository_id}"], + removeSelectedRepoFromOrgSecret: ["DELETE /orgs/{org}/codespaces/secrets/{secret_name}/repositories/{repository_id}"], + repoMachinesForAuthenticatedUser: ["GET /repos/{owner}/{repo}/codespaces/machines"], + setCodespacesBilling: ["PUT /orgs/{org}/codespaces/billing"], + setRepositoriesForSecretForAuthenticatedUser: ["PUT /user/codespaces/secrets/{secret_name}/repositories"], + setSelectedReposForOrgSecret: ["PUT /orgs/{org}/codespaces/secrets/{secret_name}/repositories"], + startForAuthenticatedUser: ["POST /user/codespaces/{codespace_name}/start"], + stopForAuthenticatedUser: ["POST /user/codespaces/{codespace_name}/stop"], + stopInOrganization: ["POST /orgs/{org}/members/{username}/codespaces/{codespace_name}/stop"], + updateForAuthenticatedUser: ["PATCH /user/codespaces/{codespace_name}"] + }, + dependabot: { + addSelectedRepoToOrgSecret: ["PUT /orgs/{org}/dependabot/secrets/{secret_name}/repositories/{repository_id}"], + createOrUpdateOrgSecret: ["PUT /orgs/{org}/dependabot/secrets/{secret_name}"], + createOrUpdateRepoSecret: ["PUT /repos/{owner}/{repo}/dependabot/secrets/{secret_name}"], + deleteOrgSecret: ["DELETE /orgs/{org}/dependabot/secrets/{secret_name}"], + deleteRepoSecret: ["DELETE /repos/{owner}/{repo}/dependabot/secrets/{secret_name}"], + getAlert: ["GET /repos/{owner}/{repo}/dependabot/alerts/{alert_number}"], + getOrgPublicKey: ["GET /orgs/{org}/dependabot/secrets/public-key"], + getOrgSecret: ["GET /orgs/{org}/dependabot/secrets/{secret_name}"], + getRepoPublicKey: ["GET /repos/{owner}/{repo}/dependabot/secrets/public-key"], + getRepoSecret: ["GET /repos/{owner}/{repo}/dependabot/secrets/{secret_name}"], + listAlertsForEnterprise: ["GET /enterprises/{enterprise}/dependabot/alerts"], + listAlertsForOrg: ["GET /orgs/{org}/dependabot/alerts"], + listAlertsForRepo: ["GET /repos/{owner}/{repo}/dependabot/alerts"], + listOrgSecrets: ["GET /orgs/{org}/dependabot/secrets"], + listRepoSecrets: ["GET /repos/{owner}/{repo}/dependabot/secrets"], + listSelectedReposForOrgSecret: ["GET /orgs/{org}/dependabot/secrets/{secret_name}/repositories"], + removeSelectedRepoFromOrgSecret: ["DELETE /orgs/{org}/dependabot/secrets/{secret_name}/repositories/{repository_id}"], + setSelectedReposForOrgSecret: ["PUT /orgs/{org}/dependabot/secrets/{secret_name}/repositories"], + updateAlert: ["PATCH /repos/{owner}/{repo}/dependabot/alerts/{alert_number}"] + }, + dependencyGraph: { + createRepositorySnapshot: ["POST /repos/{owner}/{repo}/dependency-graph/snapshots"], + diffRange: ["GET /repos/{owner}/{repo}/dependency-graph/compare/{basehead}"] + }, + emojis: { + get: ["GET /emojis"] + }, + enterpriseAdmin: { + addCustomLabelsToSelfHostedRunnerForEnterprise: ["POST /enterprises/{enterprise}/actions/runners/{runner_id}/labels"], + enableSelectedOrganizationGithubActionsEnterprise: ["PUT /enterprises/{enterprise}/actions/permissions/organizations/{org_id}"], + listLabelsForSelfHostedRunnerForEnterprise: ["GET /enterprises/{enterprise}/actions/runners/{runner_id}/labels"] + }, + gists: { + checkIsStarred: ["GET /gists/{gist_id}/star"], + create: ["POST /gists"], + createComment: ["POST /gists/{gist_id}/comments"], + delete: ["DELETE /gists/{gist_id}"], + deleteComment: ["DELETE /gists/{gist_id}/comments/{comment_id}"], + fork: ["POST /gists/{gist_id}/forks"], + get: ["GET /gists/{gist_id}"], + getComment: ["GET /gists/{gist_id}/comments/{comment_id}"], + getRevision: ["GET /gists/{gist_id}/{sha}"], + list: ["GET /gists"], + listComments: ["GET /gists/{gist_id}/comments"], + listCommits: ["GET /gists/{gist_id}/commits"], + listForUser: ["GET /users/{username}/gists"], + listForks: ["GET /gists/{gist_id}/forks"], + listPublic: ["GET /gists/public"], + listStarred: ["GET /gists/starred"], + star: ["PUT /gists/{gist_id}/star"], + unstar: ["DELETE /gists/{gist_id}/star"], + update: ["PATCH /gists/{gist_id}"], + updateComment: ["PATCH /gists/{gist_id}/comments/{comment_id}"] + }, + git: { + createBlob: ["POST /repos/{owner}/{repo}/git/blobs"], + createCommit: ["POST /repos/{owner}/{repo}/git/commits"], + createRef: ["POST /repos/{owner}/{repo}/git/refs"], + createTag: ["POST /repos/{owner}/{repo}/git/tags"], + createTree: ["POST /repos/{owner}/{repo}/git/trees"], + deleteRef: ["DELETE /repos/{owner}/{repo}/git/refs/{ref}"], + getBlob: ["GET /repos/{owner}/{repo}/git/blobs/{file_sha}"], + getCommit: ["GET /repos/{owner}/{repo}/git/commits/{commit_sha}"], + getRef: ["GET /repos/{owner}/{repo}/git/ref/{ref}"], + getTag: ["GET /repos/{owner}/{repo}/git/tags/{tag_sha}"], + getTree: ["GET /repos/{owner}/{repo}/git/trees/{tree_sha}"], + listMatchingRefs: ["GET /repos/{owner}/{repo}/git/matching-refs/{ref}"], + updateRef: ["PATCH /repos/{owner}/{repo}/git/refs/{ref}"] + }, + gitignore: { + getAllTemplates: ["GET /gitignore/templates"], + getTemplate: ["GET /gitignore/templates/{name}"] + }, + interactions: { + getRestrictionsForAuthenticatedUser: ["GET /user/interaction-limits"], + getRestrictionsForOrg: ["GET /orgs/{org}/interaction-limits"], + getRestrictionsForRepo: ["GET /repos/{owner}/{repo}/interaction-limits"], + getRestrictionsForYourPublicRepos: ["GET /user/interaction-limits", {}, { + renamed: ["interactions", "getRestrictionsForAuthenticatedUser"] + }], + removeRestrictionsForAuthenticatedUser: ["DELETE /user/interaction-limits"], + removeRestrictionsForOrg: ["DELETE /orgs/{org}/interaction-limits"], + removeRestrictionsForRepo: ["DELETE /repos/{owner}/{repo}/interaction-limits"], + removeRestrictionsForYourPublicRepos: ["DELETE /user/interaction-limits", {}, { + renamed: ["interactions", "removeRestrictionsForAuthenticatedUser"] + }], + setRestrictionsForAuthenticatedUser: ["PUT /user/interaction-limits"], + setRestrictionsForOrg: ["PUT /orgs/{org}/interaction-limits"], + setRestrictionsForRepo: ["PUT /repos/{owner}/{repo}/interaction-limits"], + setRestrictionsForYourPublicRepos: ["PUT /user/interaction-limits", {}, { + renamed: ["interactions", "setRestrictionsForAuthenticatedUser"] + }] + }, + issues: { + addAssignees: ["POST /repos/{owner}/{repo}/issues/{issue_number}/assignees"], + addLabels: ["POST /repos/{owner}/{repo}/issues/{issue_number}/labels"], + checkUserCanBeAssigned: ["GET /repos/{owner}/{repo}/assignees/{assignee}"], + checkUserCanBeAssignedToIssue: ["GET /repos/{owner}/{repo}/issues/{issue_number}/assignees/{assignee}"], + create: ["POST /repos/{owner}/{repo}/issues"], + createComment: ["POST /repos/{owner}/{repo}/issues/{issue_number}/comments"], + createLabel: ["POST /repos/{owner}/{repo}/labels"], + createMilestone: ["POST /repos/{owner}/{repo}/milestones"], + deleteComment: ["DELETE /repos/{owner}/{repo}/issues/comments/{comment_id}"], + deleteLabel: ["DELETE /repos/{owner}/{repo}/labels/{name}"], + deleteMilestone: ["DELETE /repos/{owner}/{repo}/milestones/{milestone_number}"], + get: ["GET /repos/{owner}/{repo}/issues/{issue_number}"], + getComment: ["GET /repos/{owner}/{repo}/issues/comments/{comment_id}"], + getEvent: ["GET /repos/{owner}/{repo}/issues/events/{event_id}"], + getLabel: ["GET /repos/{owner}/{repo}/labels/{name}"], + getMilestone: ["GET /repos/{owner}/{repo}/milestones/{milestone_number}"], + list: ["GET /issues"], + listAssignees: ["GET /repos/{owner}/{repo}/assignees"], + listComments: ["GET /repos/{owner}/{repo}/issues/{issue_number}/comments"], + listCommentsForRepo: ["GET /repos/{owner}/{repo}/issues/comments"], + listEvents: ["GET /repos/{owner}/{repo}/issues/{issue_number}/events"], + listEventsForRepo: ["GET /repos/{owner}/{repo}/issues/events"], + listEventsForTimeline: ["GET /repos/{owner}/{repo}/issues/{issue_number}/timeline"], + listForAuthenticatedUser: ["GET /user/issues"], + listForOrg: ["GET /orgs/{org}/issues"], + listForRepo: ["GET /repos/{owner}/{repo}/issues"], + listLabelsForMilestone: ["GET /repos/{owner}/{repo}/milestones/{milestone_number}/labels"], + listLabelsForRepo: ["GET /repos/{owner}/{repo}/labels"], + listLabelsOnIssue: ["GET /repos/{owner}/{repo}/issues/{issue_number}/labels"], + listMilestones: ["GET /repos/{owner}/{repo}/milestones"], + lock: ["PUT /repos/{owner}/{repo}/issues/{issue_number}/lock"], + removeAllLabels: ["DELETE /repos/{owner}/{repo}/issues/{issue_number}/labels"], + removeAssignees: ["DELETE /repos/{owner}/{repo}/issues/{issue_number}/assignees"], + removeLabel: ["DELETE /repos/{owner}/{repo}/issues/{issue_number}/labels/{name}"], + setLabels: ["PUT /repos/{owner}/{repo}/issues/{issue_number}/labels"], + unlock: ["DELETE /repos/{owner}/{repo}/issues/{issue_number}/lock"], + update: ["PATCH /repos/{owner}/{repo}/issues/{issue_number}"], + updateComment: ["PATCH /repos/{owner}/{repo}/issues/comments/{comment_id}"], + updateLabel: ["PATCH /repos/{owner}/{repo}/labels/{name}"], + updateMilestone: ["PATCH /repos/{owner}/{repo}/milestones/{milestone_number}"] + }, + licenses: { + get: ["GET /licenses/{license}"], + getAllCommonlyUsed: ["GET /licenses"], + getForRepo: ["GET /repos/{owner}/{repo}/license"] + }, + markdown: { + render: ["POST /markdown"], + renderRaw: ["POST /markdown/raw", { + headers: { + "content-type": "text/plain; charset=utf-8" + } + }] + }, + meta: { + get: ["GET /meta"], + getAllVersions: ["GET /versions"], + getOctocat: ["GET /octocat"], + getZen: ["GET /zen"], + root: ["GET /"] + }, + migrations: { + cancelImport: ["DELETE /repos/{owner}/{repo}/import"], + deleteArchiveForAuthenticatedUser: ["DELETE /user/migrations/{migration_id}/archive"], + deleteArchiveForOrg: ["DELETE /orgs/{org}/migrations/{migration_id}/archive"], + downloadArchiveForOrg: ["GET /orgs/{org}/migrations/{migration_id}/archive"], + getArchiveForAuthenticatedUser: ["GET /user/migrations/{migration_id}/archive"], + getCommitAuthors: ["GET /repos/{owner}/{repo}/import/authors"], + getImportStatus: ["GET /repos/{owner}/{repo}/import"], + getLargeFiles: ["GET /repos/{owner}/{repo}/import/large_files"], + getStatusForAuthenticatedUser: ["GET /user/migrations/{migration_id}"], + getStatusForOrg: ["GET /orgs/{org}/migrations/{migration_id}"], + listForAuthenticatedUser: ["GET /user/migrations"], + listForOrg: ["GET /orgs/{org}/migrations"], + listReposForAuthenticatedUser: ["GET /user/migrations/{migration_id}/repositories"], + listReposForOrg: ["GET /orgs/{org}/migrations/{migration_id}/repositories"], + listReposForUser: ["GET /user/migrations/{migration_id}/repositories", {}, { + renamed: ["migrations", "listReposForAuthenticatedUser"] + }], + mapCommitAuthor: ["PATCH /repos/{owner}/{repo}/import/authors/{author_id}"], + setLfsPreference: ["PATCH /repos/{owner}/{repo}/import/lfs"], + startForAuthenticatedUser: ["POST /user/migrations"], + startForOrg: ["POST /orgs/{org}/migrations"], + startImport: ["PUT /repos/{owner}/{repo}/import"], + unlockRepoForAuthenticatedUser: ["DELETE /user/migrations/{migration_id}/repos/{repo_name}/lock"], + unlockRepoForOrg: ["DELETE /orgs/{org}/migrations/{migration_id}/repos/{repo_name}/lock"], + updateImport: ["PATCH /repos/{owner}/{repo}/import"] + }, + orgs: { + addSecurityManagerTeam: ["PUT /orgs/{org}/security-managers/teams/{team_slug}"], + blockUser: ["PUT /orgs/{org}/blocks/{username}"], + cancelInvitation: ["DELETE /orgs/{org}/invitations/{invitation_id}"], + checkBlockedUser: ["GET /orgs/{org}/blocks/{username}"], + checkMembershipForUser: ["GET /orgs/{org}/members/{username}"], + checkPublicMembershipForUser: ["GET /orgs/{org}/public_members/{username}"], + convertMemberToOutsideCollaborator: ["PUT /orgs/{org}/outside_collaborators/{username}"], + createInvitation: ["POST /orgs/{org}/invitations"], + createWebhook: ["POST /orgs/{org}/hooks"], + deleteWebhook: ["DELETE /orgs/{org}/hooks/{hook_id}"], + enableOrDisableSecurityProductOnAllOrgRepos: ["POST /orgs/{org}/{security_product}/{enablement}"], + get: ["GET /orgs/{org}"], + getMembershipForAuthenticatedUser: ["GET /user/memberships/orgs/{org}"], + getMembershipForUser: ["GET /orgs/{org}/memberships/{username}"], + getWebhook: ["GET /orgs/{org}/hooks/{hook_id}"], + getWebhookConfigForOrg: ["GET /orgs/{org}/hooks/{hook_id}/config"], + getWebhookDelivery: ["GET /orgs/{org}/hooks/{hook_id}/deliveries/{delivery_id}"], + list: ["GET /organizations"], + listAppInstallations: ["GET /orgs/{org}/installations"], + listBlockedUsers: ["GET /orgs/{org}/blocks"], + listFailedInvitations: ["GET /orgs/{org}/failed_invitations"], + listForAuthenticatedUser: ["GET /user/orgs"], + listForUser: ["GET /users/{username}/orgs"], + listInvitationTeams: ["GET /orgs/{org}/invitations/{invitation_id}/teams"], + listMembers: ["GET /orgs/{org}/members"], + listMembershipsForAuthenticatedUser: ["GET /user/memberships/orgs"], + listOutsideCollaborators: ["GET /orgs/{org}/outside_collaborators"], + listPendingInvitations: ["GET /orgs/{org}/invitations"], + listPublicMembers: ["GET /orgs/{org}/public_members"], + listSecurityManagerTeams: ["GET /orgs/{org}/security-managers"], + listWebhookDeliveries: ["GET /orgs/{org}/hooks/{hook_id}/deliveries"], + listWebhooks: ["GET /orgs/{org}/hooks"], + pingWebhook: ["POST /orgs/{org}/hooks/{hook_id}/pings"], + redeliverWebhookDelivery: ["POST /orgs/{org}/hooks/{hook_id}/deliveries/{delivery_id}/attempts"], + removeMember: ["DELETE /orgs/{org}/members/{username}"], + removeMembershipForUser: ["DELETE /orgs/{org}/memberships/{username}"], + removeOutsideCollaborator: ["DELETE /orgs/{org}/outside_collaborators/{username}"], + removePublicMembershipForAuthenticatedUser: ["DELETE /orgs/{org}/public_members/{username}"], + removeSecurityManagerTeam: ["DELETE /orgs/{org}/security-managers/teams/{team_slug}"], + setMembershipForUser: ["PUT /orgs/{org}/memberships/{username}"], + setPublicMembershipForAuthenticatedUser: ["PUT /orgs/{org}/public_members/{username}"], + unblockUser: ["DELETE /orgs/{org}/blocks/{username}"], + update: ["PATCH /orgs/{org}"], + updateMembershipForAuthenticatedUser: ["PATCH /user/memberships/orgs/{org}"], + updateWebhook: ["PATCH /orgs/{org}/hooks/{hook_id}"], + updateWebhookConfigForOrg: ["PATCH /orgs/{org}/hooks/{hook_id}/config"] + }, + packages: { + deletePackageForAuthenticatedUser: ["DELETE /user/packages/{package_type}/{package_name}"], + deletePackageForOrg: ["DELETE /orgs/{org}/packages/{package_type}/{package_name}"], + deletePackageForUser: ["DELETE /users/{username}/packages/{package_type}/{package_name}"], + deletePackageVersionForAuthenticatedUser: ["DELETE /user/packages/{package_type}/{package_name}/versions/{package_version_id}"], + deletePackageVersionForOrg: ["DELETE /orgs/{org}/packages/{package_type}/{package_name}/versions/{package_version_id}"], + deletePackageVersionForUser: ["DELETE /users/{username}/packages/{package_type}/{package_name}/versions/{package_version_id}"], + getAllPackageVersionsForAPackageOwnedByAnOrg: ["GET /orgs/{org}/packages/{package_type}/{package_name}/versions", {}, { + renamed: ["packages", "getAllPackageVersionsForPackageOwnedByOrg"] + }], + getAllPackageVersionsForAPackageOwnedByTheAuthenticatedUser: ["GET /user/packages/{package_type}/{package_name}/versions", {}, { + renamed: ["packages", "getAllPackageVersionsForPackageOwnedByAuthenticatedUser"] + }], + getAllPackageVersionsForPackageOwnedByAuthenticatedUser: ["GET /user/packages/{package_type}/{package_name}/versions"], + getAllPackageVersionsForPackageOwnedByOrg: ["GET /orgs/{org}/packages/{package_type}/{package_name}/versions"], + getAllPackageVersionsForPackageOwnedByUser: ["GET /users/{username}/packages/{package_type}/{package_name}/versions"], + getPackageForAuthenticatedUser: ["GET /user/packages/{package_type}/{package_name}"], + getPackageForOrganization: ["GET /orgs/{org}/packages/{package_type}/{package_name}"], + getPackageForUser: ["GET /users/{username}/packages/{package_type}/{package_name}"], + getPackageVersionForAuthenticatedUser: ["GET /user/packages/{package_type}/{package_name}/versions/{package_version_id}"], + getPackageVersionForOrganization: ["GET /orgs/{org}/packages/{package_type}/{package_name}/versions/{package_version_id}"], + getPackageVersionForUser: ["GET /users/{username}/packages/{package_type}/{package_name}/versions/{package_version_id}"], + listPackagesForAuthenticatedUser: ["GET /user/packages"], + listPackagesForOrganization: ["GET /orgs/{org}/packages"], + listPackagesForUser: ["GET /users/{username}/packages"], + restorePackageForAuthenticatedUser: ["POST /user/packages/{package_type}/{package_name}/restore{?token}"], + restorePackageForOrg: ["POST /orgs/{org}/packages/{package_type}/{package_name}/restore{?token}"], + restorePackageForUser: ["POST /users/{username}/packages/{package_type}/{package_name}/restore{?token}"], + restorePackageVersionForAuthenticatedUser: ["POST /user/packages/{package_type}/{package_name}/versions/{package_version_id}/restore"], + restorePackageVersionForOrg: ["POST /orgs/{org}/packages/{package_type}/{package_name}/versions/{package_version_id}/restore"], + restorePackageVersionForUser: ["POST /users/{username}/packages/{package_type}/{package_name}/versions/{package_version_id}/restore"] + }, + projects: { + addCollaborator: ["PUT /projects/{project_id}/collaborators/{username}"], + createCard: ["POST /projects/columns/{column_id}/cards"], + createColumn: ["POST /projects/{project_id}/columns"], + createForAuthenticatedUser: ["POST /user/projects"], + createForOrg: ["POST /orgs/{org}/projects"], + createForRepo: ["POST /repos/{owner}/{repo}/projects"], + delete: ["DELETE /projects/{project_id}"], + deleteCard: ["DELETE /projects/columns/cards/{card_id}"], + deleteColumn: ["DELETE /projects/columns/{column_id}"], + get: ["GET /projects/{project_id}"], + getCard: ["GET /projects/columns/cards/{card_id}"], + getColumn: ["GET /projects/columns/{column_id}"], + getPermissionForUser: ["GET /projects/{project_id}/collaborators/{username}/permission"], + listCards: ["GET /projects/columns/{column_id}/cards"], + listCollaborators: ["GET /projects/{project_id}/collaborators"], + listColumns: ["GET /projects/{project_id}/columns"], + listForOrg: ["GET /orgs/{org}/projects"], + listForRepo: ["GET /repos/{owner}/{repo}/projects"], + listForUser: ["GET /users/{username}/projects"], + moveCard: ["POST /projects/columns/cards/{card_id}/moves"], + moveColumn: ["POST /projects/columns/{column_id}/moves"], + removeCollaborator: ["DELETE /projects/{project_id}/collaborators/{username}"], + update: ["PATCH /projects/{project_id}"], + updateCard: ["PATCH /projects/columns/cards/{card_id}"], + updateColumn: ["PATCH /projects/columns/{column_id}"] + }, + pulls: { + checkIfMerged: ["GET /repos/{owner}/{repo}/pulls/{pull_number}/merge"], + create: ["POST /repos/{owner}/{repo}/pulls"], + createReplyForReviewComment: ["POST /repos/{owner}/{repo}/pulls/{pull_number}/comments/{comment_id}/replies"], + createReview: ["POST /repos/{owner}/{repo}/pulls/{pull_number}/reviews"], + createReviewComment: ["POST /repos/{owner}/{repo}/pulls/{pull_number}/comments"], + deletePendingReview: ["DELETE /repos/{owner}/{repo}/pulls/{pull_number}/reviews/{review_id}"], + deleteReviewComment: ["DELETE /repos/{owner}/{repo}/pulls/comments/{comment_id}"], + dismissReview: ["PUT /repos/{owner}/{repo}/pulls/{pull_number}/reviews/{review_id}/dismissals"], + get: ["GET /repos/{owner}/{repo}/pulls/{pull_number}"], + getReview: ["GET /repos/{owner}/{repo}/pulls/{pull_number}/reviews/{review_id}"], + getReviewComment: ["GET /repos/{owner}/{repo}/pulls/comments/{comment_id}"], + list: ["GET /repos/{owner}/{repo}/pulls"], + listCommentsForReview: ["GET /repos/{owner}/{repo}/pulls/{pull_number}/reviews/{review_id}/comments"], + listCommits: ["GET /repos/{owner}/{repo}/pulls/{pull_number}/commits"], + listFiles: ["GET /repos/{owner}/{repo}/pulls/{pull_number}/files"], + listRequestedReviewers: ["GET /repos/{owner}/{repo}/pulls/{pull_number}/requested_reviewers"], + listReviewComments: ["GET /repos/{owner}/{repo}/pulls/{pull_number}/comments"], + listReviewCommentsForRepo: ["GET /repos/{owner}/{repo}/pulls/comments"], + listReviews: ["GET /repos/{owner}/{repo}/pulls/{pull_number}/reviews"], + merge: ["PUT /repos/{owner}/{repo}/pulls/{pull_number}/merge"], + removeRequestedReviewers: ["DELETE /repos/{owner}/{repo}/pulls/{pull_number}/requested_reviewers"], + requestReviewers: ["POST /repos/{owner}/{repo}/pulls/{pull_number}/requested_reviewers"], + submitReview: ["POST /repos/{owner}/{repo}/pulls/{pull_number}/reviews/{review_id}/events"], + update: ["PATCH /repos/{owner}/{repo}/pulls/{pull_number}"], + updateBranch: ["PUT /repos/{owner}/{repo}/pulls/{pull_number}/update-branch"], + updateReview: ["PUT /repos/{owner}/{repo}/pulls/{pull_number}/reviews/{review_id}"], + updateReviewComment: ["PATCH /repos/{owner}/{repo}/pulls/comments/{comment_id}"] + }, + rateLimit: { + get: ["GET /rate_limit"] + }, + reactions: { + createForCommitComment: ["POST /repos/{owner}/{repo}/comments/{comment_id}/reactions"], + createForIssue: ["POST /repos/{owner}/{repo}/issues/{issue_number}/reactions"], + createForIssueComment: ["POST /repos/{owner}/{repo}/issues/comments/{comment_id}/reactions"], + createForPullRequestReviewComment: ["POST /repos/{owner}/{repo}/pulls/comments/{comment_id}/reactions"], + createForRelease: ["POST /repos/{owner}/{repo}/releases/{release_id}/reactions"], + createForTeamDiscussionCommentInOrg: ["POST /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/comments/{comment_number}/reactions"], + createForTeamDiscussionInOrg: ["POST /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/reactions"], + deleteForCommitComment: ["DELETE /repos/{owner}/{repo}/comments/{comment_id}/reactions/{reaction_id}"], + deleteForIssue: ["DELETE /repos/{owner}/{repo}/issues/{issue_number}/reactions/{reaction_id}"], + deleteForIssueComment: ["DELETE /repos/{owner}/{repo}/issues/comments/{comment_id}/reactions/{reaction_id}"], + deleteForPullRequestComment: ["DELETE /repos/{owner}/{repo}/pulls/comments/{comment_id}/reactions/{reaction_id}"], + deleteForRelease: ["DELETE /repos/{owner}/{repo}/releases/{release_id}/reactions/{reaction_id}"], + deleteForTeamDiscussion: ["DELETE /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/reactions/{reaction_id}"], + deleteForTeamDiscussionComment: ["DELETE /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/comments/{comment_number}/reactions/{reaction_id}"], + listForCommitComment: ["GET /repos/{owner}/{repo}/comments/{comment_id}/reactions"], + listForIssue: ["GET /repos/{owner}/{repo}/issues/{issue_number}/reactions"], + listForIssueComment: ["GET /repos/{owner}/{repo}/issues/comments/{comment_id}/reactions"], + listForPullRequestReviewComment: ["GET /repos/{owner}/{repo}/pulls/comments/{comment_id}/reactions"], + listForRelease: ["GET /repos/{owner}/{repo}/releases/{release_id}/reactions"], + listForTeamDiscussionCommentInOrg: ["GET /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/comments/{comment_number}/reactions"], + listForTeamDiscussionInOrg: ["GET /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/reactions"] + }, + repos: { + acceptInvitation: ["PATCH /user/repository_invitations/{invitation_id}", {}, { + renamed: ["repos", "acceptInvitationForAuthenticatedUser"] + }], + acceptInvitationForAuthenticatedUser: ["PATCH /user/repository_invitations/{invitation_id}"], + addAppAccessRestrictions: ["POST /repos/{owner}/{repo}/branches/{branch}/protection/restrictions/apps", {}, { + mapToData: "apps" + }], + addCollaborator: ["PUT /repos/{owner}/{repo}/collaborators/{username}"], + addStatusCheckContexts: ["POST /repos/{owner}/{repo}/branches/{branch}/protection/required_status_checks/contexts", {}, { + mapToData: "contexts" + }], + addTeamAccessRestrictions: ["POST /repos/{owner}/{repo}/branches/{branch}/protection/restrictions/teams", {}, { + mapToData: "teams" + }], + addUserAccessRestrictions: ["POST /repos/{owner}/{repo}/branches/{branch}/protection/restrictions/users", {}, { + mapToData: "users" + }], + checkCollaborator: ["GET /repos/{owner}/{repo}/collaborators/{username}"], + checkVulnerabilityAlerts: ["GET /repos/{owner}/{repo}/vulnerability-alerts"], + codeownersErrors: ["GET /repos/{owner}/{repo}/codeowners/errors"], + compareCommits: ["GET /repos/{owner}/{repo}/compare/{base}...{head}"], + compareCommitsWithBasehead: ["GET /repos/{owner}/{repo}/compare/{basehead}"], + createAutolink: ["POST /repos/{owner}/{repo}/autolinks"], + createCommitComment: ["POST /repos/{owner}/{repo}/commits/{commit_sha}/comments"], + createCommitSignatureProtection: ["POST /repos/{owner}/{repo}/branches/{branch}/protection/required_signatures"], + createCommitStatus: ["POST /repos/{owner}/{repo}/statuses/{sha}"], + createDeployKey: ["POST /repos/{owner}/{repo}/keys"], + createDeployment: ["POST /repos/{owner}/{repo}/deployments"], + createDeploymentBranchPolicy: ["POST /repos/{owner}/{repo}/environments/{environment_name}/deployment-branch-policies"], + createDeploymentStatus: ["POST /repos/{owner}/{repo}/deployments/{deployment_id}/statuses"], + createDispatchEvent: ["POST /repos/{owner}/{repo}/dispatches"], + createForAuthenticatedUser: ["POST /user/repos"], + createFork: ["POST /repos/{owner}/{repo}/forks"], + createInOrg: ["POST /orgs/{org}/repos"], + createOrUpdateEnvironment: ["PUT /repos/{owner}/{repo}/environments/{environment_name}"], + createOrUpdateFileContents: ["PUT /repos/{owner}/{repo}/contents/{path}"], + createPagesDeployment: ["POST /repos/{owner}/{repo}/pages/deployment"], + createPagesSite: ["POST /repos/{owner}/{repo}/pages"], + createRelease: ["POST /repos/{owner}/{repo}/releases"], + createTagProtection: ["POST /repos/{owner}/{repo}/tags/protection"], + createUsingTemplate: ["POST /repos/{template_owner}/{template_repo}/generate"], + createWebhook: ["POST /repos/{owner}/{repo}/hooks"], + declineInvitation: ["DELETE /user/repository_invitations/{invitation_id}", {}, { + renamed: ["repos", "declineInvitationForAuthenticatedUser"] + }], + declineInvitationForAuthenticatedUser: ["DELETE /user/repository_invitations/{invitation_id}"], + delete: ["DELETE /repos/{owner}/{repo}"], + deleteAccessRestrictions: ["DELETE /repos/{owner}/{repo}/branches/{branch}/protection/restrictions"], + deleteAdminBranchProtection: ["DELETE /repos/{owner}/{repo}/branches/{branch}/protection/enforce_admins"], + deleteAnEnvironment: ["DELETE /repos/{owner}/{repo}/environments/{environment_name}"], + deleteAutolink: ["DELETE /repos/{owner}/{repo}/autolinks/{autolink_id}"], + deleteBranchProtection: ["DELETE /repos/{owner}/{repo}/branches/{branch}/protection"], + deleteCommitComment: ["DELETE /repos/{owner}/{repo}/comments/{comment_id}"], + deleteCommitSignatureProtection: ["DELETE /repos/{owner}/{repo}/branches/{branch}/protection/required_signatures"], + deleteDeployKey: ["DELETE /repos/{owner}/{repo}/keys/{key_id}"], + deleteDeployment: ["DELETE /repos/{owner}/{repo}/deployments/{deployment_id}"], + deleteDeploymentBranchPolicy: ["DELETE /repos/{owner}/{repo}/environments/{environment_name}/deployment-branch-policies/{branch_policy_id}"], + deleteFile: ["DELETE /repos/{owner}/{repo}/contents/{path}"], + deleteInvitation: ["DELETE /repos/{owner}/{repo}/invitations/{invitation_id}"], + deletePagesSite: ["DELETE /repos/{owner}/{repo}/pages"], + deletePullRequestReviewProtection: ["DELETE /repos/{owner}/{repo}/branches/{branch}/protection/required_pull_request_reviews"], + deleteRelease: ["DELETE /repos/{owner}/{repo}/releases/{release_id}"], + deleteReleaseAsset: ["DELETE /repos/{owner}/{repo}/releases/assets/{asset_id}"], + deleteTagProtection: ["DELETE /repos/{owner}/{repo}/tags/protection/{tag_protection_id}"], + deleteWebhook: ["DELETE /repos/{owner}/{repo}/hooks/{hook_id}"], + disableAutomatedSecurityFixes: ["DELETE /repos/{owner}/{repo}/automated-security-fixes"], + disableLfsForRepo: ["DELETE /repos/{owner}/{repo}/lfs"], + disableVulnerabilityAlerts: ["DELETE /repos/{owner}/{repo}/vulnerability-alerts"], + downloadArchive: ["GET /repos/{owner}/{repo}/zipball/{ref}", {}, { + renamed: ["repos", "downloadZipballArchive"] + }], + downloadTarballArchive: ["GET /repos/{owner}/{repo}/tarball/{ref}"], + downloadZipballArchive: ["GET /repos/{owner}/{repo}/zipball/{ref}"], + enableAutomatedSecurityFixes: ["PUT /repos/{owner}/{repo}/automated-security-fixes"], + enableLfsForRepo: ["PUT /repos/{owner}/{repo}/lfs"], + enableVulnerabilityAlerts: ["PUT /repos/{owner}/{repo}/vulnerability-alerts"], + generateReleaseNotes: ["POST /repos/{owner}/{repo}/releases/generate-notes"], + get: ["GET /repos/{owner}/{repo}"], + getAccessRestrictions: ["GET /repos/{owner}/{repo}/branches/{branch}/protection/restrictions"], + getAdminBranchProtection: ["GET /repos/{owner}/{repo}/branches/{branch}/protection/enforce_admins"], + getAllEnvironments: ["GET /repos/{owner}/{repo}/environments"], + getAllStatusCheckContexts: ["GET /repos/{owner}/{repo}/branches/{branch}/protection/required_status_checks/contexts"], + getAllTopics: ["GET /repos/{owner}/{repo}/topics"], + getAppsWithAccessToProtectedBranch: ["GET /repos/{owner}/{repo}/branches/{branch}/protection/restrictions/apps"], + getAutolink: ["GET /repos/{owner}/{repo}/autolinks/{autolink_id}"], + getBranch: ["GET /repos/{owner}/{repo}/branches/{branch}"], + getBranchProtection: ["GET /repos/{owner}/{repo}/branches/{branch}/protection"], + getClones: ["GET /repos/{owner}/{repo}/traffic/clones"], + getCodeFrequencyStats: ["GET /repos/{owner}/{repo}/stats/code_frequency"], + getCollaboratorPermissionLevel: ["GET /repos/{owner}/{repo}/collaborators/{username}/permission"], + getCombinedStatusForRef: ["GET /repos/{owner}/{repo}/commits/{ref}/status"], + getCommit: ["GET /repos/{owner}/{repo}/commits/{ref}"], + getCommitActivityStats: ["GET /repos/{owner}/{repo}/stats/commit_activity"], + getCommitComment: ["GET /repos/{owner}/{repo}/comments/{comment_id}"], + getCommitSignatureProtection: ["GET /repos/{owner}/{repo}/branches/{branch}/protection/required_signatures"], + getCommunityProfileMetrics: ["GET /repos/{owner}/{repo}/community/profile"], + getContent: ["GET /repos/{owner}/{repo}/contents/{path}"], + getContributorsStats: ["GET /repos/{owner}/{repo}/stats/contributors"], + getDeployKey: ["GET /repos/{owner}/{repo}/keys/{key_id}"], + getDeployment: ["GET /repos/{owner}/{repo}/deployments/{deployment_id}"], + getDeploymentBranchPolicy: ["GET /repos/{owner}/{repo}/environments/{environment_name}/deployment-branch-policies/{branch_policy_id}"], + getDeploymentStatus: ["GET /repos/{owner}/{repo}/deployments/{deployment_id}/statuses/{status_id}"], + getEnvironment: ["GET /repos/{owner}/{repo}/environments/{environment_name}"], + getLatestPagesBuild: ["GET /repos/{owner}/{repo}/pages/builds/latest"], + getLatestRelease: ["GET /repos/{owner}/{repo}/releases/latest"], + getPages: ["GET /repos/{owner}/{repo}/pages"], + getPagesBuild: ["GET /repos/{owner}/{repo}/pages/builds/{build_id}"], + getPagesHealthCheck: ["GET /repos/{owner}/{repo}/pages/health"], + getParticipationStats: ["GET /repos/{owner}/{repo}/stats/participation"], + getPullRequestReviewProtection: ["GET /repos/{owner}/{repo}/branches/{branch}/protection/required_pull_request_reviews"], + getPunchCardStats: ["GET /repos/{owner}/{repo}/stats/punch_card"], + getReadme: ["GET /repos/{owner}/{repo}/readme"], + getReadmeInDirectory: ["GET /repos/{owner}/{repo}/readme/{dir}"], + getRelease: ["GET /repos/{owner}/{repo}/releases/{release_id}"], + getReleaseAsset: ["GET /repos/{owner}/{repo}/releases/assets/{asset_id}"], + getReleaseByTag: ["GET /repos/{owner}/{repo}/releases/tags/{tag}"], + getStatusChecksProtection: ["GET /repos/{owner}/{repo}/branches/{branch}/protection/required_status_checks"], + getTeamsWithAccessToProtectedBranch: ["GET /repos/{owner}/{repo}/branches/{branch}/protection/restrictions/teams"], + getTopPaths: ["GET /repos/{owner}/{repo}/traffic/popular/paths"], + getTopReferrers: ["GET /repos/{owner}/{repo}/traffic/popular/referrers"], + getUsersWithAccessToProtectedBranch: ["GET /repos/{owner}/{repo}/branches/{branch}/protection/restrictions/users"], + getViews: ["GET /repos/{owner}/{repo}/traffic/views"], + getWebhook: ["GET /repos/{owner}/{repo}/hooks/{hook_id}"], + getWebhookConfigForRepo: ["GET /repos/{owner}/{repo}/hooks/{hook_id}/config"], + getWebhookDelivery: ["GET /repos/{owner}/{repo}/hooks/{hook_id}/deliveries/{delivery_id}"], + listAutolinks: ["GET /repos/{owner}/{repo}/autolinks"], + listBranches: ["GET /repos/{owner}/{repo}/branches"], + listBranchesForHeadCommit: ["GET /repos/{owner}/{repo}/commits/{commit_sha}/branches-where-head"], + listCollaborators: ["GET /repos/{owner}/{repo}/collaborators"], + listCommentsForCommit: ["GET /repos/{owner}/{repo}/commits/{commit_sha}/comments"], + listCommitCommentsForRepo: ["GET /repos/{owner}/{repo}/comments"], + listCommitStatusesForRef: ["GET /repos/{owner}/{repo}/commits/{ref}/statuses"], + listCommits: ["GET /repos/{owner}/{repo}/commits"], + listContributors: ["GET /repos/{owner}/{repo}/contributors"], + listDeployKeys: ["GET /repos/{owner}/{repo}/keys"], + listDeploymentBranchPolicies: ["GET /repos/{owner}/{repo}/environments/{environment_name}/deployment-branch-policies"], + listDeploymentStatuses: ["GET /repos/{owner}/{repo}/deployments/{deployment_id}/statuses"], + listDeployments: ["GET /repos/{owner}/{repo}/deployments"], + listForAuthenticatedUser: ["GET /user/repos"], + listForOrg: ["GET /orgs/{org}/repos"], + listForUser: ["GET /users/{username}/repos"], + listForks: ["GET /repos/{owner}/{repo}/forks"], + listInvitations: ["GET /repos/{owner}/{repo}/invitations"], + listInvitationsForAuthenticatedUser: ["GET /user/repository_invitations"], + listLanguages: ["GET /repos/{owner}/{repo}/languages"], + listPagesBuilds: ["GET /repos/{owner}/{repo}/pages/builds"], + listPublic: ["GET /repositories"], + listPullRequestsAssociatedWithCommit: ["GET /repos/{owner}/{repo}/commits/{commit_sha}/pulls"], + listReleaseAssets: ["GET /repos/{owner}/{repo}/releases/{release_id}/assets"], + listReleases: ["GET /repos/{owner}/{repo}/releases"], + listTagProtection: ["GET /repos/{owner}/{repo}/tags/protection"], + listTags: ["GET /repos/{owner}/{repo}/tags"], + listTeams: ["GET /repos/{owner}/{repo}/teams"], + listWebhookDeliveries: ["GET /repos/{owner}/{repo}/hooks/{hook_id}/deliveries"], + listWebhooks: ["GET /repos/{owner}/{repo}/hooks"], + merge: ["POST /repos/{owner}/{repo}/merges"], + mergeUpstream: ["POST /repos/{owner}/{repo}/merge-upstream"], + pingWebhook: ["POST /repos/{owner}/{repo}/hooks/{hook_id}/pings"], + redeliverWebhookDelivery: ["POST /repos/{owner}/{repo}/hooks/{hook_id}/deliveries/{delivery_id}/attempts"], + removeAppAccessRestrictions: ["DELETE /repos/{owner}/{repo}/branches/{branch}/protection/restrictions/apps", {}, { + mapToData: "apps" + }], + removeCollaborator: ["DELETE /repos/{owner}/{repo}/collaborators/{username}"], + removeStatusCheckContexts: ["DELETE /repos/{owner}/{repo}/branches/{branch}/protection/required_status_checks/contexts", {}, { + mapToData: "contexts" + }], + removeStatusCheckProtection: ["DELETE /repos/{owner}/{repo}/branches/{branch}/protection/required_status_checks"], + removeTeamAccessRestrictions: ["DELETE /repos/{owner}/{repo}/branches/{branch}/protection/restrictions/teams", {}, { + mapToData: "teams" + }], + removeUserAccessRestrictions: ["DELETE /repos/{owner}/{repo}/branches/{branch}/protection/restrictions/users", {}, { + mapToData: "users" + }], + renameBranch: ["POST /repos/{owner}/{repo}/branches/{branch}/rename"], + replaceAllTopics: ["PUT /repos/{owner}/{repo}/topics"], + requestPagesBuild: ["POST /repos/{owner}/{repo}/pages/builds"], + setAdminBranchProtection: ["POST /repos/{owner}/{repo}/branches/{branch}/protection/enforce_admins"], + setAppAccessRestrictions: ["PUT /repos/{owner}/{repo}/branches/{branch}/protection/restrictions/apps", {}, { + mapToData: "apps" + }], + setStatusCheckContexts: ["PUT /repos/{owner}/{repo}/branches/{branch}/protection/required_status_checks/contexts", {}, { + mapToData: "contexts" + }], + setTeamAccessRestrictions: ["PUT /repos/{owner}/{repo}/branches/{branch}/protection/restrictions/teams", {}, { + mapToData: "teams" + }], + setUserAccessRestrictions: ["PUT /repos/{owner}/{repo}/branches/{branch}/protection/restrictions/users", {}, { + mapToData: "users" + }], + testPushWebhook: ["POST /repos/{owner}/{repo}/hooks/{hook_id}/tests"], + transfer: ["POST /repos/{owner}/{repo}/transfer"], + update: ["PATCH /repos/{owner}/{repo}"], + updateBranchProtection: ["PUT /repos/{owner}/{repo}/branches/{branch}/protection"], + updateCommitComment: ["PATCH /repos/{owner}/{repo}/comments/{comment_id}"], + updateDeploymentBranchPolicy: ["PUT /repos/{owner}/{repo}/environments/{environment_name}/deployment-branch-policies/{branch_policy_id}"], + updateInformationAboutPagesSite: ["PUT /repos/{owner}/{repo}/pages"], + updateInvitation: ["PATCH /repos/{owner}/{repo}/invitations/{invitation_id}"], + updatePullRequestReviewProtection: ["PATCH /repos/{owner}/{repo}/branches/{branch}/protection/required_pull_request_reviews"], + updateRelease: ["PATCH /repos/{owner}/{repo}/releases/{release_id}"], + updateReleaseAsset: ["PATCH /repos/{owner}/{repo}/releases/assets/{asset_id}"], + updateStatusCheckPotection: ["PATCH /repos/{owner}/{repo}/branches/{branch}/protection/required_status_checks", {}, { + renamed: ["repos", "updateStatusCheckProtection"] + }], + updateStatusCheckProtection: ["PATCH /repos/{owner}/{repo}/branches/{branch}/protection/required_status_checks"], + updateWebhook: ["PATCH /repos/{owner}/{repo}/hooks/{hook_id}"], + updateWebhookConfigForRepo: ["PATCH /repos/{owner}/{repo}/hooks/{hook_id}/config"], + uploadReleaseAsset: ["POST /repos/{owner}/{repo}/releases/{release_id}/assets{?name,label}", { + baseUrl: "https://uploads.github.com" + }] + }, + search: { + code: ["GET /search/code"], + commits: ["GET /search/commits"], + issuesAndPullRequests: ["GET /search/issues"], + labels: ["GET /search/labels"], + repos: ["GET /search/repositories"], + topics: ["GET /search/topics"], + users: ["GET /search/users"] + }, + secretScanning: { + getAlert: ["GET /repos/{owner}/{repo}/secret-scanning/alerts/{alert_number}"], + getSecurityAnalysisSettingsForEnterprise: ["GET /enterprises/{enterprise}/code_security_and_analysis"], + listAlertsForEnterprise: ["GET /enterprises/{enterprise}/secret-scanning/alerts"], + listAlertsForOrg: ["GET /orgs/{org}/secret-scanning/alerts"], + listAlertsForRepo: ["GET /repos/{owner}/{repo}/secret-scanning/alerts"], + listLocationsForAlert: ["GET /repos/{owner}/{repo}/secret-scanning/alerts/{alert_number}/locations"], + patchSecurityAnalysisSettingsForEnterprise: ["PATCH /enterprises/{enterprise}/code_security_and_analysis"], + postSecurityProductEnablementForEnterprise: ["POST /enterprises/{enterprise}/{security_product}/{enablement}"], + updateAlert: ["PATCH /repos/{owner}/{repo}/secret-scanning/alerts/{alert_number}"] + }, + teams: { + addOrUpdateMembershipForUserInOrg: ["PUT /orgs/{org}/teams/{team_slug}/memberships/{username}"], + addOrUpdateProjectPermissionsInOrg: ["PUT /orgs/{org}/teams/{team_slug}/projects/{project_id}"], + addOrUpdateRepoPermissionsInOrg: ["PUT /orgs/{org}/teams/{team_slug}/repos/{owner}/{repo}"], + checkPermissionsForProjectInOrg: ["GET /orgs/{org}/teams/{team_slug}/projects/{project_id}"], + checkPermissionsForRepoInOrg: ["GET /orgs/{org}/teams/{team_slug}/repos/{owner}/{repo}"], + create: ["POST /orgs/{org}/teams"], + createDiscussionCommentInOrg: ["POST /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/comments"], + createDiscussionInOrg: ["POST /orgs/{org}/teams/{team_slug}/discussions"], + deleteDiscussionCommentInOrg: ["DELETE /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/comments/{comment_number}"], + deleteDiscussionInOrg: ["DELETE /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}"], + deleteInOrg: ["DELETE /orgs/{org}/teams/{team_slug}"], + getByName: ["GET /orgs/{org}/teams/{team_slug}"], + getDiscussionCommentInOrg: ["GET /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/comments/{comment_number}"], + getDiscussionInOrg: ["GET /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}"], + getMembershipForUserInOrg: ["GET /orgs/{org}/teams/{team_slug}/memberships/{username}"], + list: ["GET /orgs/{org}/teams"], + listChildInOrg: ["GET /orgs/{org}/teams/{team_slug}/teams"], + listDiscussionCommentsInOrg: ["GET /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/comments"], + listDiscussionsInOrg: ["GET /orgs/{org}/teams/{team_slug}/discussions"], + listForAuthenticatedUser: ["GET /user/teams"], + listMembersInOrg: ["GET /orgs/{org}/teams/{team_slug}/members"], + listPendingInvitationsInOrg: ["GET /orgs/{org}/teams/{team_slug}/invitations"], + listProjectsInOrg: ["GET /orgs/{org}/teams/{team_slug}/projects"], + listReposInOrg: ["GET /orgs/{org}/teams/{team_slug}/repos"], + removeMembershipForUserInOrg: ["DELETE /orgs/{org}/teams/{team_slug}/memberships/{username}"], + removeProjectInOrg: ["DELETE /orgs/{org}/teams/{team_slug}/projects/{project_id}"], + removeRepoInOrg: ["DELETE /orgs/{org}/teams/{team_slug}/repos/{owner}/{repo}"], + updateDiscussionCommentInOrg: ["PATCH /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/comments/{comment_number}"], + updateDiscussionInOrg: ["PATCH /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}"], + updateInOrg: ["PATCH /orgs/{org}/teams/{team_slug}"] + }, + users: { + addEmailForAuthenticated: ["POST /user/emails", {}, { + renamed: ["users", "addEmailForAuthenticatedUser"] + }], + addEmailForAuthenticatedUser: ["POST /user/emails"], + block: ["PUT /user/blocks/{username}"], + checkBlocked: ["GET /user/blocks/{username}"], + checkFollowingForUser: ["GET /users/{username}/following/{target_user}"], + checkPersonIsFollowedByAuthenticated: ["GET /user/following/{username}"], + createGpgKeyForAuthenticated: ["POST /user/gpg_keys", {}, { + renamed: ["users", "createGpgKeyForAuthenticatedUser"] + }], + createGpgKeyForAuthenticatedUser: ["POST /user/gpg_keys"], + createPublicSshKeyForAuthenticated: ["POST /user/keys", {}, { + renamed: ["users", "createPublicSshKeyForAuthenticatedUser"] + }], + createPublicSshKeyForAuthenticatedUser: ["POST /user/keys"], + createSshSigningKeyForAuthenticatedUser: ["POST /user/ssh_signing_keys"], + deleteEmailForAuthenticated: ["DELETE /user/emails", {}, { + renamed: ["users", "deleteEmailForAuthenticatedUser"] + }], + deleteEmailForAuthenticatedUser: ["DELETE /user/emails"], + deleteGpgKeyForAuthenticated: ["DELETE /user/gpg_keys/{gpg_key_id}", {}, { + renamed: ["users", "deleteGpgKeyForAuthenticatedUser"] + }], + deleteGpgKeyForAuthenticatedUser: ["DELETE /user/gpg_keys/{gpg_key_id}"], + deletePublicSshKeyForAuthenticated: ["DELETE /user/keys/{key_id}", {}, { + renamed: ["users", "deletePublicSshKeyForAuthenticatedUser"] + }], + deletePublicSshKeyForAuthenticatedUser: ["DELETE /user/keys/{key_id}"], + deleteSshSigningKeyForAuthenticatedUser: ["DELETE /user/ssh_signing_keys/{ssh_signing_key_id}"], + follow: ["PUT /user/following/{username}"], + getAuthenticated: ["GET /user"], + getByUsername: ["GET /users/{username}"], + getContextForUser: ["GET /users/{username}/hovercard"], + getGpgKeyForAuthenticated: ["GET /user/gpg_keys/{gpg_key_id}", {}, { + renamed: ["users", "getGpgKeyForAuthenticatedUser"] + }], + getGpgKeyForAuthenticatedUser: ["GET /user/gpg_keys/{gpg_key_id}"], + getPublicSshKeyForAuthenticated: ["GET /user/keys/{key_id}", {}, { + renamed: ["users", "getPublicSshKeyForAuthenticatedUser"] + }], + getPublicSshKeyForAuthenticatedUser: ["GET /user/keys/{key_id}"], + getSshSigningKeyForAuthenticatedUser: ["GET /user/ssh_signing_keys/{ssh_signing_key_id}"], + list: ["GET /users"], + listBlockedByAuthenticated: ["GET /user/blocks", {}, { + renamed: ["users", "listBlockedByAuthenticatedUser"] + }], + listBlockedByAuthenticatedUser: ["GET /user/blocks"], + listEmailsForAuthenticated: ["GET /user/emails", {}, { + renamed: ["users", "listEmailsForAuthenticatedUser"] + }], + listEmailsForAuthenticatedUser: ["GET /user/emails"], + listFollowedByAuthenticated: ["GET /user/following", {}, { + renamed: ["users", "listFollowedByAuthenticatedUser"] + }], + listFollowedByAuthenticatedUser: ["GET /user/following"], + listFollowersForAuthenticatedUser: ["GET /user/followers"], + listFollowersForUser: ["GET /users/{username}/followers"], + listFollowingForUser: ["GET /users/{username}/following"], + listGpgKeysForAuthenticated: ["GET /user/gpg_keys", {}, { + renamed: ["users", "listGpgKeysForAuthenticatedUser"] + }], + listGpgKeysForAuthenticatedUser: ["GET /user/gpg_keys"], + listGpgKeysForUser: ["GET /users/{username}/gpg_keys"], + listPublicEmailsForAuthenticated: ["GET /user/public_emails", {}, { + renamed: ["users", "listPublicEmailsForAuthenticatedUser"] + }], + listPublicEmailsForAuthenticatedUser: ["GET /user/public_emails"], + listPublicKeysForUser: ["GET /users/{username}/keys"], + listPublicSshKeysForAuthenticated: ["GET /user/keys", {}, { + renamed: ["users", "listPublicSshKeysForAuthenticatedUser"] + }], + listPublicSshKeysForAuthenticatedUser: ["GET /user/keys"], + listSshSigningKeysForAuthenticatedUser: ["GET /user/ssh_signing_keys"], + listSshSigningKeysForUser: ["GET /users/{username}/ssh_signing_keys"], + setPrimaryEmailVisibilityForAuthenticated: ["PATCH /user/email/visibility", {}, { + renamed: ["users", "setPrimaryEmailVisibilityForAuthenticatedUser"] + }], + setPrimaryEmailVisibilityForAuthenticatedUser: ["PATCH /user/email/visibility"], + unblock: ["DELETE /user/blocks/{username}"], + unfollow: ["DELETE /user/following/{username}"], + updateAuthenticated: ["PATCH /user"] + } +}; + +const VERSION = "7.0.1"; + +function endpointsToMethods(octokit, endpointsMap) { + const newMethods = {}; + for (const [scope, endpoints] of Object.entries(endpointsMap)) { + for (const [methodName, endpoint] of Object.entries(endpoints)) { + const [route, defaults, decorations] = endpoint; + const [method, url] = route.split(/ /); + const endpointDefaults = Object.assign({ + method, + url + }, defaults); + if (!newMethods[scope]) { + newMethods[scope] = {}; + } + const scopeMethods = newMethods[scope]; + if (decorations) { + scopeMethods[methodName] = decorate(octokit, scope, methodName, endpointDefaults, decorations); + continue; + } + scopeMethods[methodName] = octokit.request.defaults(endpointDefaults); + } + } + return newMethods; +} +function decorate(octokit, scope, methodName, defaults, decorations) { + const requestWithDefaults = octokit.request.defaults(defaults); + /* istanbul ignore next */ + function withDecorations(...args) { + // @ts-ignore https://github.com/microsoft/TypeScript/issues/25488 + let options = requestWithDefaults.endpoint.merge(...args); + // There are currently no other decorations than `.mapToData` + if (decorations.mapToData) { + options = Object.assign({}, options, { + data: options[decorations.mapToData], + [decorations.mapToData]: undefined + }); + return requestWithDefaults(options); + } + if (decorations.renamed) { + const [newScope, newMethodName] = decorations.renamed; + octokit.log.warn(`octokit.${scope}.${methodName}() has been renamed to octokit.${newScope}.${newMethodName}()`); + } + if (decorations.deprecated) { + octokit.log.warn(decorations.deprecated); + } + if (decorations.renamedParameters) { + // @ts-ignore https://github.com/microsoft/TypeScript/issues/25488 + const options = requestWithDefaults.endpoint.merge(...args); + for (const [name, alias] of Object.entries(decorations.renamedParameters)) { + if (name in options) { + octokit.log.warn(`"${name}" parameter is deprecated for "octokit.${scope}.${methodName}()". Use "${alias}" instead`); + if (!(alias in options)) { + options[alias] = options[name]; + } + delete options[name]; + } + } + return requestWithDefaults(options); + } + // @ts-ignore https://github.com/microsoft/TypeScript/issues/25488 + return requestWithDefaults(...args); + } + return Object.assign(withDecorations, requestWithDefaults); +} + +function restEndpointMethods(octokit) { + const api = endpointsToMethods(octokit, Endpoints); + return { + rest: api + }; +} +restEndpointMethods.VERSION = VERSION; +function legacyRestEndpointMethods(octokit) { + const api = endpointsToMethods(octokit, Endpoints); + return { + ...api, + rest: api + }; +} +legacyRestEndpointMethods.VERSION = VERSION; + +exports.legacyRestEndpointMethods = legacyRestEndpointMethods; +exports.restEndpointMethods = restEndpointMethods; +//# sourceMappingURL=index.js.map + + +/***/ }), + +/***/ 9417: +/***/ ((module) => { + +"use strict"; + +module.exports = balanced; +function balanced(a, b, str) { + if (a instanceof RegExp) a = maybeMatch(a, str); + if (b instanceof RegExp) b = maybeMatch(b, str); + + var r = range(a, b, str); + + return r && { + start: r[0], + end: r[1], + pre: str.slice(0, r[0]), + body: str.slice(r[0] + a.length, r[1]), + post: str.slice(r[1] + b.length) + }; +} + +function maybeMatch(reg, str) { + var m = str.match(reg); + return m ? m[0] : null; +} + +balanced.range = range; +function range(a, b, str) { + var begs, beg, left, right, result; + var ai = str.indexOf(a); + var bi = str.indexOf(b, ai + 1); + var i = ai; + + if (ai >= 0 && bi > 0) { + if(a===b) { + return [ai, bi]; + } + begs = []; + left = str.length; + + while (i >= 0 && !result) { + if (i == ai) { + begs.push(i); + ai = str.indexOf(a, i + 1); + } else if (begs.length == 1) { + result = [ begs.pop(), bi ]; + } else { + beg = begs.pop(); + if (beg < left) { + left = beg; + right = bi; + } + + bi = str.indexOf(b, i + 1); + } + + i = ai < bi && ai >= 0 ? ai : bi; + } + + if (begs.length) { + result = [ left, right ]; + } + } + + return result; +} + + +/***/ }), + +/***/ 3682: +/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { + +var register = __nccwpck_require__(4670); +var addHook = __nccwpck_require__(5549); +var removeHook = __nccwpck_require__(6819); + +// 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; + + +/***/ }), + +/***/ 5549: +/***/ ((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, + }); +} + + +/***/ }), + +/***/ 4670: +/***/ ((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)(); + }); +} + + +/***/ }), + +/***/ 6819: +/***/ ((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); +} + + +/***/ }), + +/***/ 1174: +/***/ (function(module) { + +/** + * This file contains the Bottleneck library (MIT), compiled to ES2017, and without Clustering support. + * https://github.com/SGrondin/bottleneck + */ +(function (global, factory) { + true ? module.exports = factory() : + 0; +}(this, (function () { 'use strict'; + + var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {}; + + function getCjsExportFromNamespace (n) { + return n && n['default'] || n; + } + + var load = function(received, defaults, onto = {}) { + var k, ref, v; + for (k in defaults) { + v = defaults[k]; + onto[k] = (ref = received[k]) != null ? ref : v; + } + return onto; + }; + + var overwrite = function(received, defaults, onto = {}) { + var k, v; + for (k in received) { + v = received[k]; + if (defaults[k] !== void 0) { + onto[k] = v; + } + } + return onto; + }; + + var parser = { + load: load, + overwrite: overwrite + }; + + var DLList; + + DLList = class DLList { + constructor(incr, decr) { + this.incr = incr; + this.decr = decr; + this._first = null; + this._last = null; + this.length = 0; + } + + push(value) { + var node; + this.length++; + if (typeof this.incr === "function") { + this.incr(); + } + node = { + value, + prev: this._last, + next: null + }; + if (this._last != null) { + this._last.next = node; + this._last = node; + } else { + this._first = this._last = node; + } + return void 0; + } + + shift() { + var value; + if (this._first == null) { + return; + } else { + this.length--; + if (typeof this.decr === "function") { + this.decr(); + } + } + value = this._first.value; + if ((this._first = this._first.next) != null) { + this._first.prev = null; + } else { + this._last = null; + } + return value; + } + + first() { + if (this._first != null) { + return this._first.value; + } + } + + getArray() { + var node, ref, results; + node = this._first; + results = []; + while (node != null) { + results.push((ref = node, node = node.next, ref.value)); + } + return results; + } + + forEachShift(cb) { + var node; + node = this.shift(); + while (node != null) { + (cb(node), node = this.shift()); + } + return void 0; + } + + debug() { + var node, ref, ref1, ref2, results; + node = this._first; + results = []; + while (node != null) { + results.push((ref = node, node = node.next, { + value: ref.value, + prev: (ref1 = ref.prev) != null ? ref1.value : void 0, + next: (ref2 = ref.next) != null ? ref2.value : void 0 + })); + } + return results; + } + + }; + + var DLList_1 = DLList; + + var Events; + + Events = class Events { + constructor(instance) { + this.instance = instance; + this._events = {}; + if ((this.instance.on != null) || (this.instance.once != null) || (this.instance.removeAllListeners != null)) { + throw new Error("An Emitter already exists for this object"); + } + this.instance.on = (name, cb) => { + return this._addListener(name, "many", cb); + }; + this.instance.once = (name, cb) => { + return this._addListener(name, "once", cb); + }; + this.instance.removeAllListeners = (name = null) => { + if (name != null) { + return delete this._events[name]; + } else { + return this._events = {}; + } + }; + } + + _addListener(name, status, cb) { + var base; + if ((base = this._events)[name] == null) { + base[name] = []; + } + this._events[name].push({cb, status}); + return this.instance; + } + + listenerCount(name) { + if (this._events[name] != null) { + return this._events[name].length; + } else { + return 0; + } + } + + async trigger(name, ...args) { + var e, promises; + try { + if (name !== "debug") { + this.trigger("debug", `Event triggered: ${name}`, args); + } + if (this._events[name] == null) { + return; + } + this._events[name] = this._events[name].filter(function(listener) { + return listener.status !== "none"; + }); + promises = this._events[name].map(async(listener) => { + var e, returned; + if (listener.status === "none") { + return; + } + if (listener.status === "once") { + listener.status = "none"; + } + try { + returned = typeof listener.cb === "function" ? listener.cb(...args) : void 0; + if (typeof (returned != null ? returned.then : void 0) === "function") { + return (await returned); + } else { + return returned; + } + } catch (error) { + e = error; + { + this.trigger("error", e); + } + return null; + } + }); + return ((await Promise.all(promises))).find(function(x) { + return x != null; + }); + } catch (error) { + e = error; + { + this.trigger("error", e); + } + return null; + } + } + + }; + + var Events_1 = Events; + + var DLList$1, Events$1, Queues; + + DLList$1 = DLList_1; + + Events$1 = Events_1; + + Queues = class Queues { + constructor(num_priorities) { + var i; + this.Events = new Events$1(this); + this._length = 0; + this._lists = (function() { + var j, ref, results; + results = []; + for (i = j = 1, ref = num_priorities; (1 <= ref ? j <= ref : j >= ref); i = 1 <= ref ? ++j : --j) { + results.push(new DLList$1((() => { + return this.incr(); + }), (() => { + return this.decr(); + }))); + } + return results; + }).call(this); + } + + incr() { + if (this._length++ === 0) { + return this.Events.trigger("leftzero"); + } + } + + decr() { + if (--this._length === 0) { + return this.Events.trigger("zero"); + } + } + + push(job) { + return this._lists[job.options.priority].push(job); + } + + queued(priority) { + if (priority != null) { + return this._lists[priority].length; + } else { + return this._length; + } + } + + shiftAll(fn) { + return this._lists.forEach(function(list) { + return list.forEachShift(fn); + }); + } + + getFirst(arr = this._lists) { + var j, len, list; + for (j = 0, len = arr.length; j < len; j++) { + list = arr[j]; + if (list.length > 0) { + return list; + } + } + return []; + } + + shiftLastFrom(priority) { + return this.getFirst(this._lists.slice(priority).reverse()).shift(); + } + + }; + + var Queues_1 = Queues; + + var BottleneckError; + + BottleneckError = class BottleneckError extends Error {}; + + var BottleneckError_1 = BottleneckError; + + var BottleneckError$1, DEFAULT_PRIORITY, Job, NUM_PRIORITIES, parser$1; + + NUM_PRIORITIES = 10; + + DEFAULT_PRIORITY = 5; + + parser$1 = parser; + + BottleneckError$1 = BottleneckError_1; + + Job = class Job { + constructor(task, args, options, jobDefaults, rejectOnDrop, Events, _states, Promise) { + this.task = task; + this.args = args; + this.rejectOnDrop = rejectOnDrop; + this.Events = Events; + this._states = _states; + this.Promise = Promise; + this.options = parser$1.load(options, jobDefaults); + this.options.priority = this._sanitizePriority(this.options.priority); + if (this.options.id === jobDefaults.id) { + this.options.id = `${this.options.id}-${this._randomIndex()}`; + } + this.promise = new this.Promise((_resolve, _reject) => { + this._resolve = _resolve; + this._reject = _reject; + }); + this.retryCount = 0; + } + + _sanitizePriority(priority) { + var sProperty; + sProperty = ~~priority !== priority ? DEFAULT_PRIORITY : priority; + if (sProperty < 0) { + return 0; + } else if (sProperty > NUM_PRIORITIES - 1) { + return NUM_PRIORITIES - 1; + } else { + return sProperty; + } + } + + _randomIndex() { + return Math.random().toString(36).slice(2); + } + + doDrop({error, message = "This job has been dropped by Bottleneck"} = {}) { + if (this._states.remove(this.options.id)) { + if (this.rejectOnDrop) { + this._reject(error != null ? error : new BottleneckError$1(message)); + } + this.Events.trigger("dropped", {args: this.args, options: this.options, task: this.task, promise: this.promise}); + return true; + } else { + return false; + } + } + + _assertStatus(expected) { + var status; + status = this._states.jobStatus(this.options.id); + if (!(status === expected || (expected === "DONE" && status === null))) { + throw new BottleneckError$1(`Invalid job status ${status}, expected ${expected}. Please open an issue at https://github.com/SGrondin/bottleneck/issues`); + } + } + + doReceive() { + this._states.start(this.options.id); + return this.Events.trigger("received", {args: this.args, options: this.options}); + } + + doQueue(reachedHWM, blocked) { + this._assertStatus("RECEIVED"); + this._states.next(this.options.id); + return this.Events.trigger("queued", {args: this.args, options: this.options, reachedHWM, blocked}); + } + + doRun() { + if (this.retryCount === 0) { + this._assertStatus("QUEUED"); + this._states.next(this.options.id); + } else { + this._assertStatus("EXECUTING"); + } + return this.Events.trigger("scheduled", {args: this.args, options: this.options}); + } + + async doExecute(chained, clearGlobalState, run, free) { + var error, eventInfo, passed; + if (this.retryCount === 0) { + this._assertStatus("RUNNING"); + this._states.next(this.options.id); + } else { + this._assertStatus("EXECUTING"); + } + eventInfo = {args: this.args, options: this.options, retryCount: this.retryCount}; + this.Events.trigger("executing", eventInfo); + try { + passed = (await (chained != null ? chained.schedule(this.options, this.task, ...this.args) : this.task(...this.args))); + if (clearGlobalState()) { + this.doDone(eventInfo); + await free(this.options, eventInfo); + this._assertStatus("DONE"); + return this._resolve(passed); + } + } catch (error1) { + error = error1; + return this._onFailure(error, eventInfo, clearGlobalState, run, free); + } + } + + doExpire(clearGlobalState, run, free) { + var error, eventInfo; + if (this._states.jobStatus(this.options.id === "RUNNING")) { + this._states.next(this.options.id); + } + this._assertStatus("EXECUTING"); + eventInfo = {args: this.args, options: this.options, retryCount: this.retryCount}; + error = new BottleneckError$1(`This job timed out after ${this.options.expiration} ms.`); + return this._onFailure(error, eventInfo, clearGlobalState, run, free); + } + + async _onFailure(error, eventInfo, clearGlobalState, run, free) { + var retry, retryAfter; + if (clearGlobalState()) { + retry = (await this.Events.trigger("failed", error, eventInfo)); + if (retry != null) { + retryAfter = ~~retry; + this.Events.trigger("retry", `Retrying ${this.options.id} after ${retryAfter} ms`, eventInfo); + this.retryCount++; + return run(retryAfter); + } else { + this.doDone(eventInfo); + await free(this.options, eventInfo); + this._assertStatus("DONE"); + return this._reject(error); + } + } + } + + doDone(eventInfo) { + this._assertStatus("EXECUTING"); + this._states.next(this.options.id); + return this.Events.trigger("done", eventInfo); + } + + }; + + var Job_1 = Job; + + var BottleneckError$2, LocalDatastore, parser$2; + + parser$2 = parser; + + BottleneckError$2 = BottleneckError_1; + + LocalDatastore = class LocalDatastore { + constructor(instance, storeOptions, storeInstanceOptions) { + this.instance = instance; + this.storeOptions = storeOptions; + this.clientId = this.instance._randomIndex(); + parser$2.load(storeInstanceOptions, storeInstanceOptions, this); + this._nextRequest = this._lastReservoirRefresh = this._lastReservoirIncrease = Date.now(); + this._running = 0; + this._done = 0; + this._unblockTime = 0; + this.ready = this.Promise.resolve(); + this.clients = {}; + this._startHeartbeat(); + } + + _startHeartbeat() { + var base; + if ((this.heartbeat == null) && (((this.storeOptions.reservoirRefreshInterval != null) && (this.storeOptions.reservoirRefreshAmount != null)) || ((this.storeOptions.reservoirIncreaseInterval != null) && (this.storeOptions.reservoirIncreaseAmount != null)))) { + return typeof (base = (this.heartbeat = setInterval(() => { + var amount, incr, maximum, now, reservoir; + now = Date.now(); + if ((this.storeOptions.reservoirRefreshInterval != null) && now >= this._lastReservoirRefresh + this.storeOptions.reservoirRefreshInterval) { + this._lastReservoirRefresh = now; + this.storeOptions.reservoir = this.storeOptions.reservoirRefreshAmount; + this.instance._drainAll(this.computeCapacity()); + } + if ((this.storeOptions.reservoirIncreaseInterval != null) && now >= this._lastReservoirIncrease + this.storeOptions.reservoirIncreaseInterval) { + ({ + reservoirIncreaseAmount: amount, + reservoirIncreaseMaximum: maximum, + reservoir + } = this.storeOptions); + this._lastReservoirIncrease = now; + incr = maximum != null ? Math.min(amount, maximum - reservoir) : amount; + if (incr > 0) { + this.storeOptions.reservoir += incr; + return this.instance._drainAll(this.computeCapacity()); + } + } + }, this.heartbeatInterval))).unref === "function" ? base.unref() : void 0; + } else { + return clearInterval(this.heartbeat); + } + } + + async __publish__(message) { + await this.yieldLoop(); + return this.instance.Events.trigger("message", message.toString()); + } + + async __disconnect__(flush) { + await this.yieldLoop(); + clearInterval(this.heartbeat); + return this.Promise.resolve(); + } + + yieldLoop(t = 0) { + return new this.Promise(function(resolve, reject) { + return setTimeout(resolve, t); + }); + } + + computePenalty() { + var ref; + return (ref = this.storeOptions.penalty) != null ? ref : (15 * this.storeOptions.minTime) || 5000; + } + + async __updateSettings__(options) { + await this.yieldLoop(); + parser$2.overwrite(options, options, this.storeOptions); + this._startHeartbeat(); + this.instance._drainAll(this.computeCapacity()); + return true; + } + + async __running__() { + await this.yieldLoop(); + return this._running; + } + + async __queued__() { + await this.yieldLoop(); + return this.instance.queued(); + } + + async __done__() { + await this.yieldLoop(); + return this._done; + } + + async __groupCheck__(time) { + await this.yieldLoop(); + return (this._nextRequest + this.timeout) < time; + } + + computeCapacity() { + var maxConcurrent, reservoir; + ({maxConcurrent, reservoir} = this.storeOptions); + if ((maxConcurrent != null) && (reservoir != null)) { + return Math.min(maxConcurrent - this._running, reservoir); + } else if (maxConcurrent != null) { + return maxConcurrent - this._running; + } else if (reservoir != null) { + return reservoir; + } else { + return null; + } + } + + conditionsCheck(weight) { + var capacity; + capacity = this.computeCapacity(); + return (capacity == null) || weight <= capacity; + } + + async __incrementReservoir__(incr) { + var reservoir; + await this.yieldLoop(); + reservoir = this.storeOptions.reservoir += incr; + this.instance._drainAll(this.computeCapacity()); + return reservoir; + } + + async __currentReservoir__() { + await this.yieldLoop(); + return this.storeOptions.reservoir; + } + + isBlocked(now) { + return this._unblockTime >= now; + } + + check(weight, now) { + return this.conditionsCheck(weight) && (this._nextRequest - now) <= 0; + } + + async __check__(weight) { + var now; + await this.yieldLoop(); + now = Date.now(); + return this.check(weight, now); + } + + async __register__(index, weight, expiration) { + var now, wait; + await this.yieldLoop(); + now = Date.now(); + if (this.conditionsCheck(weight)) { + this._running += weight; + if (this.storeOptions.reservoir != null) { + this.storeOptions.reservoir -= weight; + } + wait = Math.max(this._nextRequest - now, 0); + this._nextRequest = now + wait + this.storeOptions.minTime; + return { + success: true, + wait, + reservoir: this.storeOptions.reservoir + }; + } else { + return { + success: false + }; + } + } + + strategyIsBlock() { + return this.storeOptions.strategy === 3; + } + + async __submit__(queueLength, weight) { + var blocked, now, reachedHWM; + await this.yieldLoop(); + if ((this.storeOptions.maxConcurrent != null) && weight > this.storeOptions.maxConcurrent) { + throw new BottleneckError$2(`Impossible to add a job having a weight of ${weight} to a limiter having a maxConcurrent setting of ${this.storeOptions.maxConcurrent}`); + } + now = Date.now(); + reachedHWM = (this.storeOptions.highWater != null) && queueLength === this.storeOptions.highWater && !this.check(weight, now); + blocked = this.strategyIsBlock() && (reachedHWM || this.isBlocked(now)); + if (blocked) { + this._unblockTime = now + this.computePenalty(); + this._nextRequest = this._unblockTime + this.storeOptions.minTime; + this.instance._dropAllQueued(); + } + return { + reachedHWM, + blocked, + strategy: this.storeOptions.strategy + }; + } + + async __free__(index, weight) { + await this.yieldLoop(); + this._running -= weight; + this._done += weight; + this.instance._drainAll(this.computeCapacity()); + return { + running: this._running + }; + } + + }; + + var LocalDatastore_1 = LocalDatastore; + + var BottleneckError$3, States; + + BottleneckError$3 = BottleneckError_1; + + States = class States { + constructor(status1) { + this.status = status1; + this._jobs = {}; + this.counts = this.status.map(function() { + return 0; + }); + } + + next(id) { + var current, next; + current = this._jobs[id]; + next = current + 1; + if ((current != null) && next < this.status.length) { + this.counts[current]--; + this.counts[next]++; + return this._jobs[id]++; + } else if (current != null) { + this.counts[current]--; + return delete this._jobs[id]; + } + } + + start(id) { + var initial; + initial = 0; + this._jobs[id] = initial; + return this.counts[initial]++; + } + + remove(id) { + var current; + current = this._jobs[id]; + if (current != null) { + this.counts[current]--; + delete this._jobs[id]; + } + return current != null; + } + + jobStatus(id) { + var ref; + return (ref = this.status[this._jobs[id]]) != null ? ref : null; + } + + statusJobs(status) { + var k, pos, ref, results, v; + if (status != null) { + pos = this.status.indexOf(status); + if (pos < 0) { + throw new BottleneckError$3(`status must be one of ${this.status.join(', ')}`); + } + ref = this._jobs; + results = []; + for (k in ref) { + v = ref[k]; + if (v === pos) { + results.push(k); + } + } + return results; + } else { + return Object.keys(this._jobs); + } + } + + statusCounts() { + return this.counts.reduce(((acc, v, i) => { + acc[this.status[i]] = v; + return acc; + }), {}); + } + + }; + + var States_1 = States; + + var DLList$2, Sync; + + DLList$2 = DLList_1; + + Sync = class Sync { + constructor(name, Promise) { + this.schedule = this.schedule.bind(this); + this.name = name; + this.Promise = Promise; + this._running = 0; + this._queue = new DLList$2(); + } + + isEmpty() { + return this._queue.length === 0; + } + + async _tryToRun() { + var args, cb, error, reject, resolve, returned, task; + if ((this._running < 1) && this._queue.length > 0) { + this._running++; + ({task, args, resolve, reject} = this._queue.shift()); + cb = (await (async function() { + try { + returned = (await task(...args)); + return function() { + return resolve(returned); + }; + } catch (error1) { + error = error1; + return function() { + return reject(error); + }; + } + })()); + this._running--; + this._tryToRun(); + return cb(); + } + } + + schedule(task, ...args) { + var promise, reject, resolve; + resolve = reject = null; + promise = new this.Promise(function(_resolve, _reject) { + resolve = _resolve; + return reject = _reject; + }); + this._queue.push({task, args, resolve, reject}); + this._tryToRun(); + return promise; + } + + }; + + var Sync_1 = Sync; + + var version = "2.19.5"; + var version$1 = { + version: version + }; + + var version$2 = /*#__PURE__*/Object.freeze({ + version: version, + default: version$1 + }); + + var require$$2 = () => console.log('You must import the full version of Bottleneck in order to use this feature.'); + + var require$$3 = () => console.log('You must import the full version of Bottleneck in order to use this feature.'); + + var require$$4 = () => console.log('You must import the full version of Bottleneck in order to use this feature.'); + + var Events$2, Group, IORedisConnection$1, RedisConnection$1, Scripts$1, parser$3; + + parser$3 = parser; + + Events$2 = Events_1; + + RedisConnection$1 = require$$2; + + IORedisConnection$1 = require$$3; + + Scripts$1 = require$$4; + + Group = (function() { + class Group { + constructor(limiterOptions = {}) { + this.deleteKey = this.deleteKey.bind(this); + this.limiterOptions = limiterOptions; + parser$3.load(this.limiterOptions, this.defaults, this); + this.Events = new Events$2(this); + this.instances = {}; + this.Bottleneck = Bottleneck_1; + this._startAutoCleanup(); + this.sharedConnection = this.connection != null; + if (this.connection == null) { + if (this.limiterOptions.datastore === "redis") { + this.connection = new RedisConnection$1(Object.assign({}, this.limiterOptions, {Events: this.Events})); + } else if (this.limiterOptions.datastore === "ioredis") { + this.connection = new IORedisConnection$1(Object.assign({}, this.limiterOptions, {Events: this.Events})); + } + } + } + + key(key = "") { + var ref; + return (ref = this.instances[key]) != null ? ref : (() => { + var limiter; + limiter = this.instances[key] = new this.Bottleneck(Object.assign(this.limiterOptions, { + id: `${this.id}-${key}`, + timeout: this.timeout, + connection: this.connection + })); + this.Events.trigger("created", limiter, key); + return limiter; + })(); + } + + async deleteKey(key = "") { + var deleted, instance; + instance = this.instances[key]; + if (this.connection) { + deleted = (await this.connection.__runCommand__(['del', ...Scripts$1.allKeys(`${this.id}-${key}`)])); + } + if (instance != null) { + delete this.instances[key]; + await instance.disconnect(); + } + return (instance != null) || deleted > 0; + } + + limiters() { + var k, ref, results, v; + ref = this.instances; + results = []; + for (k in ref) { + v = ref[k]; + results.push({ + key: k, + limiter: v + }); + } + return results; + } + + keys() { + return Object.keys(this.instances); + } + + async clusterKeys() { + var cursor, end, found, i, k, keys, len, next, start; + if (this.connection == null) { + return this.Promise.resolve(this.keys()); + } + keys = []; + cursor = null; + start = `b_${this.id}-`.length; + end = "_settings".length; + while (cursor !== 0) { + [next, found] = (await this.connection.__runCommand__(["scan", cursor != null ? cursor : 0, "match", `b_${this.id}-*_settings`, "count", 10000])); + cursor = ~~next; + for (i = 0, len = found.length; i < len; i++) { + k = found[i]; + keys.push(k.slice(start, -end)); + } + } + return keys; + } + + _startAutoCleanup() { + var base; + clearInterval(this.interval); + return typeof (base = (this.interval = setInterval(async() => { + var e, k, ref, results, time, v; + time = Date.now(); + ref = this.instances; + results = []; + for (k in ref) { + v = ref[k]; + try { + if ((await v._store.__groupCheck__(time))) { + results.push(this.deleteKey(k)); + } else { + results.push(void 0); + } + } catch (error) { + e = error; + results.push(v.Events.trigger("error", e)); + } + } + return results; + }, this.timeout / 2))).unref === "function" ? base.unref() : void 0; + } + + updateSettings(options = {}) { + parser$3.overwrite(options, this.defaults, this); + parser$3.overwrite(options, options, this.limiterOptions); + if (options.timeout != null) { + return this._startAutoCleanup(); + } + } + + disconnect(flush = true) { + var ref; + if (!this.sharedConnection) { + return (ref = this.connection) != null ? ref.disconnect(flush) : void 0; + } + } + + } + Group.prototype.defaults = { + timeout: 1000 * 60 * 5, + connection: null, + Promise: Promise, + id: "group-key" + }; + + return Group; + + }).call(commonjsGlobal); + + var Group_1 = Group; + + var Batcher, Events$3, parser$4; + + parser$4 = parser; + + Events$3 = Events_1; + + Batcher = (function() { + class Batcher { + constructor(options = {}) { + this.options = options; + parser$4.load(this.options, this.defaults, this); + this.Events = new Events$3(this); + this._arr = []; + this._resetPromise(); + this._lastFlush = Date.now(); + } + + _resetPromise() { + return this._promise = new this.Promise((res, rej) => { + return this._resolve = res; + }); + } + + _flush() { + clearTimeout(this._timeout); + this._lastFlush = Date.now(); + this._resolve(); + this.Events.trigger("batch", this._arr); + this._arr = []; + return this._resetPromise(); + } + + add(data) { + var ret; + this._arr.push(data); + ret = this._promise; + if (this._arr.length === this.maxSize) { + this._flush(); + } else if ((this.maxTime != null) && this._arr.length === 1) { + this._timeout = setTimeout(() => { + return this._flush(); + }, this.maxTime); + } + return ret; + } + + } + Batcher.prototype.defaults = { + maxTime: null, + maxSize: null, + Promise: Promise + }; + + return Batcher; + + }).call(commonjsGlobal); + + var Batcher_1 = Batcher; + + var require$$4$1 = () => console.log('You must import the full version of Bottleneck in order to use this feature.'); + + var require$$8 = getCjsExportFromNamespace(version$2); + + var Bottleneck, DEFAULT_PRIORITY$1, Events$4, Job$1, LocalDatastore$1, NUM_PRIORITIES$1, Queues$1, RedisDatastore$1, States$1, Sync$1, parser$5, + splice = [].splice; + + NUM_PRIORITIES$1 = 10; + + DEFAULT_PRIORITY$1 = 5; + + parser$5 = parser; + + Queues$1 = Queues_1; + + Job$1 = Job_1; + + LocalDatastore$1 = LocalDatastore_1; + + RedisDatastore$1 = require$$4$1; + + Events$4 = Events_1; + + States$1 = States_1; + + Sync$1 = Sync_1; + + Bottleneck = (function() { + class Bottleneck { + constructor(options = {}, ...invalid) { + var storeInstanceOptions, storeOptions; + this._addToQueue = this._addToQueue.bind(this); + this._validateOptions(options, invalid); + parser$5.load(options, this.instanceDefaults, this); + this._queues = new Queues$1(NUM_PRIORITIES$1); + this._scheduled = {}; + this._states = new States$1(["RECEIVED", "QUEUED", "RUNNING", "EXECUTING"].concat(this.trackDoneStatus ? ["DONE"] : [])); + this._limiter = null; + this.Events = new Events$4(this); + this._submitLock = new Sync$1("submit", this.Promise); + this._registerLock = new Sync$1("register", this.Promise); + storeOptions = parser$5.load(options, this.storeDefaults, {}); + this._store = (function() { + if (this.datastore === "redis" || this.datastore === "ioredis" || (this.connection != null)) { + storeInstanceOptions = parser$5.load(options, this.redisStoreDefaults, {}); + return new RedisDatastore$1(this, storeOptions, storeInstanceOptions); + } else if (this.datastore === "local") { + storeInstanceOptions = parser$5.load(options, this.localStoreDefaults, {}); + return new LocalDatastore$1(this, storeOptions, storeInstanceOptions); + } else { + throw new Bottleneck.prototype.BottleneckError(`Invalid datastore type: ${this.datastore}`); + } + }).call(this); + this._queues.on("leftzero", () => { + var ref; + return (ref = this._store.heartbeat) != null ? typeof ref.ref === "function" ? ref.ref() : void 0 : void 0; + }); + this._queues.on("zero", () => { + var ref; + return (ref = this._store.heartbeat) != null ? typeof ref.unref === "function" ? ref.unref() : void 0 : void 0; + }); + } + + _validateOptions(options, invalid) { + if (!((options != null) && typeof options === "object" && invalid.length === 0)) { + throw new Bottleneck.prototype.BottleneckError("Bottleneck v2 takes a single object argument. Refer to https://github.com/SGrondin/bottleneck#upgrading-to-v2 if you're upgrading from Bottleneck v1."); + } + } + + ready() { + return this._store.ready; + } + + clients() { + return this._store.clients; + } + + channel() { + return `b_${this.id}`; + } + + channel_client() { + return `b_${this.id}_${this._store.clientId}`; + } + + publish(message) { + return this._store.__publish__(message); + } + + disconnect(flush = true) { + return this._store.__disconnect__(flush); + } + + chain(_limiter) { + this._limiter = _limiter; + return this; + } + + queued(priority) { + return this._queues.queued(priority); + } + + clusterQueued() { + return this._store.__queued__(); + } + + empty() { + return this.queued() === 0 && this._submitLock.isEmpty(); + } + + running() { + return this._store.__running__(); + } + + done() { + return this._store.__done__(); + } + + jobStatus(id) { + return this._states.jobStatus(id); + } + + jobs(status) { + return this._states.statusJobs(status); + } + + counts() { + return this._states.statusCounts(); + } + + _randomIndex() { + return Math.random().toString(36).slice(2); + } + + check(weight = 1) { + return this._store.__check__(weight); + } + + _clearGlobalState(index) { + if (this._scheduled[index] != null) { + clearTimeout(this._scheduled[index].expiration); + delete this._scheduled[index]; + return true; + } else { + return false; + } + } + + async _free(index, job, options, eventInfo) { + var e, running; + try { + ({running} = (await this._store.__free__(index, options.weight))); + this.Events.trigger("debug", `Freed ${options.id}`, eventInfo); + if (running === 0 && this.empty()) { + return this.Events.trigger("idle"); + } + } catch (error1) { + e = error1; + return this.Events.trigger("error", e); + } + } + + _run(index, job, wait) { + var clearGlobalState, free, run; + job.doRun(); + clearGlobalState = this._clearGlobalState.bind(this, index); + run = this._run.bind(this, index, job); + free = this._free.bind(this, index, job); + return this._scheduled[index] = { + timeout: setTimeout(() => { + return job.doExecute(this._limiter, clearGlobalState, run, free); + }, wait), + expiration: job.options.expiration != null ? setTimeout(function() { + return job.doExpire(clearGlobalState, run, free); + }, wait + job.options.expiration) : void 0, + job: job + }; + } + + _drainOne(capacity) { + return this._registerLock.schedule(() => { + var args, index, next, options, queue; + if (this.queued() === 0) { + return this.Promise.resolve(null); + } + queue = this._queues.getFirst(); + ({options, args} = next = queue.first()); + if ((capacity != null) && options.weight > capacity) { + return this.Promise.resolve(null); + } + this.Events.trigger("debug", `Draining ${options.id}`, {args, options}); + index = this._randomIndex(); + return this._store.__register__(index, options.weight, options.expiration).then(({success, wait, reservoir}) => { + var empty; + this.Events.trigger("debug", `Drained ${options.id}`, {success, args, options}); + if (success) { + queue.shift(); + empty = this.empty(); + if (empty) { + this.Events.trigger("empty"); + } + if (reservoir === 0) { + this.Events.trigger("depleted", empty); + } + this._run(index, next, wait); + return this.Promise.resolve(options.weight); + } else { + return this.Promise.resolve(null); + } + }); + }); + } + + _drainAll(capacity, total = 0) { + return this._drainOne(capacity).then((drained) => { + var newCapacity; + if (drained != null) { + newCapacity = capacity != null ? capacity - drained : capacity; + return this._drainAll(newCapacity, total + drained); + } else { + return this.Promise.resolve(total); + } + }).catch((e) => { + return this.Events.trigger("error", e); + }); + } + + _dropAllQueued(message) { + return this._queues.shiftAll(function(job) { + return job.doDrop({message}); + }); + } + + stop(options = {}) { + var done, waitForExecuting; + options = parser$5.load(options, this.stopDefaults); + waitForExecuting = (at) => { + var finished; + finished = () => { + var counts; + counts = this._states.counts; + return (counts[0] + counts[1] + counts[2] + counts[3]) === at; + }; + return new this.Promise((resolve, reject) => { + if (finished()) { + return resolve(); + } else { + return this.on("done", () => { + if (finished()) { + this.removeAllListeners("done"); + return resolve(); + } + }); + } + }); + }; + done = options.dropWaitingJobs ? (this._run = function(index, next) { + return next.doDrop({ + message: options.dropErrorMessage + }); + }, this._drainOne = () => { + return this.Promise.resolve(null); + }, this._registerLock.schedule(() => { + return this._submitLock.schedule(() => { + var k, ref, v; + ref = this._scheduled; + for (k in ref) { + v = ref[k]; + if (this.jobStatus(v.job.options.id) === "RUNNING") { + clearTimeout(v.timeout); + clearTimeout(v.expiration); + v.job.doDrop({ + message: options.dropErrorMessage + }); + } + } + this._dropAllQueued(options.dropErrorMessage); + return waitForExecuting(0); + }); + })) : this.schedule({ + priority: NUM_PRIORITIES$1 - 1, + weight: 0 + }, () => { + return waitForExecuting(1); + }); + this._receive = function(job) { + return job._reject(new Bottleneck.prototype.BottleneckError(options.enqueueErrorMessage)); + }; + this.stop = () => { + return this.Promise.reject(new Bottleneck.prototype.BottleneckError("stop() has already been called")); + }; + return done; + } + + async _addToQueue(job) { + var args, blocked, error, options, reachedHWM, shifted, strategy; + ({args, options} = job); + try { + ({reachedHWM, blocked, strategy} = (await this._store.__submit__(this.queued(), options.weight))); + } catch (error1) { + error = error1; + this.Events.trigger("debug", `Could not queue ${options.id}`, {args, options, error}); + job.doDrop({error}); + return false; + } + if (blocked) { + job.doDrop(); + return true; + } else if (reachedHWM) { + shifted = strategy === Bottleneck.prototype.strategy.LEAK ? this._queues.shiftLastFrom(options.priority) : strategy === Bottleneck.prototype.strategy.OVERFLOW_PRIORITY ? this._queues.shiftLastFrom(options.priority + 1) : strategy === Bottleneck.prototype.strategy.OVERFLOW ? job : void 0; + if (shifted != null) { + shifted.doDrop(); + } + if ((shifted == null) || strategy === Bottleneck.prototype.strategy.OVERFLOW) { + if (shifted == null) { + job.doDrop(); + } + return reachedHWM; + } + } + job.doQueue(reachedHWM, blocked); + this._queues.push(job); + await this._drainAll(); + return reachedHWM; + } + + _receive(job) { + if (this._states.jobStatus(job.options.id) != null) { + job._reject(new Bottleneck.prototype.BottleneckError(`A job with the same id already exists (id=${job.options.id})`)); + return false; + } else { + job.doReceive(); + return this._submitLock.schedule(this._addToQueue, job); + } + } + + submit(...args) { + var cb, fn, job, options, ref, ref1, task; + if (typeof args[0] === "function") { + ref = args, [fn, ...args] = ref, [cb] = splice.call(args, -1); + options = parser$5.load({}, this.jobDefaults); + } else { + ref1 = args, [options, fn, ...args] = ref1, [cb] = splice.call(args, -1); + options = parser$5.load(options, this.jobDefaults); + } + task = (...args) => { + return new this.Promise(function(resolve, reject) { + return fn(...args, function(...args) { + return (args[0] != null ? reject : resolve)(args); + }); + }); + }; + job = new Job$1(task, args, options, this.jobDefaults, this.rejectOnDrop, this.Events, this._states, this.Promise); + job.promise.then(function(args) { + return typeof cb === "function" ? cb(...args) : void 0; + }).catch(function(args) { + if (Array.isArray(args)) { + return typeof cb === "function" ? cb(...args) : void 0; + } else { + return typeof cb === "function" ? cb(args) : void 0; + } + }); + return this._receive(job); + } + + schedule(...args) { + var job, options, task; + if (typeof args[0] === "function") { + [task, ...args] = args; + options = {}; + } else { + [options, task, ...args] = args; + } + job = new Job$1(task, args, options, this.jobDefaults, this.rejectOnDrop, this.Events, this._states, this.Promise); + this._receive(job); + return job.promise; + } + + wrap(fn) { + var schedule, wrapped; + schedule = this.schedule.bind(this); + wrapped = function(...args) { + return schedule(fn.bind(this), ...args); + }; + wrapped.withOptions = function(options, ...args) { + return schedule(options, fn, ...args); + }; + return wrapped; + } + + async updateSettings(options = {}) { + await this._store.__updateSettings__(parser$5.overwrite(options, this.storeDefaults)); + parser$5.overwrite(options, this.instanceDefaults, this); + return this; + } + + currentReservoir() { + return this._store.__currentReservoir__(); + } + + incrementReservoir(incr = 0) { + return this._store.__incrementReservoir__(incr); + } + + } + Bottleneck.default = Bottleneck; + + Bottleneck.Events = Events$4; + + Bottleneck.version = Bottleneck.prototype.version = require$$8.version; + + Bottleneck.strategy = Bottleneck.prototype.strategy = { + LEAK: 1, + OVERFLOW: 2, + OVERFLOW_PRIORITY: 4, + BLOCK: 3 + }; + + Bottleneck.BottleneckError = Bottleneck.prototype.BottleneckError = BottleneckError_1; + + Bottleneck.Group = Bottleneck.prototype.Group = Group_1; + + Bottleneck.RedisConnection = Bottleneck.prototype.RedisConnection = require$$2; + + Bottleneck.IORedisConnection = Bottleneck.prototype.IORedisConnection = require$$3; + + Bottleneck.Batcher = Bottleneck.prototype.Batcher = Batcher_1; + + Bottleneck.prototype.jobDefaults = { + priority: DEFAULT_PRIORITY$1, + weight: 1, + expiration: null, + id: "" + }; + + Bottleneck.prototype.storeDefaults = { + maxConcurrent: null, + minTime: 0, + highWater: null, + strategy: Bottleneck.prototype.strategy.LEAK, + penalty: null, + reservoir: null, + reservoirRefreshInterval: null, + reservoirRefreshAmount: null, + reservoirIncreaseInterval: null, + reservoirIncreaseAmount: null, + reservoirIncreaseMaximum: null + }; + + Bottleneck.prototype.localStoreDefaults = { + Promise: Promise, + timeout: null, + heartbeatInterval: 250 + }; + + Bottleneck.prototype.redisStoreDefaults = { + Promise: Promise, + timeout: null, + heartbeatInterval: 5000, + clientTimeout: 10000, + Redis: null, + clientOptions: {}, + clusterNodes: null, + clearDatastore: false, + connection: null + }; + + Bottleneck.prototype.instanceDefaults = { + datastore: "local", + connection: null, + id: "", + rejectOnDrop: true, + trackDoneStatus: false, + Promise: Promise + }; + + Bottleneck.prototype.stopDefaults = { + enqueueErrorMessage: "This limiter has been stopped and cannot accept new jobs.", + dropWaitingJobs: true, + dropErrorMessage: "This limiter has been stopped." + }; + + return Bottleneck; + + }).call(commonjsGlobal); + + var Bottleneck_1 = Bottleneck; + + var lib = Bottleneck_1; + + return lib; + +}))); + + +/***/ }), + +/***/ 3717: +/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { + +var concatMap = __nccwpck_require__(6891); +var balanced = __nccwpck_require__(9417); + +module.exports = expandTop; + +var escSlash = '\0SLASH'+Math.random()+'\0'; +var escOpen = '\0OPEN'+Math.random()+'\0'; +var escClose = '\0CLOSE'+Math.random()+'\0'; +var escComma = '\0COMMA'+Math.random()+'\0'; +var escPeriod = '\0PERIOD'+Math.random()+'\0'; + +function numeric(str) { + return parseInt(str, 10) == str + ? parseInt(str, 10) + : str.charCodeAt(0); +} + +function escapeBraces(str) { + return str.split('\\\\').join(escSlash) + .split('\\{').join(escOpen) + .split('\\}').join(escClose) + .split('\\,').join(escComma) + .split('\\.').join(escPeriod); +} + +function unescapeBraces(str) { + return str.split(escSlash).join('\\') + .split(escOpen).join('{') + .split(escClose).join('}') + .split(escComma).join(',') + .split(escPeriod).join('.'); +} + + +// Basically just str.split(","), but handling cases +// where we have nested braced sections, which should be +// treated as individual members, like {a,{b,c},d} +function parseCommaParts(str) { + if (!str) + return ['']; + + var parts = []; + var m = balanced('{', '}', str); + + if (!m) + return str.split(','); + + var pre = m.pre; + var body = m.body; + var post = m.post; + var p = pre.split(','); + + p[p.length-1] += '{' + body + '}'; + var postParts = parseCommaParts(post); + if (post.length) { + p[p.length-1] += postParts.shift(); + p.push.apply(p, postParts); + } + + parts.push.apply(parts, p); + + return parts; +} + +function expandTop(str) { + if (!str) + return []; + + // I don't know why Bash 4.3 does this, but it does. + // Anything starting with {} will have the first two bytes preserved + // but *only* at the top level, so {},a}b will not expand to anything, + // but a{},b}c will be expanded to [a}c,abc]. + // One could argue that this is a bug in Bash, but since the goal of + // this module is to match Bash's rules, we escape a leading {} + if (str.substr(0, 2) === '{}') { + str = '\\{\\}' + str.substr(2); + } + + return expand(escapeBraces(str), true).map(unescapeBraces); +} + +function identity(e) { + return e; +} + +function embrace(str) { + return '{' + str + '}'; +} +function isPadded(el) { + return /^-?0\d/.test(el); +} + +function lte(i, y) { + return i <= y; +} +function gte(i, y) { + return i >= y; +} + +function expand(str, isTop) { + var expansions = []; + + var m = balanced('{', '}', str); + if (!m || /\$$/.test(m.pre)) return [str]; + + var isNumericSequence = /^-?\d+\.\.-?\d+(?:\.\.-?\d+)?$/.test(m.body); + var isAlphaSequence = /^[a-zA-Z]\.\.[a-zA-Z](?:\.\.-?\d+)?$/.test(m.body); + var isSequence = isNumericSequence || isAlphaSequence; + var isOptions = m.body.indexOf(',') >= 0; + if (!isSequence && !isOptions) { + // {a},b} + if (m.post.match(/,.*\}/)) { + str = m.pre + '{' + m.body + escClose + m.post; + return expand(str); + } + return [str]; + } + + var n; + if (isSequence) { + n = m.body.split(/\.\./); + } else { + n = parseCommaParts(m.body); + if (n.length === 1) { + // x{{a,b}}y ==> x{a}y x{b}y + n = expand(n[0], false).map(embrace); + if (n.length === 1) { + var post = m.post.length + ? expand(m.post, false) + : ['']; + return post.map(function(p) { + return m.pre + n[0] + p; + }); + } + } + } + + // at this point, n is the parts, and we know it's not a comma set + // with a single entry. + + // no need to expand pre, since it is guaranteed to be free of brace-sets + var pre = m.pre; + var post = m.post.length + ? expand(m.post, false) + : ['']; + + var N; + + if (isSequence) { + var x = numeric(n[0]); + var y = numeric(n[1]); + var width = Math.max(n[0].length, n[1].length) + var incr = n.length == 3 + ? Math.abs(numeric(n[2])) + : 1; + var test = lte; + var reverse = y < x; + if (reverse) { + incr *= -1; + test = gte; + } + var pad = n.some(isPadded); + + N = []; + + for (var i = x; test(i, y); i += incr) { + var c; + if (isAlphaSequence) { + c = String.fromCharCode(i); + if (c === '\\') + c = ''; + } else { + c = String(i); + if (pad) { + var need = width - c.length; + if (need > 0) { + var z = new Array(need + 1).join('0'); + if (i < 0) + c = '-' + z + c.slice(1); + else + c = z + c; + } + } + } + N.push(c); + } + } else { + N = concatMap(n, function(el) { return expand(el, false) }); + } + + for (var j = 0; j < N.length; j++) { + for (var k = 0; k < post.length; k++) { + var expansion = pre + N[j] + post[k]; + if (!isTop || isSequence || expansion) + expansions.push(expansion); + } + } + + return expansions; +} + + + +/***/ }), + +/***/ 6891: +/***/ ((module) => { + +module.exports = function (xs, fn) { + var res = []; + for (var i = 0; i < xs.length; i++) { + var x = fn(xs[i], i); + if (isArray(x)) res.push.apply(res, x); + else res.push(x); + } + return res; +}; + +var isArray = Array.isArray || function (xs) { + return Object.prototype.toString.call(xs) === '[object Array]'; +}; + + +/***/ }), + +/***/ 8932: +/***/ ((__unused_webpack_module, 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; + + +/***/ }), + +/***/ 3287: +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + + +Object.defineProperty(exports, "__esModule", ({ value: true })); + +/*! + * is-plain-object + * + * Copyright (c) 2014-2017, Jon Schlinkert. + * Released under the MIT License. + */ + +function isObject(o) { + return Object.prototype.toString.call(o) === '[object Object]'; +} + +function isPlainObject(o) { + var ctor,prot; + + if (isObject(o) === false) return false; + + // If has modified constructor + ctor = o.constructor; + if (ctor === undefined) return true; + + // If has modified prototype + prot = ctor.prototype; + if (isObject(prot) === false) return false; + + // If constructor does not have an Object-specific method + if (prot.hasOwnProperty('isPrototypeOf') === false) { + return false; + } + + // Most likely a plain Object + return true; +} + +exports.isPlainObject = isPlainObject; + + +/***/ }), + +/***/ 6737: +/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { + +// js acts as a wrapper to the c++ bindings +// prefer to do error handling and other abstrctions in the +// js layer and only go to c++ when we need to hit libxml +var bindings = __nccwpck_require__(1463); + +// document parsing for backwards compat +var Document = __nccwpck_require__(6037); + +/// parse an xml string and return a Document +module.exports.parseXml = Document.fromXml; + +/// parse an html string and return a Document +module.exports.parseHtml = Document.fromHtml; +module.exports.parseHtmlFragment = Document.fromHtmlFragment; + +// constants +module.exports.version = __nccwpck_require__(2485).version; +module.exports.libxml_version = bindings.libxml_version; +module.exports.libxml_parser_version = bindings.libxml_parser_version; +module.exports.libxml_debug_enabled = bindings.libxml_debug_enabled; +module.exports.features = bindings.features; + +// lib exports +module.exports.Comment = __nccwpck_require__(9284); +module.exports.Document = Document; +module.exports.Element = __nccwpck_require__(9837); +module.exports.ProcessingInstruction = __nccwpck_require__(1701); +module.exports.Text = __nccwpck_require__(2036); + +// Compatibility synonyms +Document.fromXmlString = Document.fromXml; +Document.fromHtmlString = Document.fromHtml; +module.exports.parseXmlString = module.exports.parseXml; +module.exports.parseHtmlString = module.exports.parseHtml; + +var sax_parser = __nccwpck_require__(3857); +module.exports.SaxParser = sax_parser.SaxParser; +module.exports.SaxPushParser = sax_parser.SaxPushParser; + +module.exports.memoryUsage = bindings.xmlMemUsed; + +module.exports.nodeCount = bindings.xmlNodeCount; + + +/***/ }), + +/***/ 1463: +/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { + +module.exports = require(__nccwpck_require__.ab + "build/Release/xmljs.node"); + + +/***/ }), + +/***/ 9284: +/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { + +var bindings = __nccwpck_require__(1463); + +var Document = __nccwpck_require__(6037); + +/// create a new comment on the given document +/// @param doc the Document to create the comment for +/// @param {String} [content] comment content +/// @constructor +var Comment = function(doc, content) { + if (!doc) { + throw new Error('document argument required'); + } else if (! (doc instanceof bindings.Document)) { + throw new Error('document argument must be an ' + + 'instance of Document'); + } + + return new bindings.Comment(doc, content); +}; + +Comment.prototype = bindings.Comment.prototype; + +module.exports = Comment; + + + +/***/ }), + +/***/ 6037: +/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { + +var bindings = __nccwpck_require__(1463); + +var Element = __nccwpck_require__(9837); + +function assertRoot(doc) { + if(!doc.root()) { + throw new Error('Document has no root element'); + } +} + +/// Create a new document +/// @param {string} version xml version, default 1.0 +/// @param {string} encoding the encoding, default utf8 +/// @constructor +function Document(version, encoding) { + version = version || '1.0'; + var doc = new bindings.Document(version); + doc.encoding(encoding || 'utf8'); + return doc; +} + +Document.prototype = bindings.Document.prototype; + +/// get or set the root element +/// if called without any arguments, this will return the document root +/// @param {Element} [elem] if specified, this will become the new document root +Document.prototype.root = function(elem) { + return this._root(elem); +}; + +/// add a child node to the document +/// this will set the document root +Document.prototype.node = function(name, content) { + return this.root(Element(this, name, content)); +}; + +/// xpath search +/// @return array of matching elements +Document.prototype.find = function(xpath, ns_uri) { + assertRoot(this); + + return this.root().find(xpath, ns_uri); +}; + +/// xpath search +/// @return first element matching +Document.prototype.get = function(xpath, ns_uri) { + assertRoot(this); + + return this.root().get(xpath, ns_uri); +}; + +/// @return a given child +Document.prototype.child = function(id) { + if (id === undefined || typeof id !== 'number') { + throw new Error('id argument required for #child'); + } + + assertRoot(this); + + return this.root().child(id); +}; + +/// @return an Array of child nodes of the document root +Document.prototype.childNodes = function() { + assertRoot(this); + + return this.root().childNodes(); +}; + +/// @return a string representation of the document +Document.prototype.toString = function(formatted) { + return this._toString(formatted !== undefined ? formatted : true); +}; + +/// @return the document version +Document.prototype.version = function() { + return this._version(); +}; + +/// @return the document encoding +Document.prototype.encoding = function(encoding) { + return this._encoding(encoding); +}; + +/// @return whether the XmlDocument is valid +Document.prototype.validate = function(xsd) { + return this._validate(xsd); +}; + +/// @return whether the XmlDocument is valid using Relaxed NG +Document.prototype.rngValidate = function(rng) { + return this._rngValidate(rng); +}; + +Document.prototype.getDtd = function() { + return this._getDtd(); +}; + +Document.prototype.setDtd = function(name, ext, sys) { + if (!name) { + throw new Error('Must pass in a DTD name'); + } else if (typeof name !== 'string') { + throw new Error('Must pass in a valid DTD name'); + } + + var params = [name]; + if (typeof ext !== 'undefined') { + params.push(ext); + } + if (ext && typeof sys !== 'undefined') { + params.push(sys); + } + + return this._setDtd.apply(this, params); +}; + +/// @return array of namespaces in document +Document.prototype.namespaces = function() { + assertRoot(this); + + return this.root().namespaces(); +}; + +Document.prototype.type = function() { + return 'document'; +}; + +module.exports = Document; + +/// parse a string into a html document +/// @param string html string to parse +/// @param {encoding:string, baseUrl:string} opts html string to parse +/// @return a Document +module.exports.fromHtml = function(string, opts) { + opts = opts || {}; + + // if for some reason user did not specify an object for the options + if (typeof(opts) !== 'object') { + throw new Error('fromHtml options must be an object'); + } + + return bindings.fromHtml(string, opts); +}; + +/// parse a string into a html document fragment +/// @param string html string to parse +/// @param {encoding:string, baseUrl:string} opts html string to parse +/// @return a Document +module.exports.fromHtmlFragment = function(string, opts) { + opts = opts || {}; + + // if for some reason user did not specify an object for the options + if (typeof(opts) !== 'object') { + throw new Error('fromHtmlFragment options must be an object'); + } + + opts.doctype = false; + opts.implied = false; + + return bindings.fromHtml(string, opts); +}; + +/// parse a string into a xml document +/// @param string xml string to parse +/// @return a Document +module.exports.fromXml = function(string, options) { + return bindings.fromXml(string, options || {}); +}; + + + +/***/ }), + +/***/ 9837: +/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { + +var bindings = __nccwpck_require__(1463); + +/// create a new element on the given document +/// @param doc the Document to create the element for +/// @param name the element name +/// @param {String} [content] element content +/// @constructor +function Element(doc, name, content) { + if (!doc) { + throw new Error('document argument required'); + } else if (! (doc instanceof bindings.Document)) { + throw new Error('document argument must be an ' + + 'instance of Document'); + } else if (!name) { + throw new Error('name argument required'); + } + + return new bindings.Element(doc, name, content); +} + +Element.prototype = bindings.Element.prototype; + +Element.prototype.attr = function() { + if (arguments.length === 1) { + var arg = arguments[0]; + if (typeof arg === 'object') { + // object setter + // iterate keys/value to set attributes + for (var k in arg) { + this._attr(k, arg[k]); + }; + return this; + } else if (typeof arg === 'string') { + // getter + return this._attr(arg); + } + } else if (arguments.length === 2) { + // 2 arg setter + var name = arguments[0]; + var value = arguments[1]; + this._attr(name, value); + return this; + } +}; + +/// helper method to attach a new node to this element +/// @param name the element name +/// @param {String} [content] element content +Element.prototype.node = function(name, content) { + var elem = Element(this.doc(), name, content); + this.addChild(elem); + return elem; +}; + +/// helper method to attach a cdata to this element +/// @param name the element name +/// @param {String} [content] element content +Element.prototype.cdata = function(content) { + this.addCData(content); + return this; +}; + +Element.prototype.get = function() { + var res = this.find.apply(this, arguments); + if (res instanceof Array) { + return res[0]; + } else { + return res; + } +}; + +Element.prototype.defineNamespace = function(prefix, href) { + // if no prefix specified + if (!href) { + href = prefix; + prefix = null; + } + return new bindings.Namespace(this, prefix, href); +}; + +module.exports = Element; + + + +/***/ }), + +/***/ 1701: +/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { + +var bindings = __nccwpck_require__(1463); + +/// create a new processing instruction on the given document +/// @param doc the Document to create the processing instruction for +/// @param name the processing instruction name +/// @param {String} [content] processing instruction content +/// @constructor +function ProcessingInstruction(doc, name, content) { + if (!doc) { + throw new Error('document argument required'); + } else if (! (doc instanceof bindings.Document)) { + throw new Error('document argument must be an ' + + 'instance of Document'); + } else if (!name) { + throw new Error('name argument required'); + } + + return new bindings.ProcessingInstruction(doc, name, content); +} + +ProcessingInstruction.prototype = bindings.ProcessingInstruction.prototype; + +module.exports = ProcessingInstruction; + + +/***/ }), + +/***/ 3857: +/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { + +var events = __nccwpck_require__(2361); + +var bindings = __nccwpck_require__(1463); + +var SaxParser = function(callbacks) { + var parser = new bindings.SaxParser(); + + // attach callbacks + for (var callback in callbacks) { + parser.on(callback, callbacks[callback]); + } + + return parser; +}; + +// Overriding the prototype, like util.inherit, wipes out the native binding. +// Copy over the methods instead. +for (var k in events.EventEmitter.prototype) + bindings.SaxParser.prototype[k] = events.EventEmitter.prototype[k]; + +var SaxPushParser = function(callbacks) { + var parser = new bindings.SaxPushParser(); + + // attach callbacks + for (var callback in callbacks) { + parser.on(callback, callbacks[callback]); + } + + return parser; +}; + +// Overriding the prototype, like util.inherit, wipes out the native binding. +// Copy over the methods instead. +for (var k in events.EventEmitter.prototype) + bindings.SaxPushParser.prototype[k] = events.EventEmitter.prototype[k]; + +module.exports.SaxParser = SaxParser; +module.exports.SaxPushParser = SaxPushParser; + + + +/***/ }), + +/***/ 2036: +/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { + +var bindings = __nccwpck_require__(1463); + +/// create a new element on the given document +/// @param doc the Document to create the element for +/// @param name the element name +/// @param {String} [contenn] element content +/// @constructor + + +function Text(doc, content) { + if (!doc) { + throw new Error('document argument required'); + } + + if (!(doc instanceof bindings.Document)) { + throw new Error('document argument must be an instance of Document'); + } + + if (!content) { + throw new Error('content argument required'); + } + + return new bindings.Text(doc, content); +} + +Text.prototype = bindings.Text.prototype; + +module.exports = Text; + + +/***/ }), + +/***/ 3973: +/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { + +module.exports = minimatch +minimatch.Minimatch = Minimatch + +var path = (function () { try { return __nccwpck_require__(1017) } catch (e) {}}()) || { + sep: '/' +} +minimatch.sep = path.sep + +var GLOBSTAR = minimatch.GLOBSTAR = Minimatch.GLOBSTAR = {} +var expand = __nccwpck_require__(3717) + +var plTypes = { + '!': { open: '(?:(?!(?:', close: '))[^/]*?)'}, + '?': { open: '(?:', close: ')?' }, + '+': { open: '(?:', close: ')+' }, + '*': { open: '(?:', close: ')*' }, + '@': { open: '(?:', close: ')' } +} + +// any single thing other than / +// don't need to escape / when using new RegExp() +var qmark = '[^/]' + +// * => any number of characters +var star = qmark + '*?' + +// ** when dots are allowed. Anything goes, except .. and . +// not (^ or / followed by one or two dots followed by $ or /), +// followed by anything, any number of times. +var twoStarDot = '(?:(?!(?:\\\/|^)(?:\\.{1,2})($|\\\/)).)*?' + +// not a ^ or / followed by a dot, +// followed by anything, any number of times. +var twoStarNoDot = '(?:(?!(?:\\\/|^)\\.).)*?' + +// characters that need to be escaped in RegExp. +var reSpecials = charSet('().*{}+?[]^$\\!') + +// "abc" -> { a:true, b:true, c:true } +function charSet (s) { + return s.split('').reduce(function (set, c) { + set[c] = true + return set + }, {}) +} + +// normalizes slashes. +var slashSplit = /\/+/ + +minimatch.filter = filter +function filter (pattern, options) { + options = options || {} + return function (p, i, list) { + return minimatch(p, pattern, options) + } +} + +function ext (a, b) { + b = b || {} + var t = {} + Object.keys(a).forEach(function (k) { + t[k] = a[k] + }) + Object.keys(b).forEach(function (k) { + t[k] = b[k] + }) + return t +} + +minimatch.defaults = function (def) { + if (!def || typeof def !== 'object' || !Object.keys(def).length) { + return minimatch + } + + var orig = minimatch + + var m = function minimatch (p, pattern, options) { + return orig(p, pattern, ext(def, options)) + } + + m.Minimatch = function Minimatch (pattern, options) { + return new orig.Minimatch(pattern, ext(def, options)) + } + m.Minimatch.defaults = function defaults (options) { + return orig.defaults(ext(def, options)).Minimatch + } + + m.filter = function filter (pattern, options) { + return orig.filter(pattern, ext(def, options)) + } + + m.defaults = function defaults (options) { + return orig.defaults(ext(def, options)) + } + + m.makeRe = function makeRe (pattern, options) { + return orig.makeRe(pattern, ext(def, options)) + } + + m.braceExpand = function braceExpand (pattern, options) { + return orig.braceExpand(pattern, ext(def, options)) + } + + m.match = function (list, pattern, options) { + return orig.match(list, pattern, ext(def, options)) + } + + return m +} + +Minimatch.defaults = function (def) { + return minimatch.defaults(def).Minimatch +} + +function minimatch (p, pattern, options) { + assertValidPattern(pattern) + + if (!options) options = {} + + // shortcut: comments match nothing. + if (!options.nocomment && pattern.charAt(0) === '#') { + return false + } + + return new Minimatch(pattern, options).match(p) +} + +function Minimatch (pattern, options) { + if (!(this instanceof Minimatch)) { + return new Minimatch(pattern, options) + } + + assertValidPattern(pattern) + + if (!options) options = {} + + pattern = pattern.trim() + + // windows support: need to use /, not \ + if (!options.allowWindowsEscape && path.sep !== '/') { + pattern = pattern.split(path.sep).join('/') + } + + this.options = options + this.set = [] + this.pattern = pattern + this.regexp = null + this.negate = false + this.comment = false + this.empty = false + this.partial = !!options.partial + + // make the set of regexps etc. + this.make() +} + +Minimatch.prototype.debug = function () {} + +Minimatch.prototype.make = make +function make () { + var pattern = this.pattern + var options = this.options + + // empty patterns and comments match nothing. + if (!options.nocomment && pattern.charAt(0) === '#') { + this.comment = true + return + } + if (!pattern) { + this.empty = true + return + } + + // step 1: figure out negation, etc. + this.parseNegate() + + // step 2: expand braces + var set = this.globSet = this.braceExpand() + + if (options.debug) this.debug = function debug() { console.error.apply(console, arguments) } + + this.debug(this.pattern, set) + + // step 3: now we have a set, so turn each one into a series of path-portion + // matching patterns. + // These will be regexps, except in the case of "**", which is + // set to the GLOBSTAR object for globstar behavior, + // and will not contain any / characters + set = this.globParts = set.map(function (s) { + return s.split(slashSplit) + }) + + this.debug(this.pattern, set) + + // glob --> regexps + set = set.map(function (s, si, set) { + return s.map(this.parse, this) + }, this) + + this.debug(this.pattern, set) + + // filter out everything that didn't compile properly. + set = set.filter(function (s) { + return s.indexOf(false) === -1 + }) + + this.debug(this.pattern, set) + + this.set = set +} + +Minimatch.prototype.parseNegate = parseNegate +function parseNegate () { + var pattern = this.pattern + var negate = false + var options = this.options + var negateOffset = 0 + + if (options.nonegate) return + + for (var i = 0, l = pattern.length + ; i < l && pattern.charAt(i) === '!' + ; i++) { + negate = !negate + negateOffset++ + } + + if (negateOffset) this.pattern = pattern.substr(negateOffset) + this.negate = negate +} + +// Brace expansion: +// a{b,c}d -> abd acd +// a{b,}c -> abc ac +// a{0..3}d -> a0d a1d a2d a3d +// a{b,c{d,e}f}g -> abg acdfg acefg +// a{b,c}d{e,f}g -> abdeg acdeg abdeg abdfg +// +// Invalid sets are not expanded. +// a{2..}b -> a{2..}b +// a{b}c -> a{b}c +minimatch.braceExpand = function (pattern, options) { + return braceExpand(pattern, options) +} + +Minimatch.prototype.braceExpand = braceExpand + +function braceExpand (pattern, options) { + if (!options) { + if (this instanceof Minimatch) { + options = this.options + } else { + options = {} + } + } + + pattern = typeof pattern === 'undefined' + ? this.pattern : pattern + + assertValidPattern(pattern) + + // Thanks to Yeting Li for + // improving this regexp to avoid a ReDOS vulnerability. + if (options.nobrace || !/\{(?:(?!\{).)*\}/.test(pattern)) { + // shortcut. no need to expand. + return [pattern] + } + + return expand(pattern) +} + +var MAX_PATTERN_LENGTH = 1024 * 64 +var assertValidPattern = function (pattern) { + if (typeof pattern !== 'string') { + throw new TypeError('invalid pattern') + } + + if (pattern.length > MAX_PATTERN_LENGTH) { + throw new TypeError('pattern is too long') + } +} + +// parse a component of the expanded set. +// At this point, no pattern may contain "/" in it +// so we're going to return a 2d array, where each entry is the full +// pattern, split on '/', and then turned into a regular expression. +// A regexp is made at the end which joins each array with an +// escaped /, and another full one which joins each regexp with |. +// +// Following the lead of Bash 4.1, note that "**" only has special meaning +// when it is the *only* thing in a path portion. Otherwise, any series +// of * is equivalent to a single *. Globstar behavior is enabled by +// default, and can be disabled by setting options.noglobstar. +Minimatch.prototype.parse = parse +var SUBPARSE = {} +function parse (pattern, isSub) { + assertValidPattern(pattern) + + var options = this.options + + // shortcuts + if (pattern === '**') { + if (!options.noglobstar) + return GLOBSTAR + else + pattern = '*' + } + if (pattern === '') return '' + + var re = '' + var hasMagic = !!options.nocase + var escaping = false + // ? => one single character + var patternListStack = [] + var negativeLists = [] + var stateChar + var inClass = false + var reClassStart = -1 + var classStart = -1 + // . and .. never match anything that doesn't start with ., + // even when options.dot is set. + var patternStart = pattern.charAt(0) === '.' ? '' // anything + // not (start or / followed by . or .. followed by / or end) + : options.dot ? '(?!(?:^|\\\/)\\.{1,2}(?:$|\\\/))' + : '(?!\\.)' + var self = this + + function clearStateChar () { + if (stateChar) { + // we had some state-tracking character + // that wasn't consumed by this pass. + switch (stateChar) { + case '*': + re += star + hasMagic = true + break + case '?': + re += qmark + hasMagic = true + break + default: + re += '\\' + stateChar + break + } + self.debug('clearStateChar %j %j', stateChar, re) + stateChar = false + } + } + + for (var i = 0, len = pattern.length, c + ; (i < len) && (c = pattern.charAt(i)) + ; i++) { + this.debug('%s\t%s %s %j', pattern, i, re, c) + + // skip over any that are escaped. + if (escaping && reSpecials[c]) { + re += '\\' + c + escaping = false + continue + } + + switch (c) { + /* istanbul ignore next */ + case '/': { + // completely not allowed, even escaped. + // Should already be path-split by now. + return false + } + + case '\\': + clearStateChar() + escaping = true + continue + + // the various stateChar values + // for the "extglob" stuff. + case '?': + case '*': + case '+': + case '@': + case '!': + this.debug('%s\t%s %s %j <-- stateChar', pattern, i, re, c) + + // all of those are literals inside a class, except that + // the glob [!a] means [^a] in regexp + if (inClass) { + this.debug(' in class') + if (c === '!' && i === classStart + 1) c = '^' + re += c + continue + } + + // if we already have a stateChar, then it means + // that there was something like ** or +? in there. + // Handle the stateChar, then proceed with this one. + self.debug('call clearStateChar %j', stateChar) + clearStateChar() + stateChar = c + // if extglob is disabled, then +(asdf|foo) isn't a thing. + // just clear the statechar *now*, rather than even diving into + // the patternList stuff. + if (options.noext) clearStateChar() + continue + + case '(': + if (inClass) { + re += '(' + continue + } + + if (!stateChar) { + re += '\\(' + continue + } + + patternListStack.push({ + type: stateChar, + start: i - 1, + reStart: re.length, + open: plTypes[stateChar].open, + close: plTypes[stateChar].close + }) + // negation is (?:(?!js)[^/]*) + re += stateChar === '!' ? '(?:(?!(?:' : '(?:' + this.debug('plType %j %j', stateChar, re) + stateChar = false + continue + + case ')': + if (inClass || !patternListStack.length) { + re += '\\)' + continue + } + + clearStateChar() + hasMagic = true + var pl = patternListStack.pop() + // negation is (?:(?!js)[^/]*) + // The others are (?:) + re += pl.close + if (pl.type === '!') { + negativeLists.push(pl) + } + pl.reEnd = re.length + continue + + case '|': + if (inClass || !patternListStack.length || escaping) { + re += '\\|' + escaping = false + continue + } + + clearStateChar() + re += '|' + continue + + // these are mostly the same in regexp and glob + case '[': + // swallow any state-tracking char before the [ + clearStateChar() + + if (inClass) { + re += '\\' + c + continue + } + + inClass = true + classStart = i + reClassStart = re.length + re += c + continue + + case ']': + // a right bracket shall lose its special + // meaning and represent itself in + // a bracket expression if it occurs + // first in the list. -- POSIX.2 2.8.3.2 + if (i === classStart + 1 || !inClass) { + re += '\\' + c + escaping = false + continue + } + + // handle the case where we left a class open. + // "[z-a]" is valid, equivalent to "\[z-a\]" + // split where the last [ was, make sure we don't have + // an invalid re. if so, re-walk the contents of the + // would-be class to re-translate any characters that + // were passed through as-is + // TODO: It would probably be faster to determine this + // without a try/catch and a new RegExp, but it's tricky + // to do safely. For now, this is safe and works. + var cs = pattern.substring(classStart + 1, i) + try { + RegExp('[' + cs + ']') + } catch (er) { + // not a valid class! + var sp = this.parse(cs, SUBPARSE) + re = re.substr(0, reClassStart) + '\\[' + sp[0] + '\\]' + hasMagic = hasMagic || sp[1] + inClass = false + continue + } + + // finish up the class. + hasMagic = true + inClass = false + re += c + continue + + default: + // swallow any state char that wasn't consumed + clearStateChar() + + if (escaping) { + // no need + escaping = false + } else if (reSpecials[c] + && !(c === '^' && inClass)) { + re += '\\' + } + + re += c + + } // switch + } // for + + // handle the case where we left a class open. + // "[abc" is valid, equivalent to "\[abc" + if (inClass) { + // split where the last [ was, and escape it + // this is a huge pita. We now have to re-walk + // the contents of the would-be class to re-translate + // any characters that were passed through as-is + cs = pattern.substr(classStart + 1) + sp = this.parse(cs, SUBPARSE) + re = re.substr(0, reClassStart) + '\\[' + sp[0] + hasMagic = hasMagic || sp[1] + } + + // handle the case where we had a +( thing at the *end* + // of the pattern. + // each pattern list stack adds 3 chars, and we need to go through + // and escape any | chars that were passed through as-is for the regexp. + // Go through and escape them, taking care not to double-escape any + // | chars that were already escaped. + for (pl = patternListStack.pop(); pl; pl = patternListStack.pop()) { + var tail = re.slice(pl.reStart + pl.open.length) + this.debug('setting tail', re, pl) + // maybe some even number of \, then maybe 1 \, followed by a | + tail = tail.replace(/((?:\\{2}){0,64})(\\?)\|/g, function (_, $1, $2) { + if (!$2) { + // the | isn't already escaped, so escape it. + $2 = '\\' + } + + // need to escape all those slashes *again*, without escaping the + // one that we need for escaping the | character. As it works out, + // escaping an even number of slashes can be done by simply repeating + // it exactly after itself. That's why this trick works. + // + // I am sorry that you have to see this. + return $1 + $1 + $2 + '|' + }) + + this.debug('tail=%j\n %s', tail, tail, pl, re) + var t = pl.type === '*' ? star + : pl.type === '?' ? qmark + : '\\' + pl.type + + hasMagic = true + re = re.slice(0, pl.reStart) + t + '\\(' + tail + } + + // handle trailing things that only matter at the very end. + clearStateChar() + if (escaping) { + // trailing \\ + re += '\\\\' + } + + // only need to apply the nodot start if the re starts with + // something that could conceivably capture a dot + var addPatternStart = false + switch (re.charAt(0)) { + case '[': case '.': case '(': addPatternStart = true + } + + // Hack to work around lack of negative lookbehind in JS + // A pattern like: *.!(x).!(y|z) needs to ensure that a name + // like 'a.xyz.yz' doesn't match. So, the first negative + // lookahead, has to look ALL the way ahead, to the end of + // the pattern. + for (var n = negativeLists.length - 1; n > -1; n--) { + var nl = negativeLists[n] + + var nlBefore = re.slice(0, nl.reStart) + var nlFirst = re.slice(nl.reStart, nl.reEnd - 8) + var nlLast = re.slice(nl.reEnd - 8, nl.reEnd) + var nlAfter = re.slice(nl.reEnd) + + nlLast += nlAfter + + // Handle nested stuff like *(*.js|!(*.json)), where open parens + // mean that we should *not* include the ) in the bit that is considered + // "after" the negated section. + var openParensBefore = nlBefore.split('(').length - 1 + var cleanAfter = nlAfter + for (i = 0; i < openParensBefore; i++) { + cleanAfter = cleanAfter.replace(/\)[+*?]?/, '') + } + nlAfter = cleanAfter + + var dollar = '' + if (nlAfter === '' && isSub !== SUBPARSE) { + dollar = '$' + } + var newRe = nlBefore + nlFirst + nlAfter + dollar + nlLast + re = newRe + } + + // if the re is not "" at this point, then we need to make sure + // it doesn't match against an empty path part. + // Otherwise a/* will match a/, which it should not. + if (re !== '' && hasMagic) { + re = '(?=.)' + re + } + + if (addPatternStart) { + re = patternStart + re + } + + // parsing just a piece of a larger pattern. + if (isSub === SUBPARSE) { + return [re, hasMagic] + } + + // skip the regexp for non-magical patterns + // unescape anything in it, though, so that it'll be + // an exact match against a file etc. + if (!hasMagic) { + return globUnescape(pattern) + } + + var flags = options.nocase ? 'i' : '' + try { + var regExp = new RegExp('^' + re + '$', flags) + } catch (er) /* istanbul ignore next - should be impossible */ { + // If it was an invalid regular expression, then it can't match + // anything. This trick looks for a character after the end of + // the string, which is of course impossible, except in multi-line + // mode, but it's not a /m regex. + return new RegExp('$.') + } + + regExp._glob = pattern + regExp._src = re + + return regExp +} + +minimatch.makeRe = function (pattern, options) { + return new Minimatch(pattern, options || {}).makeRe() +} + +Minimatch.prototype.makeRe = makeRe +function makeRe () { + if (this.regexp || this.regexp === false) return this.regexp + + // at this point, this.set is a 2d array of partial + // pattern strings, or "**". + // + // It's better to use .match(). This function shouldn't + // be used, really, but it's pretty convenient sometimes, + // when you just want to work with a regex. + var set = this.set + + if (!set.length) { + this.regexp = false + return this.regexp + } + var options = this.options + + var twoStar = options.noglobstar ? star + : options.dot ? twoStarDot + : twoStarNoDot + var flags = options.nocase ? 'i' : '' + + var re = set.map(function (pattern) { + return pattern.map(function (p) { + return (p === GLOBSTAR) ? twoStar + : (typeof p === 'string') ? regExpEscape(p) + : p._src + }).join('\\\/') + }).join('|') + + // must match entire pattern + // ending in a * or ** will make it less strict. + re = '^(?:' + re + ')$' + + // can match anything, as long as it's not this. + if (this.negate) re = '^(?!' + re + ').*$' + + try { + this.regexp = new RegExp(re, flags) + } catch (ex) /* istanbul ignore next - should be impossible */ { + this.regexp = false + } + return this.regexp +} + +minimatch.match = function (list, pattern, options) { + options = options || {} + var mm = new Minimatch(pattern, options) + list = list.filter(function (f) { + return mm.match(f) + }) + if (mm.options.nonull && !list.length) { + list.push(pattern) + } + return list +} + +Minimatch.prototype.match = function match (f, partial) { + if (typeof partial === 'undefined') partial = this.partial + this.debug('match', f, this.pattern) + // short-circuit in the case of busted things. + // comments, etc. + if (this.comment) return false + if (this.empty) return f === '' + + if (f === '/' && partial) return true + + var options = this.options + + // windows: need to use /, not \ + if (path.sep !== '/') { + f = f.split(path.sep).join('/') + } + + // treat the test path as a set of pathparts. + f = f.split(slashSplit) + this.debug(this.pattern, 'split', f) + + // just ONE of the pattern sets in this.set needs to match + // in order for it to be valid. If negating, then just one + // match means that we have failed. + // Either way, return on the first hit. + + var set = this.set + this.debug(this.pattern, 'set', set) + + // Find the basename of the path by looking for the last non-empty segment + var filename + var i + for (i = f.length - 1; i >= 0; i--) { + filename = f[i] + if (filename) break + } + + for (i = 0; i < set.length; i++) { + var pattern = set[i] + var file = f + if (options.matchBase && pattern.length === 1) { + file = [filename] + } + var hit = this.matchOne(file, pattern, partial) + if (hit) { + if (options.flipNegate) return true + return !this.negate + } + } + + // didn't get any hits. this is success if it's a negative + // pattern, failure otherwise. + if (options.flipNegate) return false + return this.negate +} + +// set partial to true to test if, for example, +// "/a/b" matches the start of "/*/b/*/d" +// Partial means, if you run out of file before you run +// out of pattern, then that's fine, as long as all +// the parts match. +Minimatch.prototype.matchOne = function (file, pattern, partial) { + var options = this.options + + this.debug('matchOne', + { 'this': this, file: file, pattern: pattern }) + + this.debug('matchOne', file.length, pattern.length) + + for (var fi = 0, + pi = 0, + fl = file.length, + pl = pattern.length + ; (fi < fl) && (pi < pl) + ; fi++, pi++) { + this.debug('matchOne loop') + var p = pattern[pi] + var f = file[fi] + + this.debug(pattern, p, f) + + // should be impossible. + // some invalid regexp stuff in the set. + /* istanbul ignore if */ + if (p === false) return false + + if (p === GLOBSTAR) { + this.debug('GLOBSTAR', [pattern, p, f]) + + // "**" + // a/**/b/**/c would match the following: + // a/b/x/y/z/c + // a/x/y/z/b/c + // a/b/x/b/x/c + // a/b/c + // To do this, take the rest of the pattern after + // the **, and see if it would match the file remainder. + // If so, return success. + // If not, the ** "swallows" a segment, and try again. + // This is recursively awful. + // + // a/**/b/**/c matching a/b/x/y/z/c + // - a matches a + // - doublestar + // - matchOne(b/x/y/z/c, b/**/c) + // - b matches b + // - doublestar + // - matchOne(x/y/z/c, c) -> no + // - matchOne(y/z/c, c) -> no + // - matchOne(z/c, c) -> no + // - matchOne(c, c) yes, hit + var fr = fi + var pr = pi + 1 + if (pr === pl) { + this.debug('** at the end') + // a ** at the end will just swallow the rest. + // We have found a match. + // however, it will not swallow /.x, unless + // options.dot is set. + // . and .. are *never* matched by **, for explosively + // exponential reasons. + for (; fi < fl; fi++) { + if (file[fi] === '.' || file[fi] === '..' || + (!options.dot && file[fi].charAt(0) === '.')) return false + } + return true + } + + // ok, let's see if we can swallow whatever we can. + while (fr < fl) { + var swallowee = file[fr] + + this.debug('\nglobstar while', file, fr, pattern, pr, swallowee) + + // XXX remove this slice. Just pass the start index. + if (this.matchOne(file.slice(fr), pattern.slice(pr), partial)) { + this.debug('globstar found match!', fr, fl, swallowee) + // found a match. + return true + } else { + // can't swallow "." or ".." ever. + // can only swallow ".foo" when explicitly asked. + if (swallowee === '.' || swallowee === '..' || + (!options.dot && swallowee.charAt(0) === '.')) { + this.debug('dot detected!', file, fr, pattern, pr) + break + } + + // ** swallows a segment, and continue. + this.debug('globstar swallow a segment, and continue') + fr++ + } + } + + // no match was found. + // However, in partial mode, we can't say this is necessarily over. + // If there's more *pattern* left, then + /* istanbul ignore if */ + if (partial) { + // ran out of file + this.debug('\n>>> no match, partial?', file, fr, pattern, pr) + if (fr === fl) return true + } + return false + } + + // something other than ** + // non-magic patterns just have to match exactly + // patterns with magic have been turned into regexps. + var hit + if (typeof p === 'string') { + hit = f === p + this.debug('string match', p, f, hit) + } else { + hit = f.match(p) + this.debug('pattern match', p, f, hit) + } + + if (!hit) return false + } + + // Note: ending in / means that we'll get a final "" + // at the end of the pattern. This can only match a + // corresponding "" at the end of the file. + // If the file ends in /, then it can only match a + // a pattern that ends in /, unless the pattern just + // doesn't have any more for it. But, a/b/ should *not* + // match "a/b/*", even though "" matches against the + // [^/]*? pattern, except in partial mode, where it might + // simply not be reached yet. + // However, a/b/ should still satisfy a/* + + // now either we fell off the end of the pattern, or we're done. + if (fi === fl && pi === pl) { + // ran out of pattern and filename at the same time. + // an exact hit! + return true + } else if (fi === fl) { + // ran out of file, but still had pattern left. + // this is ok if we're doing the match as part of + // a glob fs traversal. + return partial + } else /* istanbul ignore else */ if (pi === pl) { + // ran out of pattern, still have file left. + // this is only acceptable if we're on the very last + // empty segment of a file with a trailing slash. + // a/* should match a/b/ + return (fi === fl - 1) && (file[fi] === '') + } + + // should be unreachable. + /* istanbul ignore next */ + throw new Error('wtf?') +} + +// replace stuff like \* with * +function globUnescape (s) { + return s.replace(/\\(.)/g, '$1') +} + +function regExpEscape (s) { + return s.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, '\\$&') +} + + +/***/ }), + +/***/ 467: +/***/ ((module, exports, __nccwpck_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(__nccwpck_require__(2781)); +var http = _interopDefault(__nccwpck_require__(3685)); +var Url = _interopDefault(__nccwpck_require__(7310)); +var whatwgUrl = _interopDefault(__nccwpck_require__(8665)); +var https = _interopDefault(__nccwpck_require__(5687)); +var zlib = _interopDefault(__nccwpck_require__(9796)); + +// 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 = (__nccwpck_require__(2877).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'); +const URL = Url.URL || whatwgUrl.URL; + +// fix an issue where "format", "parse" aren't a named export for node <10 +const parse_url = Url.parse; +const format_url = Url.format; + +/** + * Wrapper around `new URL` to handle arbitrary URLs + * + * @param {string} urlStr + * @return {void} + */ +function parseURL(urlStr) { + /* + Check whether the URL is absolute or not + Scheme: https://tools.ietf.org/html/rfc3986#section-3.1 + Absolute URL: https://tools.ietf.org/html/rfc3986#section-4.3 + */ + if (/^[a-zA-Z][a-zA-Z\d+\-.]*:/.exec(urlStr)) { + urlStr = new URL(urlStr).toString(); + } + + // Fallback to old implementation for arbitrary URLs + return parse_url(urlStr); +} + +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 = parseURL(input.href); + } else { + // coerce input to a string before attempting to parse + parsedURL = parseURL(`${input}`); + } + input = {}; + } else { + parsedURL = parseURL(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'; + +const URL$1 = Url.URL || whatwgUrl.URL; + +// fix an issue where "PassThrough", "resolve" aren't a named export for node <10 +const PassThrough$1 = Stream.PassThrough; + +const isDomainOrSubdomain = function isDomainOrSubdomain(destination, original) { + const orig = new URL$1(original).hostname; + const dest = new URL$1(destination).hostname; + + return orig === dest || orig[orig.length - dest.length - 1] === '.' && orig.endsWith(dest); +}; + +/** + * isSameProtocol reports whether the two provided URLs use the same protocol. + * + * Both domains must already be in canonical form. + * @param {string|URL} original + * @param {string|URL} destination + */ +const isSameProtocol = function isSameProtocol(destination, original) { + const orig = new URL$1(original).protocol; + const dest = new URL$1(destination).protocol; + + return orig === dest; +}; + +/** + * 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) { + destroyStream(request.body, 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)); + + if (response && response.body) { + destroyStream(response.body, err); + } + + finalize(); + }); + + fixResponseChunkedTransferBadEnding(req, function (err) { + if (signal && signal.aborted) { + return; + } + + if (response && response.body) { + destroyStream(response.body, err); + } + }); + + /* c8 ignore next 18 */ + if (parseInt(process.version.substring(1)) < 14) { + // Before Node.js 14, pipeline() does not fully support async iterators and does not always + // properly handle when the socket close/end events are out of order. + req.on('socket', function (s) { + s.addListener('close', function (hadError) { + // if a data listener is still present we didn't end cleanly + const hasDataListener = s.listenerCount('data') > 0; + + // if end happened before close but the socket didn't emit an error, do it now + if (response && hasDataListener && !hadError && !(signal && signal.aborted)) { + const err = new Error('Premature close'); + err.code = 'ERR_STREAM_PREMATURE_CLOSE'; + response.body.emit('error', err); + } + }); + }); + } + + 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 + let locationURL = null; + try { + locationURL = location === null ? null : new URL$1(location, request.url).toString(); + } catch (err) { + // error here can only be invalid URL in Location: header + // do not throw when options.redirect == manual + // let the user extract the errorneous redirect URL + if (request.redirect !== 'manual') { + reject(new FetchError(`uri requested responds with an invalid redirect URL: ${location}`, 'invalid-redirect')); + finalize(); + return; + } + } + + // HTTP fetch step 5.5 + switch (request.redirect) { + case 'error': + reject(new FetchError(`uri requested responds with a redirect, redirect mode is set to error: ${request.url}`, 'no-redirect')); + finalize(); + return; + case 'manual': + // node-fetch-specific step: make manual redirect a bit easier to use by setting the Location header value to the resolved URL. + if (locationURL !== null) { + // handle corrupted header + try { + headers.set('Location', locationURL); + } catch (err) { + // istanbul ignore next: nodejs server prevent invalid response headers, we can't test this through normal request + reject(err); + } + } + break; + case 'follow': + // HTTP-redirect fetch step 2 + if (locationURL === null) { + break; + } + + // HTTP-redirect fetch step 5 + if (request.counter >= request.follow) { + reject(new FetchError(`maximum redirect reached at: ${request.url}`, 'max-redirect')); + finalize(); + return; + } + + // HTTP-redirect fetch step 6 (counter increment) + // Create a new Request object. + const requestOpts = { + headers: new Headers(request.headers), + follow: request.follow, + counter: request.counter + 1, + agent: request.agent, + compress: request.compress, + method: request.method, + body: request.body, + signal: request.signal, + timeout: request.timeout, + size: request.size + }; + + if (!isDomainOrSubdomain(request.url, locationURL) || !isSameProtocol(request.url, locationURL)) { + for (const name of ['authorization', 'www-authenticate', 'cookie', 'cookie2']) { + requestOpts.headers.delete(name); + } + } + + // 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); + }); + raw.on('end', function () { + // some old IIS servers return zero-length OK deflate responses, so 'data' is never emitted. + if (!response) { + 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); + }); +} +function fixResponseChunkedTransferBadEnding(request, errorCallback) { + let socket; + + request.on('socket', function (s) { + socket = s; + }); + + request.on('response', function (response) { + const headers = response.headers; + + if (headers['transfer-encoding'] === 'chunked' && !headers['content-length']) { + response.once('close', function (hadError) { + // if a data listener is still present we didn't end cleanly + const hasDataListener = socket.listenerCount('data') > 0; + + if (hasDataListener && !hadError) { + const err = new Error('Premature close'); + err.code = 'ERR_STREAM_PREMATURE_CLOSE'; + errorCallback(err); + } + }); + } + }); +} + +function destroyStream(stream, err) { + if (stream.destroy) { + stream.destroy(err); + } else { + // node < 8 + stream.emit('error', err); + stream.end(); + } +} + +/** + * 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; + + +/***/ }), + +/***/ 1223: +/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { + +var wrappy = __nccwpck_require__(2940) +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 +} + + +/***/ }), + +/***/ 4256: +/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { + +"use strict"; + + +var punycode = __nccwpck_require__(5477); +var mappingTable = __nccwpck_require__(2020); + +var PROCESSING_OPTIONS = { + TRANSITIONAL: 0, + NONTRANSITIONAL: 1 +}; + +function normalize(str) { // fix bug in v8 + return str.split('\u0000').map(function (s) { return s.normalize('NFC'); }).join('\u0000'); +} + +function findStatus(val) { + var start = 0; + var end = mappingTable.length - 1; + + while (start <= end) { + var mid = Math.floor((start + end) / 2); + + var target = mappingTable[mid]; + if (target[0][0] <= val && target[0][1] >= val) { + return target; + } else if (target[0][0] > val) { + end = mid - 1; + } else { + start = mid + 1; + } + } + + return null; +} + +var regexAstralSymbols = /[\uD800-\uDBFF][\uDC00-\uDFFF]/g; + +function countSymbols(string) { + return string + // replace every surrogate pair with a BMP symbol + .replace(regexAstralSymbols, '_') + // then get the length + .length; +} + +function mapChars(domain_name, useSTD3, processing_option) { + var hasError = false; + var processed = ""; + + var len = countSymbols(domain_name); + for (var i = 0; i < len; ++i) { + var codePoint = domain_name.codePointAt(i); + var status = findStatus(codePoint); + + switch (status[1]) { + case "disallowed": + hasError = true; + processed += String.fromCodePoint(codePoint); + break; + case "ignored": + break; + case "mapped": + processed += String.fromCodePoint.apply(String, status[2]); + break; + case "deviation": + if (processing_option === PROCESSING_OPTIONS.TRANSITIONAL) { + processed += String.fromCodePoint.apply(String, status[2]); + } else { + processed += String.fromCodePoint(codePoint); + } + break; + case "valid": + processed += String.fromCodePoint(codePoint); + break; + case "disallowed_STD3_mapped": + if (useSTD3) { + hasError = true; + processed += String.fromCodePoint(codePoint); + } else { + processed += String.fromCodePoint.apply(String, status[2]); + } + break; + case "disallowed_STD3_valid": + if (useSTD3) { + hasError = true; + } + + processed += String.fromCodePoint(codePoint); + break; + } + } + + return { + string: processed, + error: hasError + }; +} + +var combiningMarksRegex = /[\u0300-\u036F\u0483-\u0489\u0591-\u05BD\u05BF\u05C1\u05C2\u05C4\u05C5\u05C7\u0610-\u061A\u064B-\u065F\u0670\u06D6-\u06DC\u06DF-\u06E4\u06E7\u06E8\u06EA-\u06ED\u0711\u0730-\u074A\u07A6-\u07B0\u07EB-\u07F3\u0816-\u0819\u081B-\u0823\u0825-\u0827\u0829-\u082D\u0859-\u085B\u08E4-\u0903\u093A-\u093C\u093E-\u094F\u0951-\u0957\u0962\u0963\u0981-\u0983\u09BC\u09BE-\u09C4\u09C7\u09C8\u09CB-\u09CD\u09D7\u09E2\u09E3\u0A01-\u0A03\u0A3C\u0A3E-\u0A42\u0A47\u0A48\u0A4B-\u0A4D\u0A51\u0A70\u0A71\u0A75\u0A81-\u0A83\u0ABC\u0ABE-\u0AC5\u0AC7-\u0AC9\u0ACB-\u0ACD\u0AE2\u0AE3\u0B01-\u0B03\u0B3C\u0B3E-\u0B44\u0B47\u0B48\u0B4B-\u0B4D\u0B56\u0B57\u0B62\u0B63\u0B82\u0BBE-\u0BC2\u0BC6-\u0BC8\u0BCA-\u0BCD\u0BD7\u0C00-\u0C03\u0C3E-\u0C44\u0C46-\u0C48\u0C4A-\u0C4D\u0C55\u0C56\u0C62\u0C63\u0C81-\u0C83\u0CBC\u0CBE-\u0CC4\u0CC6-\u0CC8\u0CCA-\u0CCD\u0CD5\u0CD6\u0CE2\u0CE3\u0D01-\u0D03\u0D3E-\u0D44\u0D46-\u0D48\u0D4A-\u0D4D\u0D57\u0D62\u0D63\u0D82\u0D83\u0DCA\u0DCF-\u0DD4\u0DD6\u0DD8-\u0DDF\u0DF2\u0DF3\u0E31\u0E34-\u0E3A\u0E47-\u0E4E\u0EB1\u0EB4-\u0EB9\u0EBB\u0EBC\u0EC8-\u0ECD\u0F18\u0F19\u0F35\u0F37\u0F39\u0F3E\u0F3F\u0F71-\u0F84\u0F86\u0F87\u0F8D-\u0F97\u0F99-\u0FBC\u0FC6\u102B-\u103E\u1056-\u1059\u105E-\u1060\u1062-\u1064\u1067-\u106D\u1071-\u1074\u1082-\u108D\u108F\u109A-\u109D\u135D-\u135F\u1712-\u1714\u1732-\u1734\u1752\u1753\u1772\u1773\u17B4-\u17D3\u17DD\u180B-\u180D\u18A9\u1920-\u192B\u1930-\u193B\u19B0-\u19C0\u19C8\u19C9\u1A17-\u1A1B\u1A55-\u1A5E\u1A60-\u1A7C\u1A7F\u1AB0-\u1ABE\u1B00-\u1B04\u1B34-\u1B44\u1B6B-\u1B73\u1B80-\u1B82\u1BA1-\u1BAD\u1BE6-\u1BF3\u1C24-\u1C37\u1CD0-\u1CD2\u1CD4-\u1CE8\u1CED\u1CF2-\u1CF4\u1CF8\u1CF9\u1DC0-\u1DF5\u1DFC-\u1DFF\u20D0-\u20F0\u2CEF-\u2CF1\u2D7F\u2DE0-\u2DFF\u302A-\u302F\u3099\u309A\uA66F-\uA672\uA674-\uA67D\uA69F\uA6F0\uA6F1\uA802\uA806\uA80B\uA823-\uA827\uA880\uA881\uA8B4-\uA8C4\uA8E0-\uA8F1\uA926-\uA92D\uA947-\uA953\uA980-\uA983\uA9B3-\uA9C0\uA9E5\uAA29-\uAA36\uAA43\uAA4C\uAA4D\uAA7B-\uAA7D\uAAB0\uAAB2-\uAAB4\uAAB7\uAAB8\uAABE\uAABF\uAAC1\uAAEB-\uAAEF\uAAF5\uAAF6\uABE3-\uABEA\uABEC\uABED\uFB1E\uFE00-\uFE0F\uFE20-\uFE2D]|\uD800[\uDDFD\uDEE0\uDF76-\uDF7A]|\uD802[\uDE01-\uDE03\uDE05\uDE06\uDE0C-\uDE0F\uDE38-\uDE3A\uDE3F\uDEE5\uDEE6]|\uD804[\uDC00-\uDC02\uDC38-\uDC46\uDC7F-\uDC82\uDCB0-\uDCBA\uDD00-\uDD02\uDD27-\uDD34\uDD73\uDD80-\uDD82\uDDB3-\uDDC0\uDE2C-\uDE37\uDEDF-\uDEEA\uDF01-\uDF03\uDF3C\uDF3E-\uDF44\uDF47\uDF48\uDF4B-\uDF4D\uDF57\uDF62\uDF63\uDF66-\uDF6C\uDF70-\uDF74]|\uD805[\uDCB0-\uDCC3\uDDAF-\uDDB5\uDDB8-\uDDC0\uDE30-\uDE40\uDEAB-\uDEB7]|\uD81A[\uDEF0-\uDEF4\uDF30-\uDF36]|\uD81B[\uDF51-\uDF7E\uDF8F-\uDF92]|\uD82F[\uDC9D\uDC9E]|\uD834[\uDD65-\uDD69\uDD6D-\uDD72\uDD7B-\uDD82\uDD85-\uDD8B\uDDAA-\uDDAD\uDE42-\uDE44]|\uD83A[\uDCD0-\uDCD6]|\uDB40[\uDD00-\uDDEF]/; + +function validateLabel(label, processing_option) { + if (label.substr(0, 4) === "xn--") { + label = punycode.toUnicode(label); + processing_option = PROCESSING_OPTIONS.NONTRANSITIONAL; + } + + var error = false; + + if (normalize(label) !== label || + (label[3] === "-" && label[4] === "-") || + label[0] === "-" || label[label.length - 1] === "-" || + label.indexOf(".") !== -1 || + label.search(combiningMarksRegex) === 0) { + error = true; + } + + var len = countSymbols(label); + for (var i = 0; i < len; ++i) { + var status = findStatus(label.codePointAt(i)); + if ((processing === PROCESSING_OPTIONS.TRANSITIONAL && status[1] !== "valid") || + (processing === PROCESSING_OPTIONS.NONTRANSITIONAL && + status[1] !== "valid" && status[1] !== "deviation")) { + error = true; + break; + } + } + + return { + label: label, + error: error + }; +} + +function processing(domain_name, useSTD3, processing_option) { + var result = mapChars(domain_name, useSTD3, processing_option); + result.string = normalize(result.string); + + var labels = result.string.split("."); + for (var i = 0; i < labels.length; ++i) { + try { + var validation = validateLabel(labels[i]); + labels[i] = validation.label; + result.error = result.error || validation.error; + } catch(e) { + result.error = true; + } + } + + return { + string: labels.join("."), + error: result.error + }; +} + +module.exports.toASCII = function(domain_name, useSTD3, processing_option, verifyDnsLength) { + var result = processing(domain_name, useSTD3, processing_option); + var labels = result.string.split("."); + labels = labels.map(function(l) { + try { + return punycode.toASCII(l); + } catch(e) { + result.error = true; + return l; + } + }); + + if (verifyDnsLength) { + var total = labels.slice(0, labels.length - 1).join(".").length; + if (total.length > 253 || total.length === 0) { + result.error = true; + } + + for (var i=0; i < labels.length; ++i) { + if (labels.length > 63 || labels.length === 0) { + result.error = true; + break; + } + } + } + + if (result.error) return null; + return labels.join("."); +}; + +module.exports.toUnicode = function(domain_name, useSTD3) { + var result = processing(domain_name, useSTD3, PROCESSING_OPTIONS.NONTRANSITIONAL); + + return { + domain: result.string, + error: result.error + }; +}; + +module.exports.PROCESSING_OPTIONS = PROCESSING_OPTIONS; + + +/***/ }), + +/***/ 4294: +/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { + +module.exports = __nccwpck_require__(4219); + + +/***/ }), + +/***/ 4219: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + + +var net = __nccwpck_require__(1808); +var tls = __nccwpck_require__(4404); +var http = __nccwpck_require__(3685); +var https = __nccwpck_require__(5687); +var events = __nccwpck_require__(2361); +var assert = __nccwpck_require__(9491); +var util = __nccwpck_require__(3837); + + +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 + + +/***/ }), + +/***/ 5030: +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + + +Object.defineProperty(exports, "__esModule", ({ value: true })); + +function getUserAgent() { + if (typeof navigator === "object" && "userAgent" in navigator) { + return navigator.userAgent; + } + + if (typeof process === "object" && "version" in process) { + return `Node.js/${process.version.substr(1)} (${process.platform}; ${process.arch})`; + } + + return ""; +} + +exports.getUserAgent = getUserAgent; +//# sourceMappingURL=index.js.map + + +/***/ }), + +/***/ 5840: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + + +Object.defineProperty(exports, "__esModule", ({ + value: true +})); +Object.defineProperty(exports, "v1", ({ + enumerable: true, + get: function () { + return _v.default; + } +})); +Object.defineProperty(exports, "v3", ({ + enumerable: true, + get: function () { + return _v2.default; + } +})); +Object.defineProperty(exports, "v4", ({ + enumerable: true, + get: function () { + return _v3.default; + } +})); +Object.defineProperty(exports, "v5", ({ + enumerable: true, + get: function () { + return _v4.default; + } +})); +Object.defineProperty(exports, "NIL", ({ + enumerable: true, + get: function () { + return _nil.default; + } +})); +Object.defineProperty(exports, "version", ({ + enumerable: true, + get: function () { + return _version.default; + } +})); +Object.defineProperty(exports, "validate", ({ + enumerable: true, + get: function () { + return _validate.default; + } +})); +Object.defineProperty(exports, "stringify", ({ + enumerable: true, + get: function () { + return _stringify.default; + } +})); +Object.defineProperty(exports, "parse", ({ + enumerable: true, + get: function () { + return _parse.default; + } +})); + +var _v = _interopRequireDefault(__nccwpck_require__(8628)); + +var _v2 = _interopRequireDefault(__nccwpck_require__(6409)); + +var _v3 = _interopRequireDefault(__nccwpck_require__(5122)); + +var _v4 = _interopRequireDefault(__nccwpck_require__(9120)); + +var _nil = _interopRequireDefault(__nccwpck_require__(5332)); + +var _version = _interopRequireDefault(__nccwpck_require__(1595)); + +var _validate = _interopRequireDefault(__nccwpck_require__(6900)); + +var _stringify = _interopRequireDefault(__nccwpck_require__(8950)); + +var _parse = _interopRequireDefault(__nccwpck_require__(2746)); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +/***/ }), + +/***/ 4569: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + + +Object.defineProperty(exports, "__esModule", ({ + value: true +})); +exports["default"] = void 0; + +var _crypto = _interopRequireDefault(__nccwpck_require__(6113)); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +function md5(bytes) { + if (Array.isArray(bytes)) { + bytes = Buffer.from(bytes); + } else if (typeof bytes === 'string') { + bytes = Buffer.from(bytes, 'utf8'); + } + + return _crypto.default.createHash('md5').update(bytes).digest(); +} + +var _default = md5; +exports["default"] = _default; + +/***/ }), + +/***/ 5332: +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + + +Object.defineProperty(exports, "__esModule", ({ + value: true +})); +exports["default"] = void 0; +var _default = '00000000-0000-0000-0000-000000000000'; +exports["default"] = _default; + +/***/ }), + +/***/ 2746: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + + +Object.defineProperty(exports, "__esModule", ({ + value: true +})); +exports["default"] = void 0; + +var _validate = _interopRequireDefault(__nccwpck_require__(6900)); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +function parse(uuid) { + if (!(0, _validate.default)(uuid)) { + throw TypeError('Invalid UUID'); + } + + let v; + const arr = new Uint8Array(16); // Parse ########-....-....-....-............ + + arr[0] = (v = parseInt(uuid.slice(0, 8), 16)) >>> 24; + arr[1] = v >>> 16 & 0xff; + arr[2] = v >>> 8 & 0xff; + arr[3] = v & 0xff; // Parse ........-####-....-....-............ + + arr[4] = (v = parseInt(uuid.slice(9, 13), 16)) >>> 8; + arr[5] = v & 0xff; // Parse ........-....-####-....-............ + + arr[6] = (v = parseInt(uuid.slice(14, 18), 16)) >>> 8; + arr[7] = v & 0xff; // Parse ........-....-....-####-............ + + arr[8] = (v = parseInt(uuid.slice(19, 23), 16)) >>> 8; + arr[9] = v & 0xff; // Parse ........-....-....-....-############ + // (Use "/" to avoid 32-bit truncation when bit-shifting high-order bytes) + + arr[10] = (v = parseInt(uuid.slice(24, 36), 16)) / 0x10000000000 & 0xff; + arr[11] = v / 0x100000000 & 0xff; + arr[12] = v >>> 24 & 0xff; + arr[13] = v >>> 16 & 0xff; + arr[14] = v >>> 8 & 0xff; + arr[15] = v & 0xff; + return arr; +} + +var _default = parse; +exports["default"] = _default; + +/***/ }), + +/***/ 814: +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + + +Object.defineProperty(exports, "__esModule", ({ + value: true +})); +exports["default"] = void 0; +var _default = /^(?:[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}|00000000-0000-0000-0000-000000000000)$/i; +exports["default"] = _default; + +/***/ }), + +/***/ 807: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + + +Object.defineProperty(exports, "__esModule", ({ + value: true +})); +exports["default"] = rng; + +var _crypto = _interopRequireDefault(__nccwpck_require__(6113)); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +const rnds8Pool = new Uint8Array(256); // # of random values to pre-allocate + +let poolPtr = rnds8Pool.length; + +function rng() { + if (poolPtr > rnds8Pool.length - 16) { + _crypto.default.randomFillSync(rnds8Pool); + + poolPtr = 0; + } + + return rnds8Pool.slice(poolPtr, poolPtr += 16); +} + +/***/ }), + +/***/ 5274: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + + +Object.defineProperty(exports, "__esModule", ({ + value: true +})); +exports["default"] = void 0; + +var _crypto = _interopRequireDefault(__nccwpck_require__(6113)); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +function sha1(bytes) { + if (Array.isArray(bytes)) { + bytes = Buffer.from(bytes); + } else if (typeof bytes === 'string') { + bytes = Buffer.from(bytes, 'utf8'); + } + + return _crypto.default.createHash('sha1').update(bytes).digest(); +} + +var _default = sha1; +exports["default"] = _default; + +/***/ }), + +/***/ 8950: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + + +Object.defineProperty(exports, "__esModule", ({ + value: true +})); +exports["default"] = void 0; + +var _validate = _interopRequireDefault(__nccwpck_require__(6900)); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +/** + * Convert array of 16 byte values to UUID string format of the form: + * XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX + */ +const byteToHex = []; + +for (let i = 0; i < 256; ++i) { + byteToHex.push((i + 0x100).toString(16).substr(1)); +} + +function stringify(arr, offset = 0) { + // Note: Be careful editing this code! It's been tuned for performance + // and works in ways you may not expect. See https://github.com/uuidjs/uuid/pull/434 + const uuid = (byteToHex[arr[offset + 0]] + byteToHex[arr[offset + 1]] + byteToHex[arr[offset + 2]] + byteToHex[arr[offset + 3]] + '-' + byteToHex[arr[offset + 4]] + byteToHex[arr[offset + 5]] + '-' + byteToHex[arr[offset + 6]] + byteToHex[arr[offset + 7]] + '-' + byteToHex[arr[offset + 8]] + byteToHex[arr[offset + 9]] + '-' + byteToHex[arr[offset + 10]] + byteToHex[arr[offset + 11]] + byteToHex[arr[offset + 12]] + byteToHex[arr[offset + 13]] + byteToHex[arr[offset + 14]] + byteToHex[arr[offset + 15]]).toLowerCase(); // Consistency check for valid UUID. If this throws, it's likely due to one + // of the following: + // - One or more input array values don't map to a hex octet (leading to + // "undefined" in the uuid) + // - Invalid input values for the RFC `version` or `variant` fields + + if (!(0, _validate.default)(uuid)) { + throw TypeError('Stringified UUID is invalid'); + } + + return uuid; +} + +var _default = stringify; +exports["default"] = _default; + +/***/ }), + +/***/ 8628: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + + +Object.defineProperty(exports, "__esModule", ({ + value: true +})); +exports["default"] = void 0; + +var _rng = _interopRequireDefault(__nccwpck_require__(807)); + +var _stringify = _interopRequireDefault(__nccwpck_require__(8950)); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +// **`v1()` - Generate time-based UUID** +// +// Inspired by https://github.com/LiosK/UUID.js +// and http://docs.python.org/library/uuid.html +let _nodeId; + +let _clockseq; // Previous uuid creation time + + +let _lastMSecs = 0; +let _lastNSecs = 0; // See https://github.com/uuidjs/uuid for API details + +function v1(options, buf, offset) { + let i = buf && offset || 0; + const b = buf || new Array(16); + options = options || {}; + let node = options.node || _nodeId; + let clockseq = options.clockseq !== undefined ? options.clockseq : _clockseq; // node and clockseq need to be initialized to random values if they're not + // specified. We do this lazily to minimize issues related to insufficient + // system entropy. See #189 + + if (node == null || clockseq == null) { + const seedBytes = options.random || (options.rng || _rng.default)(); + + if (node == null) { + // Per 4.5, create and 48-bit node id, (47 random bits + multicast bit = 1) + node = _nodeId = [seedBytes[0] | 0x01, seedBytes[1], seedBytes[2], seedBytes[3], seedBytes[4], seedBytes[5]]; + } + + if (clockseq == null) { + // Per 4.2.2, randomize (14 bit) clockseq + clockseq = _clockseq = (seedBytes[6] << 8 | seedBytes[7]) & 0x3fff; + } + } // UUID timestamps are 100 nano-second units since the Gregorian epoch, + // (1582-10-15 00:00). JSNumbers aren't precise enough for this, so + // time is handled internally as 'msecs' (integer milliseconds) and 'nsecs' + // (100-nanoseconds offset from msecs) since unix epoch, 1970-01-01 00:00. + + + let msecs = options.msecs !== undefined ? options.msecs : Date.now(); // Per 4.2.1.2, use count of uuid's generated during the current clock + // cycle to simulate higher resolution clock + + let nsecs = options.nsecs !== undefined ? options.nsecs : _lastNSecs + 1; // Time since last uuid creation (in msecs) + + const dt = msecs - _lastMSecs + (nsecs - _lastNSecs) / 10000; // Per 4.2.1.2, Bump clockseq on clock regression + + if (dt < 0 && options.clockseq === undefined) { + clockseq = clockseq + 1 & 0x3fff; + } // Reset nsecs if clock regresses (new clockseq) or we've moved onto a new + // time interval + + + if ((dt < 0 || msecs > _lastMSecs) && options.nsecs === undefined) { + nsecs = 0; + } // Per 4.2.1.2 Throw error if too many uuids are requested + + + if (nsecs >= 10000) { + throw new Error("uuid.v1(): Can't create more than 10M uuids/sec"); + } + + _lastMSecs = msecs; + _lastNSecs = nsecs; + _clockseq = clockseq; // Per 4.1.4 - Convert from unix epoch to Gregorian epoch + + msecs += 12219292800000; // `time_low` + + const tl = ((msecs & 0xfffffff) * 10000 + nsecs) % 0x100000000; + b[i++] = tl >>> 24 & 0xff; + b[i++] = tl >>> 16 & 0xff; + b[i++] = tl >>> 8 & 0xff; + b[i++] = tl & 0xff; // `time_mid` + + const tmh = msecs / 0x100000000 * 10000 & 0xfffffff; + b[i++] = tmh >>> 8 & 0xff; + b[i++] = tmh & 0xff; // `time_high_and_version` + + b[i++] = tmh >>> 24 & 0xf | 0x10; // include version + + b[i++] = tmh >>> 16 & 0xff; // `clock_seq_hi_and_reserved` (Per 4.2.2 - include variant) + + b[i++] = clockseq >>> 8 | 0x80; // `clock_seq_low` + + b[i++] = clockseq & 0xff; // `node` + + for (let n = 0; n < 6; ++n) { + b[i + n] = node[n]; + } + + return buf || (0, _stringify.default)(b); +} + +var _default = v1; +exports["default"] = _default; + +/***/ }), + +/***/ 6409: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + + +Object.defineProperty(exports, "__esModule", ({ + value: true +})); +exports["default"] = void 0; + +var _v = _interopRequireDefault(__nccwpck_require__(5998)); + +var _md = _interopRequireDefault(__nccwpck_require__(4569)); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +const v3 = (0, _v.default)('v3', 0x30, _md.default); +var _default = v3; +exports["default"] = _default; + +/***/ }), + +/***/ 5998: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + + +Object.defineProperty(exports, "__esModule", ({ + value: true +})); +exports["default"] = _default; +exports.URL = exports.DNS = void 0; + +var _stringify = _interopRequireDefault(__nccwpck_require__(8950)); + +var _parse = _interopRequireDefault(__nccwpck_require__(2746)); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +function stringToBytes(str) { + str = unescape(encodeURIComponent(str)); // UTF8 escape + + const bytes = []; + + for (let i = 0; i < str.length; ++i) { + bytes.push(str.charCodeAt(i)); + } + + return bytes; +} + +const DNS = '6ba7b810-9dad-11d1-80b4-00c04fd430c8'; +exports.DNS = DNS; +const URL = '6ba7b811-9dad-11d1-80b4-00c04fd430c8'; +exports.URL = URL; + +function _default(name, version, hashfunc) { + function generateUUID(value, namespace, buf, offset) { + if (typeof value === 'string') { + value = stringToBytes(value); + } + + if (typeof namespace === 'string') { + namespace = (0, _parse.default)(namespace); + } + + if (namespace.length !== 16) { + throw TypeError('Namespace must be array-like (16 iterable integer values, 0-255)'); + } // Compute hash of namespace and value, Per 4.3 + // Future: Use spread syntax when supported on all platforms, e.g. `bytes = + // hashfunc([...namespace, ... value])` + + + let bytes = new Uint8Array(16 + value.length); + bytes.set(namespace); + bytes.set(value, namespace.length); + bytes = hashfunc(bytes); + bytes[6] = bytes[6] & 0x0f | version; + bytes[8] = bytes[8] & 0x3f | 0x80; + + if (buf) { + offset = offset || 0; + + for (let i = 0; i < 16; ++i) { + buf[offset + i] = bytes[i]; + } + + return buf; + } + + return (0, _stringify.default)(bytes); + } // Function#name is not settable on some platforms (#270) + + + try { + generateUUID.name = name; // eslint-disable-next-line no-empty + } catch (err) {} // For CommonJS default export support + + + generateUUID.DNS = DNS; + generateUUID.URL = URL; + return generateUUID; +} + +/***/ }), + +/***/ 5122: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + + +Object.defineProperty(exports, "__esModule", ({ + value: true +})); +exports["default"] = void 0; + +var _rng = _interopRequireDefault(__nccwpck_require__(807)); + +var _stringify = _interopRequireDefault(__nccwpck_require__(8950)); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +function v4(options, buf, offset) { + options = options || {}; + + const rnds = options.random || (options.rng || _rng.default)(); // Per 4.4, set bits for version and `clock_seq_hi_and_reserved` + + + rnds[6] = rnds[6] & 0x0f | 0x40; + rnds[8] = rnds[8] & 0x3f | 0x80; // Copy bytes to buffer, if provided + + if (buf) { + offset = offset || 0; + + for (let i = 0; i < 16; ++i) { + buf[offset + i] = rnds[i]; + } + + return buf; + } + + return (0, _stringify.default)(rnds); +} + +var _default = v4; +exports["default"] = _default; + +/***/ }), + +/***/ 9120: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + + +Object.defineProperty(exports, "__esModule", ({ + value: true +})); +exports["default"] = void 0; + +var _v = _interopRequireDefault(__nccwpck_require__(5998)); + +var _sha = _interopRequireDefault(__nccwpck_require__(5274)); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +const v5 = (0, _v.default)('v5', 0x50, _sha.default); +var _default = v5; +exports["default"] = _default; + +/***/ }), + +/***/ 6900: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + + +Object.defineProperty(exports, "__esModule", ({ + value: true +})); +exports["default"] = void 0; + +var _regex = _interopRequireDefault(__nccwpck_require__(814)); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +function validate(uuid) { + return typeof uuid === 'string' && _regex.default.test(uuid); +} + +var _default = validate; +exports["default"] = _default; + +/***/ }), + +/***/ 1595: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + + +Object.defineProperty(exports, "__esModule", ({ + value: true +})); +exports["default"] = void 0; + +var _validate = _interopRequireDefault(__nccwpck_require__(6900)); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +function version(uuid) { + if (!(0, _validate.default)(uuid)) { + throw TypeError('Invalid UUID'); + } + + return parseInt(uuid.substr(14, 1), 16); +} + +var _default = version; +exports["default"] = _default; + +/***/ }), + +/***/ 4886: +/***/ ((module) => { + +"use strict"; + + +var conversions = {}; +module.exports = conversions; + +function sign(x) { + return x < 0 ? -1 : 1; +} + +function evenRound(x) { + // Round x to the nearest integer, choosing the even integer if it lies halfway between two. + if ((x % 1) === 0.5 && (x & 1) === 0) { // [even number].5; round down (i.e. floor) + return Math.floor(x); + } else { + return Math.round(x); + } +} + +function createNumberConversion(bitLength, typeOpts) { + if (!typeOpts.unsigned) { + --bitLength; + } + const lowerBound = typeOpts.unsigned ? 0 : -Math.pow(2, bitLength); + const upperBound = Math.pow(2, bitLength) - 1; + + const moduloVal = typeOpts.moduloBitLength ? Math.pow(2, typeOpts.moduloBitLength) : Math.pow(2, bitLength); + const moduloBound = typeOpts.moduloBitLength ? Math.pow(2, typeOpts.moduloBitLength - 1) : Math.pow(2, bitLength - 1); + + return function(V, opts) { + if (!opts) opts = {}; + + let x = +V; + + if (opts.enforceRange) { + if (!Number.isFinite(x)) { + throw new TypeError("Argument is not a finite number"); + } + + x = sign(x) * Math.floor(Math.abs(x)); + if (x < lowerBound || x > upperBound) { + throw new TypeError("Argument is not in byte range"); + } + + return x; + } + + if (!isNaN(x) && opts.clamp) { + x = evenRound(x); + + if (x < lowerBound) x = lowerBound; + if (x > upperBound) x = upperBound; + return x; + } + + if (!Number.isFinite(x) || x === 0) { + return 0; + } + + x = sign(x) * Math.floor(Math.abs(x)); + x = x % moduloVal; + + if (!typeOpts.unsigned && x >= moduloBound) { + return x - moduloVal; + } else if (typeOpts.unsigned) { + if (x < 0) { + x += moduloVal; + } else if (x === -0) { // don't return negative zero + return 0; + } + } + + return x; + } +} + +conversions["void"] = function () { + return undefined; +}; + +conversions["boolean"] = function (val) { + return !!val; +}; + +conversions["byte"] = createNumberConversion(8, { unsigned: false }); +conversions["octet"] = createNumberConversion(8, { unsigned: true }); + +conversions["short"] = createNumberConversion(16, { unsigned: false }); +conversions["unsigned short"] = createNumberConversion(16, { unsigned: true }); + +conversions["long"] = createNumberConversion(32, { unsigned: false }); +conversions["unsigned long"] = createNumberConversion(32, { unsigned: true }); + +conversions["long long"] = createNumberConversion(32, { unsigned: false, moduloBitLength: 64 }); +conversions["unsigned long long"] = createNumberConversion(32, { unsigned: true, moduloBitLength: 64 }); + +conversions["double"] = function (V) { + const x = +V; + + if (!Number.isFinite(x)) { + throw new TypeError("Argument is not a finite floating-point value"); + } + + return x; +}; + +conversions["unrestricted double"] = function (V) { + const x = +V; + + if (isNaN(x)) { + throw new TypeError("Argument is NaN"); + } + + return x; +}; + +// not quite valid, but good enough for JS +conversions["float"] = conversions["double"]; +conversions["unrestricted float"] = conversions["unrestricted double"]; + +conversions["DOMString"] = function (V, opts) { + if (!opts) opts = {}; + + if (opts.treatNullAsEmptyString && V === null) { + return ""; + } + + return String(V); +}; + +conversions["ByteString"] = function (V, opts) { + const x = String(V); + let c = undefined; + for (let i = 0; (c = x.codePointAt(i)) !== undefined; ++i) { + if (c > 255) { + throw new TypeError("Argument is not a valid bytestring"); + } + } + + return x; +}; + +conversions["USVString"] = function (V) { + const S = String(V); + const n = S.length; + const U = []; + for (let i = 0; i < n; ++i) { + const c = S.charCodeAt(i); + if (c < 0xD800 || c > 0xDFFF) { + U.push(String.fromCodePoint(c)); + } else if (0xDC00 <= c && c <= 0xDFFF) { + U.push(String.fromCodePoint(0xFFFD)); + } else { + if (i === n - 1) { + U.push(String.fromCodePoint(0xFFFD)); + } else { + const d = S.charCodeAt(i + 1); + if (0xDC00 <= d && d <= 0xDFFF) { + const a = c & 0x3FF; + const b = d & 0x3FF; + U.push(String.fromCodePoint((2 << 15) + (2 << 9) * a + b)); + ++i; + } else { + U.push(String.fromCodePoint(0xFFFD)); + } + } + } + } + + return U.join(''); +}; + +conversions["Date"] = function (V, opts) { + if (!(V instanceof Date)) { + throw new TypeError("Argument is not a Date object"); + } + if (isNaN(V)) { + return undefined; + } + + return V; +}; + +conversions["RegExp"] = function (V, opts) { + if (!(V instanceof RegExp)) { + V = new RegExp(V); + } + + return V; +}; + + +/***/ }), + +/***/ 7537: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +const usm = __nccwpck_require__(2158); + +exports.implementation = class URLImpl { + constructor(constructorArgs) { + const url = constructorArgs[0]; + const base = constructorArgs[1]; + + let parsedBase = null; + if (base !== undefined) { + parsedBase = usm.basicURLParse(base); + if (parsedBase === "failure") { + throw new TypeError("Invalid base URL"); + } + } + + const parsedURL = usm.basicURLParse(url, { baseURL: parsedBase }); + if (parsedURL === "failure") { + throw new TypeError("Invalid URL"); + } + + this._url = parsedURL; + + // TODO: query stuff + } + + get href() { + return usm.serializeURL(this._url); + } + + set href(v) { + const parsedURL = usm.basicURLParse(v); + if (parsedURL === "failure") { + throw new TypeError("Invalid URL"); + } + + this._url = parsedURL; + } + + get origin() { + return usm.serializeURLOrigin(this._url); + } + + get protocol() { + return this._url.scheme + ":"; + } + + set protocol(v) { + usm.basicURLParse(v + ":", { url: this._url, stateOverride: "scheme start" }); + } + + get username() { + return this._url.username; + } + + set username(v) { + if (usm.cannotHaveAUsernamePasswordPort(this._url)) { + return; + } + + usm.setTheUsername(this._url, v); + } + + get password() { + return this._url.password; + } + + set password(v) { + if (usm.cannotHaveAUsernamePasswordPort(this._url)) { + return; + } + + usm.setThePassword(this._url, v); + } + + get host() { + const url = this._url; + + if (url.host === null) { + return ""; + } + + if (url.port === null) { + return usm.serializeHost(url.host); + } + + return usm.serializeHost(url.host) + ":" + usm.serializeInteger(url.port); + } + + set host(v) { + if (this._url.cannotBeABaseURL) { + return; + } + + usm.basicURLParse(v, { url: this._url, stateOverride: "host" }); + } + + get hostname() { + if (this._url.host === null) { + return ""; + } + + return usm.serializeHost(this._url.host); + } + + set hostname(v) { + if (this._url.cannotBeABaseURL) { + return; + } + + usm.basicURLParse(v, { url: this._url, stateOverride: "hostname" }); + } + + get port() { + if (this._url.port === null) { + return ""; + } + + return usm.serializeInteger(this._url.port); + } + + set port(v) { + if (usm.cannotHaveAUsernamePasswordPort(this._url)) { + return; + } + + if (v === "") { + this._url.port = null; + } else { + usm.basicURLParse(v, { url: this._url, stateOverride: "port" }); + } + } + + get pathname() { + if (this._url.cannotBeABaseURL) { + return this._url.path[0]; + } + + if (this._url.path.length === 0) { + return ""; + } + + return "/" + this._url.path.join("/"); + } + + set pathname(v) { + if (this._url.cannotBeABaseURL) { + return; + } + + this._url.path = []; + usm.basicURLParse(v, { url: this._url, stateOverride: "path start" }); + } + + get search() { + if (this._url.query === null || this._url.query === "") { + return ""; + } + + return "?" + this._url.query; + } + + set search(v) { + // TODO: query stuff + + const url = this._url; + + if (v === "") { + url.query = null; + return; + } + + const input = v[0] === "?" ? v.substring(1) : v; + url.query = ""; + usm.basicURLParse(input, { url, stateOverride: "query" }); + } + + get hash() { + if (this._url.fragment === null || this._url.fragment === "") { + return ""; + } + + return "#" + this._url.fragment; + } + + set hash(v) { + if (v === "") { + this._url.fragment = null; + return; + } + + const input = v[0] === "#" ? v.substring(1) : v; + this._url.fragment = ""; + usm.basicURLParse(input, { url: this._url, stateOverride: "fragment" }); + } + + toJSON() { + return this.href; + } +}; + + +/***/ }), + +/***/ 3394: +/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { + +"use strict"; + + +const conversions = __nccwpck_require__(4886); +const utils = __nccwpck_require__(3185); +const Impl = __nccwpck_require__(7537); + +const impl = utils.implSymbol; + +function URL(url) { + if (!this || this[impl] || !(this instanceof URL)) { + throw new TypeError("Failed to construct 'URL': Please use the 'new' operator, this DOM object constructor cannot be called as a function."); + } + if (arguments.length < 1) { + throw new TypeError("Failed to construct 'URL': 1 argument required, but only " + arguments.length + " present."); + } + const args = []; + for (let i = 0; i < arguments.length && i < 2; ++i) { + args[i] = arguments[i]; + } + args[0] = conversions["USVString"](args[0]); + if (args[1] !== undefined) { + args[1] = conversions["USVString"](args[1]); + } + + module.exports.setup(this, args); +} + +URL.prototype.toJSON = function toJSON() { + if (!this || !module.exports.is(this)) { + throw new TypeError("Illegal invocation"); + } + const args = []; + for (let i = 0; i < arguments.length && i < 0; ++i) { + args[i] = arguments[i]; + } + return this[impl].toJSON.apply(this[impl], args); +}; +Object.defineProperty(URL.prototype, "href", { + get() { + return this[impl].href; + }, + set(V) { + V = conversions["USVString"](V); + this[impl].href = V; + }, + enumerable: true, + configurable: true +}); + +URL.prototype.toString = function () { + if (!this || !module.exports.is(this)) { + throw new TypeError("Illegal invocation"); + } + return this.href; +}; + +Object.defineProperty(URL.prototype, "origin", { + get() { + return this[impl].origin; + }, + enumerable: true, + configurable: true +}); + +Object.defineProperty(URL.prototype, "protocol", { + get() { + return this[impl].protocol; + }, + set(V) { + V = conversions["USVString"](V); + this[impl].protocol = V; + }, + enumerable: true, + configurable: true +}); + +Object.defineProperty(URL.prototype, "username", { + get() { + return this[impl].username; + }, + set(V) { + V = conversions["USVString"](V); + this[impl].username = V; + }, + enumerable: true, + configurable: true +}); + +Object.defineProperty(URL.prototype, "password", { + get() { + return this[impl].password; + }, + set(V) { + V = conversions["USVString"](V); + this[impl].password = V; + }, + enumerable: true, + configurable: true +}); + +Object.defineProperty(URL.prototype, "host", { + get() { + return this[impl].host; + }, + set(V) { + V = conversions["USVString"](V); + this[impl].host = V; + }, + enumerable: true, + configurable: true +}); + +Object.defineProperty(URL.prototype, "hostname", { + get() { + return this[impl].hostname; + }, + set(V) { + V = conversions["USVString"](V); + this[impl].hostname = V; + }, + enumerable: true, + configurable: true +}); + +Object.defineProperty(URL.prototype, "port", { + get() { + return this[impl].port; + }, + set(V) { + V = conversions["USVString"](V); + this[impl].port = V; + }, + enumerable: true, + configurable: true +}); + +Object.defineProperty(URL.prototype, "pathname", { + get() { + return this[impl].pathname; + }, + set(V) { + V = conversions["USVString"](V); + this[impl].pathname = V; + }, + enumerable: true, + configurable: true +}); + +Object.defineProperty(URL.prototype, "search", { + get() { + return this[impl].search; + }, + set(V) { + V = conversions["USVString"](V); + this[impl].search = V; + }, + enumerable: true, + configurable: true +}); + +Object.defineProperty(URL.prototype, "hash", { + get() { + return this[impl].hash; + }, + set(V) { + V = conversions["USVString"](V); + this[impl].hash = V; + }, + enumerable: true, + configurable: true +}); + + +module.exports = { + is(obj) { + return !!obj && obj[impl] instanceof Impl.implementation; + }, + create(constructorArgs, privateData) { + let obj = Object.create(URL.prototype); + this.setup(obj, constructorArgs, privateData); + return obj; + }, + setup(obj, constructorArgs, privateData) { + if (!privateData) privateData = {}; + privateData.wrapper = obj; + + obj[impl] = new Impl.implementation(constructorArgs, privateData); + obj[impl][utils.wrapperSymbol] = obj; + }, + interface: URL, + expose: { + Window: { URL: URL }, + Worker: { URL: URL } + } +}; + + + +/***/ }), + +/***/ 8665: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + + +exports.URL = __nccwpck_require__(3394)["interface"]; +exports.serializeURL = __nccwpck_require__(2158).serializeURL; +exports.serializeURLOrigin = __nccwpck_require__(2158).serializeURLOrigin; +exports.basicURLParse = __nccwpck_require__(2158).basicURLParse; +exports.setTheUsername = __nccwpck_require__(2158).setTheUsername; +exports.setThePassword = __nccwpck_require__(2158).setThePassword; +exports.serializeHost = __nccwpck_require__(2158).serializeHost; +exports.serializeInteger = __nccwpck_require__(2158).serializeInteger; +exports.parseURL = __nccwpck_require__(2158).parseURL; + + +/***/ }), + +/***/ 2158: +/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { + +"use strict"; + +const punycode = __nccwpck_require__(5477); +const tr46 = __nccwpck_require__(4256); + +const specialSchemes = { + ftp: 21, + file: null, + gopher: 70, + http: 80, + https: 443, + ws: 80, + wss: 443 +}; + +const failure = Symbol("failure"); + +function countSymbols(str) { + return punycode.ucs2.decode(str).length; +} + +function at(input, idx) { + const c = input[idx]; + return isNaN(c) ? undefined : String.fromCodePoint(c); +} + +function isASCIIDigit(c) { + return c >= 0x30 && c <= 0x39; +} + +function isASCIIAlpha(c) { + return (c >= 0x41 && c <= 0x5A) || (c >= 0x61 && c <= 0x7A); +} + +function isASCIIAlphanumeric(c) { + return isASCIIAlpha(c) || isASCIIDigit(c); +} + +function isASCIIHex(c) { + return isASCIIDigit(c) || (c >= 0x41 && c <= 0x46) || (c >= 0x61 && c <= 0x66); +} + +function isSingleDot(buffer) { + return buffer === "." || buffer.toLowerCase() === "%2e"; +} + +function isDoubleDot(buffer) { + buffer = buffer.toLowerCase(); + return buffer === ".." || buffer === "%2e." || buffer === ".%2e" || buffer === "%2e%2e"; +} + +function isWindowsDriveLetterCodePoints(cp1, cp2) { + return isASCIIAlpha(cp1) && (cp2 === 58 || cp2 === 124); +} + +function isWindowsDriveLetterString(string) { + return string.length === 2 && isASCIIAlpha(string.codePointAt(0)) && (string[1] === ":" || string[1] === "|"); +} + +function isNormalizedWindowsDriveLetterString(string) { + return string.length === 2 && isASCIIAlpha(string.codePointAt(0)) && string[1] === ":"; +} + +function containsForbiddenHostCodePoint(string) { + return string.search(/\u0000|\u0009|\u000A|\u000D|\u0020|#|%|\/|:|\?|@|\[|\\|\]/) !== -1; +} + +function containsForbiddenHostCodePointExcludingPercent(string) { + return string.search(/\u0000|\u0009|\u000A|\u000D|\u0020|#|\/|:|\?|@|\[|\\|\]/) !== -1; +} + +function isSpecialScheme(scheme) { + return specialSchemes[scheme] !== undefined; +} + +function isSpecial(url) { + return isSpecialScheme(url.scheme); +} + +function defaultPort(scheme) { + return specialSchemes[scheme]; +} + +function percentEncode(c) { + let hex = c.toString(16).toUpperCase(); + if (hex.length === 1) { + hex = "0" + hex; + } + + return "%" + hex; +} + +function utf8PercentEncode(c) { + const buf = new Buffer(c); + + let str = ""; + + for (let i = 0; i < buf.length; ++i) { + str += percentEncode(buf[i]); + } + + return str; +} + +function utf8PercentDecode(str) { + const input = new Buffer(str); + const output = []; + for (let i = 0; i < input.length; ++i) { + if (input[i] !== 37) { + output.push(input[i]); + } else if (input[i] === 37 && isASCIIHex(input[i + 1]) && isASCIIHex(input[i + 2])) { + output.push(parseInt(input.slice(i + 1, i + 3).toString(), 16)); + i += 2; + } else { + output.push(input[i]); + } + } + return new Buffer(output).toString(); +} + +function isC0ControlPercentEncode(c) { + return c <= 0x1F || c > 0x7E; +} + +const extraPathPercentEncodeSet = new Set([32, 34, 35, 60, 62, 63, 96, 123, 125]); +function isPathPercentEncode(c) { + return isC0ControlPercentEncode(c) || extraPathPercentEncodeSet.has(c); +} + +const extraUserinfoPercentEncodeSet = + new Set([47, 58, 59, 61, 64, 91, 92, 93, 94, 124]); +function isUserinfoPercentEncode(c) { + return isPathPercentEncode(c) || extraUserinfoPercentEncodeSet.has(c); +} + +function percentEncodeChar(c, encodeSetPredicate) { + const cStr = String.fromCodePoint(c); + + if (encodeSetPredicate(c)) { + return utf8PercentEncode(cStr); + } + + return cStr; +} + +function parseIPv4Number(input) { + let R = 10; + + if (input.length >= 2 && input.charAt(0) === "0" && input.charAt(1).toLowerCase() === "x") { + input = input.substring(2); + R = 16; + } else if (input.length >= 2 && input.charAt(0) === "0") { + input = input.substring(1); + R = 8; + } + + if (input === "") { + return 0; + } + + const regex = R === 10 ? /[^0-9]/ : (R === 16 ? /[^0-9A-Fa-f]/ : /[^0-7]/); + if (regex.test(input)) { + return failure; + } + + return parseInt(input, R); +} + +function parseIPv4(input) { + const parts = input.split("."); + if (parts[parts.length - 1] === "") { + if (parts.length > 1) { + parts.pop(); + } + } + + if (parts.length > 4) { + return input; + } + + const numbers = []; + for (const part of parts) { + if (part === "") { + return input; + } + const n = parseIPv4Number(part); + if (n === failure) { + return input; + } + + numbers.push(n); + } + + for (let i = 0; i < numbers.length - 1; ++i) { + if (numbers[i] > 255) { + return failure; + } + } + if (numbers[numbers.length - 1] >= Math.pow(256, 5 - numbers.length)) { + return failure; + } + + let ipv4 = numbers.pop(); + let counter = 0; + + for (const n of numbers) { + ipv4 += n * Math.pow(256, 3 - counter); + ++counter; + } + + return ipv4; +} + +function serializeIPv4(address) { + let output = ""; + let n = address; + + for (let i = 1; i <= 4; ++i) { + output = String(n % 256) + output; + if (i !== 4) { + output = "." + output; + } + n = Math.floor(n / 256); + } + + return output; +} + +function parseIPv6(input) { + const address = [0, 0, 0, 0, 0, 0, 0, 0]; + let pieceIndex = 0; + let compress = null; + let pointer = 0; + + input = punycode.ucs2.decode(input); + + if (input[pointer] === 58) { + if (input[pointer + 1] !== 58) { + return failure; + } + + pointer += 2; + ++pieceIndex; + compress = pieceIndex; + } + + while (pointer < input.length) { + if (pieceIndex === 8) { + return failure; + } + + if (input[pointer] === 58) { + if (compress !== null) { + return failure; + } + ++pointer; + ++pieceIndex; + compress = pieceIndex; + continue; + } + + let value = 0; + let length = 0; + + while (length < 4 && isASCIIHex(input[pointer])) { + value = value * 0x10 + parseInt(at(input, pointer), 16); + ++pointer; + ++length; + } + + if (input[pointer] === 46) { + if (length === 0) { + return failure; + } + + pointer -= length; + + if (pieceIndex > 6) { + return failure; + } + + let numbersSeen = 0; + + while (input[pointer] !== undefined) { + let ipv4Piece = null; + + if (numbersSeen > 0) { + if (input[pointer] === 46 && numbersSeen < 4) { + ++pointer; + } else { + return failure; + } + } + + if (!isASCIIDigit(input[pointer])) { + return failure; + } + + while (isASCIIDigit(input[pointer])) { + const number = parseInt(at(input, pointer)); + if (ipv4Piece === null) { + ipv4Piece = number; + } else if (ipv4Piece === 0) { + return failure; + } else { + ipv4Piece = ipv4Piece * 10 + number; + } + if (ipv4Piece > 255) { + return failure; + } + ++pointer; + } + + address[pieceIndex] = address[pieceIndex] * 0x100 + ipv4Piece; + + ++numbersSeen; + + if (numbersSeen === 2 || numbersSeen === 4) { + ++pieceIndex; + } + } + + if (numbersSeen !== 4) { + return failure; + } + + break; + } else if (input[pointer] === 58) { + ++pointer; + if (input[pointer] === undefined) { + return failure; + } + } else if (input[pointer] !== undefined) { + return failure; + } + + address[pieceIndex] = value; + ++pieceIndex; + } + + if (compress !== null) { + let swaps = pieceIndex - compress; + pieceIndex = 7; + while (pieceIndex !== 0 && swaps > 0) { + const temp = address[compress + swaps - 1]; + address[compress + swaps - 1] = address[pieceIndex]; + address[pieceIndex] = temp; + --pieceIndex; + --swaps; + } + } else if (compress === null && pieceIndex !== 8) { + return failure; + } + + return address; +} + +function serializeIPv6(address) { + let output = ""; + const seqResult = findLongestZeroSequence(address); + const compress = seqResult.idx; + let ignore0 = false; + + for (let pieceIndex = 0; pieceIndex <= 7; ++pieceIndex) { + if (ignore0 && address[pieceIndex] === 0) { + continue; + } else if (ignore0) { + ignore0 = false; + } + + if (compress === pieceIndex) { + const separator = pieceIndex === 0 ? "::" : ":"; + output += separator; + ignore0 = true; + continue; + } + + output += address[pieceIndex].toString(16); + + if (pieceIndex !== 7) { + output += ":"; + } + } + + return output; +} + +function parseHost(input, isSpecialArg) { + if (input[0] === "[") { + if (input[input.length - 1] !== "]") { + return failure; + } + + return parseIPv6(input.substring(1, input.length - 1)); + } + + if (!isSpecialArg) { + return parseOpaqueHost(input); + } + + const domain = utf8PercentDecode(input); + const asciiDomain = tr46.toASCII(domain, false, tr46.PROCESSING_OPTIONS.NONTRANSITIONAL, false); + if (asciiDomain === null) { + return failure; + } + + if (containsForbiddenHostCodePoint(asciiDomain)) { + return failure; + } + + const ipv4Host = parseIPv4(asciiDomain); + if (typeof ipv4Host === "number" || ipv4Host === failure) { + return ipv4Host; + } + + return asciiDomain; +} + +function parseOpaqueHost(input) { + if (containsForbiddenHostCodePointExcludingPercent(input)) { + return failure; + } + + let output = ""; + const decoded = punycode.ucs2.decode(input); + for (let i = 0; i < decoded.length; ++i) { + output += percentEncodeChar(decoded[i], isC0ControlPercentEncode); + } + return output; +} + +function findLongestZeroSequence(arr) { + let maxIdx = null; + let maxLen = 1; // only find elements > 1 + let currStart = null; + let currLen = 0; + + for (let i = 0; i < arr.length; ++i) { + if (arr[i] !== 0) { + if (currLen > maxLen) { + maxIdx = currStart; + maxLen = currLen; + } + + currStart = null; + currLen = 0; + } else { + if (currStart === null) { + currStart = i; + } + ++currLen; + } + } + + // if trailing zeros + if (currLen > maxLen) { + maxIdx = currStart; + maxLen = currLen; + } + + return { + idx: maxIdx, + len: maxLen + }; +} + +function serializeHost(host) { + if (typeof host === "number") { + return serializeIPv4(host); + } + + // IPv6 serializer + if (host instanceof Array) { + return "[" + serializeIPv6(host) + "]"; + } + + return host; +} + +function trimControlChars(url) { + return url.replace(/^[\u0000-\u001F\u0020]+|[\u0000-\u001F\u0020]+$/g, ""); +} + +function trimTabAndNewline(url) { + return url.replace(/\u0009|\u000A|\u000D/g, ""); +} + +function shortenPath(url) { + const path = url.path; + if (path.length === 0) { + return; + } + if (url.scheme === "file" && path.length === 1 && isNormalizedWindowsDriveLetter(path[0])) { + return; + } + + path.pop(); +} + +function includesCredentials(url) { + return url.username !== "" || url.password !== ""; +} + +function cannotHaveAUsernamePasswordPort(url) { + return url.host === null || url.host === "" || url.cannotBeABaseURL || url.scheme === "file"; +} + +function isNormalizedWindowsDriveLetter(string) { + return /^[A-Za-z]:$/.test(string); +} + +function URLStateMachine(input, base, encodingOverride, url, stateOverride) { + this.pointer = 0; + this.input = input; + this.base = base || null; + this.encodingOverride = encodingOverride || "utf-8"; + this.stateOverride = stateOverride; + this.url = url; + this.failure = false; + this.parseError = false; + + if (!this.url) { + this.url = { + scheme: "", + username: "", + password: "", + host: null, + port: null, + path: [], + query: null, + fragment: null, + + cannotBeABaseURL: false + }; + + const res = trimControlChars(this.input); + if (res !== this.input) { + this.parseError = true; + } + this.input = res; + } + + const res = trimTabAndNewline(this.input); + if (res !== this.input) { + this.parseError = true; + } + this.input = res; + + this.state = stateOverride || "scheme start"; + + this.buffer = ""; + this.atFlag = false; + this.arrFlag = false; + this.passwordTokenSeenFlag = false; + + this.input = punycode.ucs2.decode(this.input); + + for (; this.pointer <= this.input.length; ++this.pointer) { + const c = this.input[this.pointer]; + const cStr = isNaN(c) ? undefined : String.fromCodePoint(c); + + // exec state machine + const ret = this["parse " + this.state](c, cStr); + if (!ret) { + break; // terminate algorithm + } else if (ret === failure) { + this.failure = true; + break; + } + } +} + +URLStateMachine.prototype["parse scheme start"] = function parseSchemeStart(c, cStr) { + if (isASCIIAlpha(c)) { + this.buffer += cStr.toLowerCase(); + this.state = "scheme"; + } else if (!this.stateOverride) { + this.state = "no scheme"; + --this.pointer; + } else { + this.parseError = true; + return failure; + } + + return true; +}; + +URLStateMachine.prototype["parse scheme"] = function parseScheme(c, cStr) { + if (isASCIIAlphanumeric(c) || c === 43 || c === 45 || c === 46) { + this.buffer += cStr.toLowerCase(); + } else if (c === 58) { + if (this.stateOverride) { + if (isSpecial(this.url) && !isSpecialScheme(this.buffer)) { + return false; + } + + if (!isSpecial(this.url) && isSpecialScheme(this.buffer)) { + return false; + } + + if ((includesCredentials(this.url) || this.url.port !== null) && this.buffer === "file") { + return false; + } + + if (this.url.scheme === "file" && (this.url.host === "" || this.url.host === null)) { + return false; + } + } + this.url.scheme = this.buffer; + this.buffer = ""; + if (this.stateOverride) { + return false; + } + if (this.url.scheme === "file") { + if (this.input[this.pointer + 1] !== 47 || this.input[this.pointer + 2] !== 47) { + this.parseError = true; + } + this.state = "file"; + } else if (isSpecial(this.url) && this.base !== null && this.base.scheme === this.url.scheme) { + this.state = "special relative or authority"; + } else if (isSpecial(this.url)) { + this.state = "special authority slashes"; + } else if (this.input[this.pointer + 1] === 47) { + this.state = "path or authority"; + ++this.pointer; + } else { + this.url.cannotBeABaseURL = true; + this.url.path.push(""); + this.state = "cannot-be-a-base-URL path"; + } + } else if (!this.stateOverride) { + this.buffer = ""; + this.state = "no scheme"; + this.pointer = -1; + } else { + this.parseError = true; + return failure; + } + + return true; +}; + +URLStateMachine.prototype["parse no scheme"] = function parseNoScheme(c) { + if (this.base === null || (this.base.cannotBeABaseURL && c !== 35)) { + return failure; + } else if (this.base.cannotBeABaseURL && c === 35) { + this.url.scheme = this.base.scheme; + this.url.path = this.base.path.slice(); + this.url.query = this.base.query; + this.url.fragment = ""; + this.url.cannotBeABaseURL = true; + this.state = "fragment"; + } else if (this.base.scheme === "file") { + this.state = "file"; + --this.pointer; + } else { + this.state = "relative"; + --this.pointer; + } + + return true; +}; + +URLStateMachine.prototype["parse special relative or authority"] = function parseSpecialRelativeOrAuthority(c) { + if (c === 47 && this.input[this.pointer + 1] === 47) { + this.state = "special authority ignore slashes"; + ++this.pointer; + } else { + this.parseError = true; + this.state = "relative"; + --this.pointer; + } + + return true; +}; + +URLStateMachine.prototype["parse path or authority"] = function parsePathOrAuthority(c) { + if (c === 47) { + this.state = "authority"; + } else { + this.state = "path"; + --this.pointer; + } + + return true; +}; + +URLStateMachine.prototype["parse relative"] = function parseRelative(c) { + this.url.scheme = this.base.scheme; + if (isNaN(c)) { + this.url.username = this.base.username; + this.url.password = this.base.password; + this.url.host = this.base.host; + this.url.port = this.base.port; + this.url.path = this.base.path.slice(); + this.url.query = this.base.query; + } else if (c === 47) { + this.state = "relative slash"; + } else if (c === 63) { + this.url.username = this.base.username; + this.url.password = this.base.password; + this.url.host = this.base.host; + this.url.port = this.base.port; + this.url.path = this.base.path.slice(); + this.url.query = ""; + this.state = "query"; + } else if (c === 35) { + this.url.username = this.base.username; + this.url.password = this.base.password; + this.url.host = this.base.host; + this.url.port = this.base.port; + this.url.path = this.base.path.slice(); + this.url.query = this.base.query; + this.url.fragment = ""; + this.state = "fragment"; + } else if (isSpecial(this.url) && c === 92) { + this.parseError = true; + this.state = "relative slash"; + } else { + this.url.username = this.base.username; + this.url.password = this.base.password; + this.url.host = this.base.host; + this.url.port = this.base.port; + this.url.path = this.base.path.slice(0, this.base.path.length - 1); + + this.state = "path"; + --this.pointer; + } + + return true; +}; + +URLStateMachine.prototype["parse relative slash"] = function parseRelativeSlash(c) { + if (isSpecial(this.url) && (c === 47 || c === 92)) { + if (c === 92) { + this.parseError = true; + } + this.state = "special authority ignore slashes"; + } else if (c === 47) { + this.state = "authority"; + } else { + this.url.username = this.base.username; + this.url.password = this.base.password; + this.url.host = this.base.host; + this.url.port = this.base.port; + this.state = "path"; + --this.pointer; + } + + return true; +}; + +URLStateMachine.prototype["parse special authority slashes"] = function parseSpecialAuthoritySlashes(c) { + if (c === 47 && this.input[this.pointer + 1] === 47) { + this.state = "special authority ignore slashes"; + ++this.pointer; + } else { + this.parseError = true; + this.state = "special authority ignore slashes"; + --this.pointer; + } + + return true; +}; + +URLStateMachine.prototype["parse special authority ignore slashes"] = function parseSpecialAuthorityIgnoreSlashes(c) { + if (c !== 47 && c !== 92) { + this.state = "authority"; + --this.pointer; + } else { + this.parseError = true; + } + + return true; +}; + +URLStateMachine.prototype["parse authority"] = function parseAuthority(c, cStr) { + if (c === 64) { + this.parseError = true; + if (this.atFlag) { + this.buffer = "%40" + this.buffer; + } + this.atFlag = true; + + // careful, this is based on buffer and has its own pointer (this.pointer != pointer) and inner chars + const len = countSymbols(this.buffer); + for (let pointer = 0; pointer < len; ++pointer) { + const codePoint = this.buffer.codePointAt(pointer); + + if (codePoint === 58 && !this.passwordTokenSeenFlag) { + this.passwordTokenSeenFlag = true; + continue; + } + const encodedCodePoints = percentEncodeChar(codePoint, isUserinfoPercentEncode); + if (this.passwordTokenSeenFlag) { + this.url.password += encodedCodePoints; + } else { + this.url.username += encodedCodePoints; + } + } + this.buffer = ""; + } else if (isNaN(c) || c === 47 || c === 63 || c === 35 || + (isSpecial(this.url) && c === 92)) { + if (this.atFlag && this.buffer === "") { + this.parseError = true; + return failure; + } + this.pointer -= countSymbols(this.buffer) + 1; + this.buffer = ""; + this.state = "host"; + } else { + this.buffer += cStr; + } + + return true; +}; + +URLStateMachine.prototype["parse hostname"] = +URLStateMachine.prototype["parse host"] = function parseHostName(c, cStr) { + if (this.stateOverride && this.url.scheme === "file") { + --this.pointer; + this.state = "file host"; + } else if (c === 58 && !this.arrFlag) { + if (this.buffer === "") { + this.parseError = true; + return failure; + } + + const host = parseHost(this.buffer, isSpecial(this.url)); + if (host === failure) { + return failure; + } + + this.url.host = host; + this.buffer = ""; + this.state = "port"; + if (this.stateOverride === "hostname") { + return false; + } + } else if (isNaN(c) || c === 47 || c === 63 || c === 35 || + (isSpecial(this.url) && c === 92)) { + --this.pointer; + if (isSpecial(this.url) && this.buffer === "") { + this.parseError = true; + return failure; + } else if (this.stateOverride && this.buffer === "" && + (includesCredentials(this.url) || this.url.port !== null)) { + this.parseError = true; + return false; + } + + const host = parseHost(this.buffer, isSpecial(this.url)); + if (host === failure) { + return failure; + } + + this.url.host = host; + this.buffer = ""; + this.state = "path start"; + if (this.stateOverride) { + return false; + } + } else { + if (c === 91) { + this.arrFlag = true; + } else if (c === 93) { + this.arrFlag = false; + } + this.buffer += cStr; + } + + return true; +}; + +URLStateMachine.prototype["parse port"] = function parsePort(c, cStr) { + if (isASCIIDigit(c)) { + this.buffer += cStr; + } else if (isNaN(c) || c === 47 || c === 63 || c === 35 || + (isSpecial(this.url) && c === 92) || + this.stateOverride) { + if (this.buffer !== "") { + const port = parseInt(this.buffer); + if (port > Math.pow(2, 16) - 1) { + this.parseError = true; + return failure; + } + this.url.port = port === defaultPort(this.url.scheme) ? null : port; + this.buffer = ""; + } + if (this.stateOverride) { + return false; + } + this.state = "path start"; + --this.pointer; + } else { + this.parseError = true; + return failure; + } + + return true; +}; + +const fileOtherwiseCodePoints = new Set([47, 92, 63, 35]); + +URLStateMachine.prototype["parse file"] = function parseFile(c) { + this.url.scheme = "file"; + + if (c === 47 || c === 92) { + if (c === 92) { + this.parseError = true; + } + this.state = "file slash"; + } else if (this.base !== null && this.base.scheme === "file") { + if (isNaN(c)) { + this.url.host = this.base.host; + this.url.path = this.base.path.slice(); + this.url.query = this.base.query; + } else if (c === 63) { + this.url.host = this.base.host; + this.url.path = this.base.path.slice(); + this.url.query = ""; + this.state = "query"; + } else if (c === 35) { + this.url.host = this.base.host; + this.url.path = this.base.path.slice(); + this.url.query = this.base.query; + this.url.fragment = ""; + this.state = "fragment"; + } else { + if (this.input.length - this.pointer - 1 === 0 || // remaining consists of 0 code points + !isWindowsDriveLetterCodePoints(c, this.input[this.pointer + 1]) || + (this.input.length - this.pointer - 1 >= 2 && // remaining has at least 2 code points + !fileOtherwiseCodePoints.has(this.input[this.pointer + 2]))) { + this.url.host = this.base.host; + this.url.path = this.base.path.slice(); + shortenPath(this.url); + } else { + this.parseError = true; + } + + this.state = "path"; + --this.pointer; + } + } else { + this.state = "path"; + --this.pointer; + } + + return true; +}; + +URLStateMachine.prototype["parse file slash"] = function parseFileSlash(c) { + if (c === 47 || c === 92) { + if (c === 92) { + this.parseError = true; + } + this.state = "file host"; + } else { + if (this.base !== null && this.base.scheme === "file") { + if (isNormalizedWindowsDriveLetterString(this.base.path[0])) { + this.url.path.push(this.base.path[0]); + } else { + this.url.host = this.base.host; + } + } + this.state = "path"; + --this.pointer; + } + + return true; +}; + +URLStateMachine.prototype["parse file host"] = function parseFileHost(c, cStr) { + if (isNaN(c) || c === 47 || c === 92 || c === 63 || c === 35) { + --this.pointer; + if (!this.stateOverride && isWindowsDriveLetterString(this.buffer)) { + this.parseError = true; + this.state = "path"; + } else if (this.buffer === "") { + this.url.host = ""; + if (this.stateOverride) { + return false; + } + this.state = "path start"; + } else { + let host = parseHost(this.buffer, isSpecial(this.url)); + if (host === failure) { + return failure; + } + if (host === "localhost") { + host = ""; + } + this.url.host = host; + + if (this.stateOverride) { + return false; + } + + this.buffer = ""; + this.state = "path start"; + } + } else { + this.buffer += cStr; + } + + return true; +}; + +URLStateMachine.prototype["parse path start"] = function parsePathStart(c) { + if (isSpecial(this.url)) { + if (c === 92) { + this.parseError = true; + } + this.state = "path"; + + if (c !== 47 && c !== 92) { + --this.pointer; + } + } else if (!this.stateOverride && c === 63) { + this.url.query = ""; + this.state = "query"; + } else if (!this.stateOverride && c === 35) { + this.url.fragment = ""; + this.state = "fragment"; + } else if (c !== undefined) { + this.state = "path"; + if (c !== 47) { + --this.pointer; + } + } + + return true; +}; + +URLStateMachine.prototype["parse path"] = function parsePath(c) { + if (isNaN(c) || c === 47 || (isSpecial(this.url) && c === 92) || + (!this.stateOverride && (c === 63 || c === 35))) { + if (isSpecial(this.url) && c === 92) { + this.parseError = true; + } + + if (isDoubleDot(this.buffer)) { + shortenPath(this.url); + if (c !== 47 && !(isSpecial(this.url) && c === 92)) { + this.url.path.push(""); + } + } else if (isSingleDot(this.buffer) && c !== 47 && + !(isSpecial(this.url) && c === 92)) { + this.url.path.push(""); + } else if (!isSingleDot(this.buffer)) { + if (this.url.scheme === "file" && this.url.path.length === 0 && isWindowsDriveLetterString(this.buffer)) { + if (this.url.host !== "" && this.url.host !== null) { + this.parseError = true; + this.url.host = ""; + } + this.buffer = this.buffer[0] + ":"; + } + this.url.path.push(this.buffer); + } + this.buffer = ""; + if (this.url.scheme === "file" && (c === undefined || c === 63 || c === 35)) { + while (this.url.path.length > 1 && this.url.path[0] === "") { + this.parseError = true; + this.url.path.shift(); + } + } + if (c === 63) { + this.url.query = ""; + this.state = "query"; + } + if (c === 35) { + this.url.fragment = ""; + this.state = "fragment"; + } + } else { + // TODO: If c is not a URL code point and not "%", parse error. + + if (c === 37 && + (!isASCIIHex(this.input[this.pointer + 1]) || + !isASCIIHex(this.input[this.pointer + 2]))) { + this.parseError = true; + } + + this.buffer += percentEncodeChar(c, isPathPercentEncode); + } + + return true; +}; + +URLStateMachine.prototype["parse cannot-be-a-base-URL path"] = function parseCannotBeABaseURLPath(c) { + if (c === 63) { + this.url.query = ""; + this.state = "query"; + } else if (c === 35) { + this.url.fragment = ""; + this.state = "fragment"; + } else { + // TODO: Add: not a URL code point + if (!isNaN(c) && c !== 37) { + this.parseError = true; + } + + if (c === 37 && + (!isASCIIHex(this.input[this.pointer + 1]) || + !isASCIIHex(this.input[this.pointer + 2]))) { + this.parseError = true; + } + + if (!isNaN(c)) { + this.url.path[0] = this.url.path[0] + percentEncodeChar(c, isC0ControlPercentEncode); + } + } + + return true; +}; + +URLStateMachine.prototype["parse query"] = function parseQuery(c, cStr) { + if (isNaN(c) || (!this.stateOverride && c === 35)) { + if (!isSpecial(this.url) || this.url.scheme === "ws" || this.url.scheme === "wss") { + this.encodingOverride = "utf-8"; + } + + const buffer = new Buffer(this.buffer); // TODO: Use encoding override instead + for (let i = 0; i < buffer.length; ++i) { + if (buffer[i] < 0x21 || buffer[i] > 0x7E || buffer[i] === 0x22 || buffer[i] === 0x23 || + buffer[i] === 0x3C || buffer[i] === 0x3E) { + this.url.query += percentEncode(buffer[i]); + } else { + this.url.query += String.fromCodePoint(buffer[i]); + } + } + + this.buffer = ""; + if (c === 35) { + this.url.fragment = ""; + this.state = "fragment"; + } + } else { + // TODO: If c is not a URL code point and not "%", parse error. + if (c === 37 && + (!isASCIIHex(this.input[this.pointer + 1]) || + !isASCIIHex(this.input[this.pointer + 2]))) { + this.parseError = true; + } + + this.buffer += cStr; + } + + return true; +}; + +URLStateMachine.prototype["parse fragment"] = function parseFragment(c) { + if (isNaN(c)) { // do nothing + } else if (c === 0x0) { + this.parseError = true; + } else { + // TODO: If c is not a URL code point and not "%", parse error. + if (c === 37 && + (!isASCIIHex(this.input[this.pointer + 1]) || + !isASCIIHex(this.input[this.pointer + 2]))) { + this.parseError = true; + } + + this.url.fragment += percentEncodeChar(c, isC0ControlPercentEncode); + } + + return true; +}; + +function serializeURL(url, excludeFragment) { + let output = url.scheme + ":"; + if (url.host !== null) { + output += "//"; + + if (url.username !== "" || url.password !== "") { + output += url.username; + if (url.password !== "") { + output += ":" + url.password; + } + output += "@"; + } + + output += serializeHost(url.host); + + if (url.port !== null) { + output += ":" + url.port; + } + } else if (url.host === null && url.scheme === "file") { + output += "//"; + } + + if (url.cannotBeABaseURL) { + output += url.path[0]; + } else { + for (const string of url.path) { + output += "/" + string; + } + } + + if (url.query !== null) { + output += "?" + url.query; + } + + if (!excludeFragment && url.fragment !== null) { + output += "#" + url.fragment; + } + + return output; +} + +function serializeOrigin(tuple) { + let result = tuple.scheme + "://"; + result += serializeHost(tuple.host); + + if (tuple.port !== null) { + result += ":" + tuple.port; + } + + return result; +} + +module.exports.serializeURL = serializeURL; + +module.exports.serializeURLOrigin = function (url) { + // https://url.spec.whatwg.org/#concept-url-origin + switch (url.scheme) { + case "blob": + try { + return module.exports.serializeURLOrigin(module.exports.parseURL(url.path[0])); + } catch (e) { + // serializing an opaque origin returns "null" + return "null"; + } + case "ftp": + case "gopher": + case "http": + case "https": + case "ws": + case "wss": + return serializeOrigin({ + scheme: url.scheme, + host: url.host, + port: url.port + }); + case "file": + // spec says "exercise to the reader", chrome says "file://" + return "file://"; + default: + // serializing an opaque origin returns "null" + return "null"; + } +}; + +module.exports.basicURLParse = function (input, options) { + if (options === undefined) { + options = {}; + } + + const usm = new URLStateMachine(input, options.baseURL, options.encodingOverride, options.url, options.stateOverride); + if (usm.failure) { + return "failure"; + } + + return usm.url; +}; + +module.exports.setTheUsername = function (url, username) { + url.username = ""; + const decoded = punycode.ucs2.decode(username); + for (let i = 0; i < decoded.length; ++i) { + url.username += percentEncodeChar(decoded[i], isUserinfoPercentEncode); + } +}; + +module.exports.setThePassword = function (url, password) { + url.password = ""; + const decoded = punycode.ucs2.decode(password); + for (let i = 0; i < decoded.length; ++i) { + url.password += percentEncodeChar(decoded[i], isUserinfoPercentEncode); + } +}; + +module.exports.serializeHost = serializeHost; + +module.exports.cannotHaveAUsernamePasswordPort = cannotHaveAUsernamePasswordPort; + +module.exports.serializeInteger = function (integer) { + return String(integer); +}; + +module.exports.parseURL = function (input, options) { + if (options === undefined) { + options = {}; + } + + // We don't handle blobs, so this just delegates: + return module.exports.basicURLParse(input, { baseURL: options.baseURL, encodingOverride: options.encodingOverride }); +}; + + +/***/ }), + +/***/ 3185: +/***/ ((module) => { + +"use strict"; + + +module.exports.mixin = function mixin(target, source) { + const keys = Object.getOwnPropertyNames(source); + for (let i = 0; i < keys.length; ++i) { + Object.defineProperty(target, keys[i], Object.getOwnPropertyDescriptor(source, keys[i])); + } +}; + +module.exports.wrapperSymbol = Symbol("wrapper"); +module.exports.implSymbol = Symbol("impl"); + +module.exports.wrapperForImpl = function (impl) { + return impl[module.exports.wrapperSymbol]; +}; + +module.exports.implForWrapper = function (wrapper) { + return wrapper[module.exports.implSymbol]; +}; + + + +/***/ }), + +/***/ 2940: +/***/ ((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 + } +} + + +/***/ }), + +/***/ 1252: +/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { + +const glob = __nccwpck_require__(8090); +const core = __nccwpck_require__(2186); +const fs = __nccwpck_require__(7147); +const libxmljs = __nccwpck_require__(6737); + +const resolveFileAndLine = (file, classname, output, isFilenameInOutput) => { + // extract filename from classname and remove suffix + let filename; + let filenameWithPackage; + if (isFilenameInOutput) { + filename = output.split(':')[0].trim(); + filenameWithPackage = filename + } else { + filename = file ? file : classname.split('.').slice(-1)[0].split('(')[0]; + filenameWithPackage = classname.replace(/\./g, "/"); + } + const matches = output.match(new RegExp(`${filename}.*?:\\d+`, 'g')); + if (!matches) return { filename: filename, filenameWithPackage: filenameWithPackage, line: 1 }; + + const [lastItem] = matches.slice(-1); + const [, line] = lastItem.split(':'); + core.debug(`Resolved file ${filenameWithPackage} with name ${filename} and line ${line}`); + + return { filename, filenameWithPackage, line: parseInt(line) }; +}; + +const resolvePath = async filenameWithPackage => { + if (!filenameWithPackage) { + return ''; + } + core.debug(`Resolving path for ${filenameWithPackage}`); + const globber = await glob.create([`**/${filenameWithPackage}.*`, `**/${filenameWithPackage}`].join('\n'), { followSymbolicLinks: false }); + const results = await globber.glob(); + core.debug(`Matched files: ${results}`); + const searchPath = globber.getSearchPaths()[0]; + + let path = ''; + if (results.length) { + // skip various temp folders + const found = results.find(r => !r.includes('__pycache__') && !r.endsWith('.class')); + if (found) path = found.slice(searchPath.length + 1); + else path = filenameWithPackage; + } else { + path = filenameWithPackage; + } + core.debug(`Resolved path: ${path}`); + + // canonicalize to make windows paths use forward slashes + const canonicalPath = path.replace(/\\/g, '/'); + core.debug(`Canonical path: ${canonicalPath}`); + + return canonicalPath; +}; + +async function parseFile(file, isFilenameInStackTrace) { + core.debug(`Parsing file ${file}`); + let count = 0; + let skipped = 0; + let annotations = []; + + const data = await fs.promises.readFile(file); + + const report = libxmljs.parseXml(data + "", {huge: true}); + const testsuites = report.find('//testsuite'); + + for (const testsuite of testsuites) { + const testcases = testsuite.find('testcase'); + for (const testcase of testcases) { + count++; + skipped += testcase.find('skipped').length; + let failures = testcase.find('failure | flakyFailure | error'); + if (failures.length == 0) { + continue; + } + const stackTrace = failures.map(failure => failure.text()).join('').trim(); + const message = ( + failures.map(failure => failure.attr('message')?.value()).join('') || + stackTrace.split('\n').slice(0, 2).join('\n') + ).trim(); + + const { filename, filenameWithPackage, line } = resolveFileAndLine( + testcase.attr('file')?.value() || '', + testcase.attr('classname')?.value() || '', + stackTrace, + isFilenameInStackTrace + ); + + const path = await resolvePath(filenameWithPackage); + const title = `${filename}.${testcase.attr('name')?.value()}`; + core.info(`${path}:${line} | ${message.replace(/\n/g, ' ')}`); + + annotations.push({ + path, + start_line: line, + end_line: line, + start_column: 0, + end_column: 0, + annotation_level: 'failure', + title, + message, + raw_details: stackTrace + }); + } + } + return { count, skipped, annotations }; +} + +const parseTestReports = async (reportPaths, isFilenameInStackTrace) => { + const globber = await glob.create(reportPaths, { followSymbolicLinks: false }); + let annotations = []; + let count = 0; + let skipped = 0; + for await (const file of globber.globGenerator()) { + const { count: c, skipped: s, annotations: a } = await parseFile(file, isFilenameInStackTrace); + if (c === 0) continue; + count += c; + skipped += s; + annotations = annotations.concat(a); + } + return { count, skipped, annotations }; +}; + +module.exports = { resolveFileAndLine, resolvePath, parseFile, parseTestReports }; + + +/***/ }), + +/***/ 2877: +/***/ ((module) => { + +module.exports = eval("require")("encoding"); + + +/***/ }), + +/***/ 9491: +/***/ ((module) => { + +"use strict"; +module.exports = require("assert"); + +/***/ }), + +/***/ 6113: +/***/ ((module) => { + +"use strict"; +module.exports = require("crypto"); + +/***/ }), + +/***/ 2361: +/***/ ((module) => { + +"use strict"; +module.exports = require("events"); + +/***/ }), + +/***/ 7147: +/***/ ((module) => { + +"use strict"; +module.exports = require("fs"); + +/***/ }), + +/***/ 3685: +/***/ ((module) => { + +"use strict"; +module.exports = require("http"); + +/***/ }), + +/***/ 5687: +/***/ ((module) => { + +"use strict"; +module.exports = require("https"); + +/***/ }), + +/***/ 1808: +/***/ ((module) => { + +"use strict"; +module.exports = require("net"); + +/***/ }), + +/***/ 2037: +/***/ ((module) => { + +"use strict"; +module.exports = require("os"); + +/***/ }), + +/***/ 1017: +/***/ ((module) => { + +"use strict"; +module.exports = require("path"); + +/***/ }), + +/***/ 5477: +/***/ ((module) => { + +"use strict"; +module.exports = require("punycode"); + +/***/ }), + +/***/ 2781: +/***/ ((module) => { + +"use strict"; +module.exports = require("stream"); + +/***/ }), + +/***/ 4404: +/***/ ((module) => { + +"use strict"; +module.exports = require("tls"); + +/***/ }), + +/***/ 7310: +/***/ ((module) => { + +"use strict"; +module.exports = require("url"); + +/***/ }), + +/***/ 3837: +/***/ ((module) => { + +"use strict"; +module.exports = require("util"); + +/***/ }), + +/***/ 9796: +/***/ ((module) => { + +"use strict"; +module.exports = require("zlib"); + +/***/ }), + +/***/ 2485: +/***/ ((module) => { + +"use strict"; +module.exports = JSON.parse('{"version":"0.19.10"}'); + +/***/ }), + +/***/ 2020: +/***/ ((module) => { + +"use strict"; +module.exports = JSON.parse('[[[0,44],"disallowed_STD3_valid"],[[45,46],"valid"],[[47,47],"disallowed_STD3_valid"],[[48,57],"valid"],[[58,64],"disallowed_STD3_valid"],[[65,65],"mapped",[97]],[[66,66],"mapped",[98]],[[67,67],"mapped",[99]],[[68,68],"mapped",[100]],[[69,69],"mapped",[101]],[[70,70],"mapped",[102]],[[71,71],"mapped",[103]],[[72,72],"mapped",[104]],[[73,73],"mapped",[105]],[[74,74],"mapped",[106]],[[75,75],"mapped",[107]],[[76,76],"mapped",[108]],[[77,77],"mapped",[109]],[[78,78],"mapped",[110]],[[79,79],"mapped",[111]],[[80,80],"mapped",[112]],[[81,81],"mapped",[113]],[[82,82],"mapped",[114]],[[83,83],"mapped",[115]],[[84,84],"mapped",[116]],[[85,85],"mapped",[117]],[[86,86],"mapped",[118]],[[87,87],"mapped",[119]],[[88,88],"mapped",[120]],[[89,89],"mapped",[121]],[[90,90],"mapped",[122]],[[91,96],"disallowed_STD3_valid"],[[97,122],"valid"],[[123,127],"disallowed_STD3_valid"],[[128,159],"disallowed"],[[160,160],"disallowed_STD3_mapped",[32]],[[161,167],"valid",[],"NV8"],[[168,168],"disallowed_STD3_mapped",[32,776]],[[169,169],"valid",[],"NV8"],[[170,170],"mapped",[97]],[[171,172],"valid",[],"NV8"],[[173,173],"ignored"],[[174,174],"valid",[],"NV8"],[[175,175],"disallowed_STD3_mapped",[32,772]],[[176,177],"valid",[],"NV8"],[[178,178],"mapped",[50]],[[179,179],"mapped",[51]],[[180,180],"disallowed_STD3_mapped",[32,769]],[[181,181],"mapped",[956]],[[182,182],"valid",[],"NV8"],[[183,183],"valid"],[[184,184],"disallowed_STD3_mapped",[32,807]],[[185,185],"mapped",[49]],[[186,186],"mapped",[111]],[[187,187],"valid",[],"NV8"],[[188,188],"mapped",[49,8260,52]],[[189,189],"mapped",[49,8260,50]],[[190,190],"mapped",[51,8260,52]],[[191,191],"valid",[],"NV8"],[[192,192],"mapped",[224]],[[193,193],"mapped",[225]],[[194,194],"mapped",[226]],[[195,195],"mapped",[227]],[[196,196],"mapped",[228]],[[197,197],"mapped",[229]],[[198,198],"mapped",[230]],[[199,199],"mapped",[231]],[[200,200],"mapped",[232]],[[201,201],"mapped",[233]],[[202,202],"mapped",[234]],[[203,203],"mapped",[235]],[[204,204],"mapped",[236]],[[205,205],"mapped",[237]],[[206,206],"mapped",[238]],[[207,207],"mapped",[239]],[[208,208],"mapped",[240]],[[209,209],"mapped",[241]],[[210,210],"mapped",[242]],[[211,211],"mapped",[243]],[[212,212],"mapped",[244]],[[213,213],"mapped",[245]],[[214,214],"mapped",[246]],[[215,215],"valid",[],"NV8"],[[216,216],"mapped",[248]],[[217,217],"mapped",[249]],[[218,218],"mapped",[250]],[[219,219],"mapped",[251]],[[220,220],"mapped",[252]],[[221,221],"mapped",[253]],[[222,222],"mapped",[254]],[[223,223],"deviation",[115,115]],[[224,246],"valid"],[[247,247],"valid",[],"NV8"],[[248,255],"valid"],[[256,256],"mapped",[257]],[[257,257],"valid"],[[258,258],"mapped",[259]],[[259,259],"valid"],[[260,260],"mapped",[261]],[[261,261],"valid"],[[262,262],"mapped",[263]],[[263,263],"valid"],[[264,264],"mapped",[265]],[[265,265],"valid"],[[266,266],"mapped",[267]],[[267,267],"valid"],[[268,268],"mapped",[269]],[[269,269],"valid"],[[270,270],"mapped",[271]],[[271,271],"valid"],[[272,272],"mapped",[273]],[[273,273],"valid"],[[274,274],"mapped",[275]],[[275,275],"valid"],[[276,276],"mapped",[277]],[[277,277],"valid"],[[278,278],"mapped",[279]],[[279,279],"valid"],[[280,280],"mapped",[281]],[[281,281],"valid"],[[282,282],"mapped",[283]],[[283,283],"valid"],[[284,284],"mapped",[285]],[[285,285],"valid"],[[286,286],"mapped",[287]],[[287,287],"valid"],[[288,288],"mapped",[289]],[[289,289],"valid"],[[290,290],"mapped",[291]],[[291,291],"valid"],[[292,292],"mapped",[293]],[[293,293],"valid"],[[294,294],"mapped",[295]],[[295,295],"valid"],[[296,296],"mapped",[297]],[[297,297],"valid"],[[298,298],"mapped",[299]],[[299,299],"valid"],[[300,300],"mapped",[301]],[[301,301],"valid"],[[302,302],"mapped",[303]],[[303,303],"valid"],[[304,304],"mapped",[105,775]],[[305,305],"valid"],[[306,307],"mapped",[105,106]],[[308,308],"mapped",[309]],[[309,309],"valid"],[[310,310],"mapped",[311]],[[311,312],"valid"],[[313,313],"mapped",[314]],[[314,314],"valid"],[[315,315],"mapped",[316]],[[316,316],"valid"],[[317,317],"mapped",[318]],[[318,318],"valid"],[[319,320],"mapped",[108,183]],[[321,321],"mapped",[322]],[[322,322],"valid"],[[323,323],"mapped",[324]],[[324,324],"valid"],[[325,325],"mapped",[326]],[[326,326],"valid"],[[327,327],"mapped",[328]],[[328,328],"valid"],[[329,329],"mapped",[700,110]],[[330,330],"mapped",[331]],[[331,331],"valid"],[[332,332],"mapped",[333]],[[333,333],"valid"],[[334,334],"mapped",[335]],[[335,335],"valid"],[[336,336],"mapped",[337]],[[337,337],"valid"],[[338,338],"mapped",[339]],[[339,339],"valid"],[[340,340],"mapped",[341]],[[341,341],"valid"],[[342,342],"mapped",[343]],[[343,343],"valid"],[[344,344],"mapped",[345]],[[345,345],"valid"],[[346,346],"mapped",[347]],[[347,347],"valid"],[[348,348],"mapped",[349]],[[349,349],"valid"],[[350,350],"mapped",[351]],[[351,351],"valid"],[[352,352],"mapped",[353]],[[353,353],"valid"],[[354,354],"mapped",[355]],[[355,355],"valid"],[[356,356],"mapped",[357]],[[357,357],"valid"],[[358,358],"mapped",[359]],[[359,359],"valid"],[[360,360],"mapped",[361]],[[361,361],"valid"],[[362,362],"mapped",[363]],[[363,363],"valid"],[[364,364],"mapped",[365]],[[365,365],"valid"],[[366,366],"mapped",[367]],[[367,367],"valid"],[[368,368],"mapped",[369]],[[369,369],"valid"],[[370,370],"mapped",[371]],[[371,371],"valid"],[[372,372],"mapped",[373]],[[373,373],"valid"],[[374,374],"mapped",[375]],[[375,375],"valid"],[[376,376],"mapped",[255]],[[377,377],"mapped",[378]],[[378,378],"valid"],[[379,379],"mapped",[380]],[[380,380],"valid"],[[381,381],"mapped",[382]],[[382,382],"valid"],[[383,383],"mapped",[115]],[[384,384],"valid"],[[385,385],"mapped",[595]],[[386,386],"mapped",[387]],[[387,387],"valid"],[[388,388],"mapped",[389]],[[389,389],"valid"],[[390,390],"mapped",[596]],[[391,391],"mapped",[392]],[[392,392],"valid"],[[393,393],"mapped",[598]],[[394,394],"mapped",[599]],[[395,395],"mapped",[396]],[[396,397],"valid"],[[398,398],"mapped",[477]],[[399,399],"mapped",[601]],[[400,400],"mapped",[603]],[[401,401],"mapped",[402]],[[402,402],"valid"],[[403,403],"mapped",[608]],[[404,404],"mapped",[611]],[[405,405],"valid"],[[406,406],"mapped",[617]],[[407,407],"mapped",[616]],[[408,408],"mapped",[409]],[[409,411],"valid"],[[412,412],"mapped",[623]],[[413,413],"mapped",[626]],[[414,414],"valid"],[[415,415],"mapped",[629]],[[416,416],"mapped",[417]],[[417,417],"valid"],[[418,418],"mapped",[419]],[[419,419],"valid"],[[420,420],"mapped",[421]],[[421,421],"valid"],[[422,422],"mapped",[640]],[[423,423],"mapped",[424]],[[424,424],"valid"],[[425,425],"mapped",[643]],[[426,427],"valid"],[[428,428],"mapped",[429]],[[429,429],"valid"],[[430,430],"mapped",[648]],[[431,431],"mapped",[432]],[[432,432],"valid"],[[433,433],"mapped",[650]],[[434,434],"mapped",[651]],[[435,435],"mapped",[436]],[[436,436],"valid"],[[437,437],"mapped",[438]],[[438,438],"valid"],[[439,439],"mapped",[658]],[[440,440],"mapped",[441]],[[441,443],"valid"],[[444,444],"mapped",[445]],[[445,451],"valid"],[[452,454],"mapped",[100,382]],[[455,457],"mapped",[108,106]],[[458,460],"mapped",[110,106]],[[461,461],"mapped",[462]],[[462,462],"valid"],[[463,463],"mapped",[464]],[[464,464],"valid"],[[465,465],"mapped",[466]],[[466,466],"valid"],[[467,467],"mapped",[468]],[[468,468],"valid"],[[469,469],"mapped",[470]],[[470,470],"valid"],[[471,471],"mapped",[472]],[[472,472],"valid"],[[473,473],"mapped",[474]],[[474,474],"valid"],[[475,475],"mapped",[476]],[[476,477],"valid"],[[478,478],"mapped",[479]],[[479,479],"valid"],[[480,480],"mapped",[481]],[[481,481],"valid"],[[482,482],"mapped",[483]],[[483,483],"valid"],[[484,484],"mapped",[485]],[[485,485],"valid"],[[486,486],"mapped",[487]],[[487,487],"valid"],[[488,488],"mapped",[489]],[[489,489],"valid"],[[490,490],"mapped",[491]],[[491,491],"valid"],[[492,492],"mapped",[493]],[[493,493],"valid"],[[494,494],"mapped",[495]],[[495,496],"valid"],[[497,499],"mapped",[100,122]],[[500,500],"mapped",[501]],[[501,501],"valid"],[[502,502],"mapped",[405]],[[503,503],"mapped",[447]],[[504,504],"mapped",[505]],[[505,505],"valid"],[[506,506],"mapped",[507]],[[507,507],"valid"],[[508,508],"mapped",[509]],[[509,509],"valid"],[[510,510],"mapped",[511]],[[511,511],"valid"],[[512,512],"mapped",[513]],[[513,513],"valid"],[[514,514],"mapped",[515]],[[515,515],"valid"],[[516,516],"mapped",[517]],[[517,517],"valid"],[[518,518],"mapped",[519]],[[519,519],"valid"],[[520,520],"mapped",[521]],[[521,521],"valid"],[[522,522],"mapped",[523]],[[523,523],"valid"],[[524,524],"mapped",[525]],[[525,525],"valid"],[[526,526],"mapped",[527]],[[527,527],"valid"],[[528,528],"mapped",[529]],[[529,529],"valid"],[[530,530],"mapped",[531]],[[531,531],"valid"],[[532,532],"mapped",[533]],[[533,533],"valid"],[[534,534],"mapped",[535]],[[535,535],"valid"],[[536,536],"mapped",[537]],[[537,537],"valid"],[[538,538],"mapped",[539]],[[539,539],"valid"],[[540,540],"mapped",[541]],[[541,541],"valid"],[[542,542],"mapped",[543]],[[543,543],"valid"],[[544,544],"mapped",[414]],[[545,545],"valid"],[[546,546],"mapped",[547]],[[547,547],"valid"],[[548,548],"mapped",[549]],[[549,549],"valid"],[[550,550],"mapped",[551]],[[551,551],"valid"],[[552,552],"mapped",[553]],[[553,553],"valid"],[[554,554],"mapped",[555]],[[555,555],"valid"],[[556,556],"mapped",[557]],[[557,557],"valid"],[[558,558],"mapped",[559]],[[559,559],"valid"],[[560,560],"mapped",[561]],[[561,561],"valid"],[[562,562],"mapped",[563]],[[563,563],"valid"],[[564,566],"valid"],[[567,569],"valid"],[[570,570],"mapped",[11365]],[[571,571],"mapped",[572]],[[572,572],"valid"],[[573,573],"mapped",[410]],[[574,574],"mapped",[11366]],[[575,576],"valid"],[[577,577],"mapped",[578]],[[578,578],"valid"],[[579,579],"mapped",[384]],[[580,580],"mapped",[649]],[[581,581],"mapped",[652]],[[582,582],"mapped",[583]],[[583,583],"valid"],[[584,584],"mapped",[585]],[[585,585],"valid"],[[586,586],"mapped",[587]],[[587,587],"valid"],[[588,588],"mapped",[589]],[[589,589],"valid"],[[590,590],"mapped",[591]],[[591,591],"valid"],[[592,680],"valid"],[[681,685],"valid"],[[686,687],"valid"],[[688,688],"mapped",[104]],[[689,689],"mapped",[614]],[[690,690],"mapped",[106]],[[691,691],"mapped",[114]],[[692,692],"mapped",[633]],[[693,693],"mapped",[635]],[[694,694],"mapped",[641]],[[695,695],"mapped",[119]],[[696,696],"mapped",[121]],[[697,705],"valid"],[[706,709],"valid",[],"NV8"],[[710,721],"valid"],[[722,727],"valid",[],"NV8"],[[728,728],"disallowed_STD3_mapped",[32,774]],[[729,729],"disallowed_STD3_mapped",[32,775]],[[730,730],"disallowed_STD3_mapped",[32,778]],[[731,731],"disallowed_STD3_mapped",[32,808]],[[732,732],"disallowed_STD3_mapped",[32,771]],[[733,733],"disallowed_STD3_mapped",[32,779]],[[734,734],"valid",[],"NV8"],[[735,735],"valid",[],"NV8"],[[736,736],"mapped",[611]],[[737,737],"mapped",[108]],[[738,738],"mapped",[115]],[[739,739],"mapped",[120]],[[740,740],"mapped",[661]],[[741,745],"valid",[],"NV8"],[[746,747],"valid",[],"NV8"],[[748,748],"valid"],[[749,749],"valid",[],"NV8"],[[750,750],"valid"],[[751,767],"valid",[],"NV8"],[[768,831],"valid"],[[832,832],"mapped",[768]],[[833,833],"mapped",[769]],[[834,834],"valid"],[[835,835],"mapped",[787]],[[836,836],"mapped",[776,769]],[[837,837],"mapped",[953]],[[838,846],"valid"],[[847,847],"ignored"],[[848,855],"valid"],[[856,860],"valid"],[[861,863],"valid"],[[864,865],"valid"],[[866,866],"valid"],[[867,879],"valid"],[[880,880],"mapped",[881]],[[881,881],"valid"],[[882,882],"mapped",[883]],[[883,883],"valid"],[[884,884],"mapped",[697]],[[885,885],"valid"],[[886,886],"mapped",[887]],[[887,887],"valid"],[[888,889],"disallowed"],[[890,890],"disallowed_STD3_mapped",[32,953]],[[891,893],"valid"],[[894,894],"disallowed_STD3_mapped",[59]],[[895,895],"mapped",[1011]],[[896,899],"disallowed"],[[900,900],"disallowed_STD3_mapped",[32,769]],[[901,901],"disallowed_STD3_mapped",[32,776,769]],[[902,902],"mapped",[940]],[[903,903],"mapped",[183]],[[904,904],"mapped",[941]],[[905,905],"mapped",[942]],[[906,906],"mapped",[943]],[[907,907],"disallowed"],[[908,908],"mapped",[972]],[[909,909],"disallowed"],[[910,910],"mapped",[973]],[[911,911],"mapped",[974]],[[912,912],"valid"],[[913,913],"mapped",[945]],[[914,914],"mapped",[946]],[[915,915],"mapped",[947]],[[916,916],"mapped",[948]],[[917,917],"mapped",[949]],[[918,918],"mapped",[950]],[[919,919],"mapped",[951]],[[920,920],"mapped",[952]],[[921,921],"mapped",[953]],[[922,922],"mapped",[954]],[[923,923],"mapped",[955]],[[924,924],"mapped",[956]],[[925,925],"mapped",[957]],[[926,926],"mapped",[958]],[[927,927],"mapped",[959]],[[928,928],"mapped",[960]],[[929,929],"mapped",[961]],[[930,930],"disallowed"],[[931,931],"mapped",[963]],[[932,932],"mapped",[964]],[[933,933],"mapped",[965]],[[934,934],"mapped",[966]],[[935,935],"mapped",[967]],[[936,936],"mapped",[968]],[[937,937],"mapped",[969]],[[938,938],"mapped",[970]],[[939,939],"mapped",[971]],[[940,961],"valid"],[[962,962],"deviation",[963]],[[963,974],"valid"],[[975,975],"mapped",[983]],[[976,976],"mapped",[946]],[[977,977],"mapped",[952]],[[978,978],"mapped",[965]],[[979,979],"mapped",[973]],[[980,980],"mapped",[971]],[[981,981],"mapped",[966]],[[982,982],"mapped",[960]],[[983,983],"valid"],[[984,984],"mapped",[985]],[[985,985],"valid"],[[986,986],"mapped",[987]],[[987,987],"valid"],[[988,988],"mapped",[989]],[[989,989],"valid"],[[990,990],"mapped",[991]],[[991,991],"valid"],[[992,992],"mapped",[993]],[[993,993],"valid"],[[994,994],"mapped",[995]],[[995,995],"valid"],[[996,996],"mapped",[997]],[[997,997],"valid"],[[998,998],"mapped",[999]],[[999,999],"valid"],[[1000,1000],"mapped",[1001]],[[1001,1001],"valid"],[[1002,1002],"mapped",[1003]],[[1003,1003],"valid"],[[1004,1004],"mapped",[1005]],[[1005,1005],"valid"],[[1006,1006],"mapped",[1007]],[[1007,1007],"valid"],[[1008,1008],"mapped",[954]],[[1009,1009],"mapped",[961]],[[1010,1010],"mapped",[963]],[[1011,1011],"valid"],[[1012,1012],"mapped",[952]],[[1013,1013],"mapped",[949]],[[1014,1014],"valid",[],"NV8"],[[1015,1015],"mapped",[1016]],[[1016,1016],"valid"],[[1017,1017],"mapped",[963]],[[1018,1018],"mapped",[1019]],[[1019,1019],"valid"],[[1020,1020],"valid"],[[1021,1021],"mapped",[891]],[[1022,1022],"mapped",[892]],[[1023,1023],"mapped",[893]],[[1024,1024],"mapped",[1104]],[[1025,1025],"mapped",[1105]],[[1026,1026],"mapped",[1106]],[[1027,1027],"mapped",[1107]],[[1028,1028],"mapped",[1108]],[[1029,1029],"mapped",[1109]],[[1030,1030],"mapped",[1110]],[[1031,1031],"mapped",[1111]],[[1032,1032],"mapped",[1112]],[[1033,1033],"mapped",[1113]],[[1034,1034],"mapped",[1114]],[[1035,1035],"mapped",[1115]],[[1036,1036],"mapped",[1116]],[[1037,1037],"mapped",[1117]],[[1038,1038],"mapped",[1118]],[[1039,1039],"mapped",[1119]],[[1040,1040],"mapped",[1072]],[[1041,1041],"mapped",[1073]],[[1042,1042],"mapped",[1074]],[[1043,1043],"mapped",[1075]],[[1044,1044],"mapped",[1076]],[[1045,1045],"mapped",[1077]],[[1046,1046],"mapped",[1078]],[[1047,1047],"mapped",[1079]],[[1048,1048],"mapped",[1080]],[[1049,1049],"mapped",[1081]],[[1050,1050],"mapped",[1082]],[[1051,1051],"mapped",[1083]],[[1052,1052],"mapped",[1084]],[[1053,1053],"mapped",[1085]],[[1054,1054],"mapped",[1086]],[[1055,1055],"mapped",[1087]],[[1056,1056],"mapped",[1088]],[[1057,1057],"mapped",[1089]],[[1058,1058],"mapped",[1090]],[[1059,1059],"mapped",[1091]],[[1060,1060],"mapped",[1092]],[[1061,1061],"mapped",[1093]],[[1062,1062],"mapped",[1094]],[[1063,1063],"mapped",[1095]],[[1064,1064],"mapped",[1096]],[[1065,1065],"mapped",[1097]],[[1066,1066],"mapped",[1098]],[[1067,1067],"mapped",[1099]],[[1068,1068],"mapped",[1100]],[[1069,1069],"mapped",[1101]],[[1070,1070],"mapped",[1102]],[[1071,1071],"mapped",[1103]],[[1072,1103],"valid"],[[1104,1104],"valid"],[[1105,1116],"valid"],[[1117,1117],"valid"],[[1118,1119],"valid"],[[1120,1120],"mapped",[1121]],[[1121,1121],"valid"],[[1122,1122],"mapped",[1123]],[[1123,1123],"valid"],[[1124,1124],"mapped",[1125]],[[1125,1125],"valid"],[[1126,1126],"mapped",[1127]],[[1127,1127],"valid"],[[1128,1128],"mapped",[1129]],[[1129,1129],"valid"],[[1130,1130],"mapped",[1131]],[[1131,1131],"valid"],[[1132,1132],"mapped",[1133]],[[1133,1133],"valid"],[[1134,1134],"mapped",[1135]],[[1135,1135],"valid"],[[1136,1136],"mapped",[1137]],[[1137,1137],"valid"],[[1138,1138],"mapped",[1139]],[[1139,1139],"valid"],[[1140,1140],"mapped",[1141]],[[1141,1141],"valid"],[[1142,1142],"mapped",[1143]],[[1143,1143],"valid"],[[1144,1144],"mapped",[1145]],[[1145,1145],"valid"],[[1146,1146],"mapped",[1147]],[[1147,1147],"valid"],[[1148,1148],"mapped",[1149]],[[1149,1149],"valid"],[[1150,1150],"mapped",[1151]],[[1151,1151],"valid"],[[1152,1152],"mapped",[1153]],[[1153,1153],"valid"],[[1154,1154],"valid",[],"NV8"],[[1155,1158],"valid"],[[1159,1159],"valid"],[[1160,1161],"valid",[],"NV8"],[[1162,1162],"mapped",[1163]],[[1163,1163],"valid"],[[1164,1164],"mapped",[1165]],[[1165,1165],"valid"],[[1166,1166],"mapped",[1167]],[[1167,1167],"valid"],[[1168,1168],"mapped",[1169]],[[1169,1169],"valid"],[[1170,1170],"mapped",[1171]],[[1171,1171],"valid"],[[1172,1172],"mapped",[1173]],[[1173,1173],"valid"],[[1174,1174],"mapped",[1175]],[[1175,1175],"valid"],[[1176,1176],"mapped",[1177]],[[1177,1177],"valid"],[[1178,1178],"mapped",[1179]],[[1179,1179],"valid"],[[1180,1180],"mapped",[1181]],[[1181,1181],"valid"],[[1182,1182],"mapped",[1183]],[[1183,1183],"valid"],[[1184,1184],"mapped",[1185]],[[1185,1185],"valid"],[[1186,1186],"mapped",[1187]],[[1187,1187],"valid"],[[1188,1188],"mapped",[1189]],[[1189,1189],"valid"],[[1190,1190],"mapped",[1191]],[[1191,1191],"valid"],[[1192,1192],"mapped",[1193]],[[1193,1193],"valid"],[[1194,1194],"mapped",[1195]],[[1195,1195],"valid"],[[1196,1196],"mapped",[1197]],[[1197,1197],"valid"],[[1198,1198],"mapped",[1199]],[[1199,1199],"valid"],[[1200,1200],"mapped",[1201]],[[1201,1201],"valid"],[[1202,1202],"mapped",[1203]],[[1203,1203],"valid"],[[1204,1204],"mapped",[1205]],[[1205,1205],"valid"],[[1206,1206],"mapped",[1207]],[[1207,1207],"valid"],[[1208,1208],"mapped",[1209]],[[1209,1209],"valid"],[[1210,1210],"mapped",[1211]],[[1211,1211],"valid"],[[1212,1212],"mapped",[1213]],[[1213,1213],"valid"],[[1214,1214],"mapped",[1215]],[[1215,1215],"valid"],[[1216,1216],"disallowed"],[[1217,1217],"mapped",[1218]],[[1218,1218],"valid"],[[1219,1219],"mapped",[1220]],[[1220,1220],"valid"],[[1221,1221],"mapped",[1222]],[[1222,1222],"valid"],[[1223,1223],"mapped",[1224]],[[1224,1224],"valid"],[[1225,1225],"mapped",[1226]],[[1226,1226],"valid"],[[1227,1227],"mapped",[1228]],[[1228,1228],"valid"],[[1229,1229],"mapped",[1230]],[[1230,1230],"valid"],[[1231,1231],"valid"],[[1232,1232],"mapped",[1233]],[[1233,1233],"valid"],[[1234,1234],"mapped",[1235]],[[1235,1235],"valid"],[[1236,1236],"mapped",[1237]],[[1237,1237],"valid"],[[1238,1238],"mapped",[1239]],[[1239,1239],"valid"],[[1240,1240],"mapped",[1241]],[[1241,1241],"valid"],[[1242,1242],"mapped",[1243]],[[1243,1243],"valid"],[[1244,1244],"mapped",[1245]],[[1245,1245],"valid"],[[1246,1246],"mapped",[1247]],[[1247,1247],"valid"],[[1248,1248],"mapped",[1249]],[[1249,1249],"valid"],[[1250,1250],"mapped",[1251]],[[1251,1251],"valid"],[[1252,1252],"mapped",[1253]],[[1253,1253],"valid"],[[1254,1254],"mapped",[1255]],[[1255,1255],"valid"],[[1256,1256],"mapped",[1257]],[[1257,1257],"valid"],[[1258,1258],"mapped",[1259]],[[1259,1259],"valid"],[[1260,1260],"mapped",[1261]],[[1261,1261],"valid"],[[1262,1262],"mapped",[1263]],[[1263,1263],"valid"],[[1264,1264],"mapped",[1265]],[[1265,1265],"valid"],[[1266,1266],"mapped",[1267]],[[1267,1267],"valid"],[[1268,1268],"mapped",[1269]],[[1269,1269],"valid"],[[1270,1270],"mapped",[1271]],[[1271,1271],"valid"],[[1272,1272],"mapped",[1273]],[[1273,1273],"valid"],[[1274,1274],"mapped",[1275]],[[1275,1275],"valid"],[[1276,1276],"mapped",[1277]],[[1277,1277],"valid"],[[1278,1278],"mapped",[1279]],[[1279,1279],"valid"],[[1280,1280],"mapped",[1281]],[[1281,1281],"valid"],[[1282,1282],"mapped",[1283]],[[1283,1283],"valid"],[[1284,1284],"mapped",[1285]],[[1285,1285],"valid"],[[1286,1286],"mapped",[1287]],[[1287,1287],"valid"],[[1288,1288],"mapped",[1289]],[[1289,1289],"valid"],[[1290,1290],"mapped",[1291]],[[1291,1291],"valid"],[[1292,1292],"mapped",[1293]],[[1293,1293],"valid"],[[1294,1294],"mapped",[1295]],[[1295,1295],"valid"],[[1296,1296],"mapped",[1297]],[[1297,1297],"valid"],[[1298,1298],"mapped",[1299]],[[1299,1299],"valid"],[[1300,1300],"mapped",[1301]],[[1301,1301],"valid"],[[1302,1302],"mapped",[1303]],[[1303,1303],"valid"],[[1304,1304],"mapped",[1305]],[[1305,1305],"valid"],[[1306,1306],"mapped",[1307]],[[1307,1307],"valid"],[[1308,1308],"mapped",[1309]],[[1309,1309],"valid"],[[1310,1310],"mapped",[1311]],[[1311,1311],"valid"],[[1312,1312],"mapped",[1313]],[[1313,1313],"valid"],[[1314,1314],"mapped",[1315]],[[1315,1315],"valid"],[[1316,1316],"mapped",[1317]],[[1317,1317],"valid"],[[1318,1318],"mapped",[1319]],[[1319,1319],"valid"],[[1320,1320],"mapped",[1321]],[[1321,1321],"valid"],[[1322,1322],"mapped",[1323]],[[1323,1323],"valid"],[[1324,1324],"mapped",[1325]],[[1325,1325],"valid"],[[1326,1326],"mapped",[1327]],[[1327,1327],"valid"],[[1328,1328],"disallowed"],[[1329,1329],"mapped",[1377]],[[1330,1330],"mapped",[1378]],[[1331,1331],"mapped",[1379]],[[1332,1332],"mapped",[1380]],[[1333,1333],"mapped",[1381]],[[1334,1334],"mapped",[1382]],[[1335,1335],"mapped",[1383]],[[1336,1336],"mapped",[1384]],[[1337,1337],"mapped",[1385]],[[1338,1338],"mapped",[1386]],[[1339,1339],"mapped",[1387]],[[1340,1340],"mapped",[1388]],[[1341,1341],"mapped",[1389]],[[1342,1342],"mapped",[1390]],[[1343,1343],"mapped",[1391]],[[1344,1344],"mapped",[1392]],[[1345,1345],"mapped",[1393]],[[1346,1346],"mapped",[1394]],[[1347,1347],"mapped",[1395]],[[1348,1348],"mapped",[1396]],[[1349,1349],"mapped",[1397]],[[1350,1350],"mapped",[1398]],[[1351,1351],"mapped",[1399]],[[1352,1352],"mapped",[1400]],[[1353,1353],"mapped",[1401]],[[1354,1354],"mapped",[1402]],[[1355,1355],"mapped",[1403]],[[1356,1356],"mapped",[1404]],[[1357,1357],"mapped",[1405]],[[1358,1358],"mapped",[1406]],[[1359,1359],"mapped",[1407]],[[1360,1360],"mapped",[1408]],[[1361,1361],"mapped",[1409]],[[1362,1362],"mapped",[1410]],[[1363,1363],"mapped",[1411]],[[1364,1364],"mapped",[1412]],[[1365,1365],"mapped",[1413]],[[1366,1366],"mapped",[1414]],[[1367,1368],"disallowed"],[[1369,1369],"valid"],[[1370,1375],"valid",[],"NV8"],[[1376,1376],"disallowed"],[[1377,1414],"valid"],[[1415,1415],"mapped",[1381,1410]],[[1416,1416],"disallowed"],[[1417,1417],"valid",[],"NV8"],[[1418,1418],"valid",[],"NV8"],[[1419,1420],"disallowed"],[[1421,1422],"valid",[],"NV8"],[[1423,1423],"valid",[],"NV8"],[[1424,1424],"disallowed"],[[1425,1441],"valid"],[[1442,1442],"valid"],[[1443,1455],"valid"],[[1456,1465],"valid"],[[1466,1466],"valid"],[[1467,1469],"valid"],[[1470,1470],"valid",[],"NV8"],[[1471,1471],"valid"],[[1472,1472],"valid",[],"NV8"],[[1473,1474],"valid"],[[1475,1475],"valid",[],"NV8"],[[1476,1476],"valid"],[[1477,1477],"valid"],[[1478,1478],"valid",[],"NV8"],[[1479,1479],"valid"],[[1480,1487],"disallowed"],[[1488,1514],"valid"],[[1515,1519],"disallowed"],[[1520,1524],"valid"],[[1525,1535],"disallowed"],[[1536,1539],"disallowed"],[[1540,1540],"disallowed"],[[1541,1541],"disallowed"],[[1542,1546],"valid",[],"NV8"],[[1547,1547],"valid",[],"NV8"],[[1548,1548],"valid",[],"NV8"],[[1549,1551],"valid",[],"NV8"],[[1552,1557],"valid"],[[1558,1562],"valid"],[[1563,1563],"valid",[],"NV8"],[[1564,1564],"disallowed"],[[1565,1565],"disallowed"],[[1566,1566],"valid",[],"NV8"],[[1567,1567],"valid",[],"NV8"],[[1568,1568],"valid"],[[1569,1594],"valid"],[[1595,1599],"valid"],[[1600,1600],"valid",[],"NV8"],[[1601,1618],"valid"],[[1619,1621],"valid"],[[1622,1624],"valid"],[[1625,1630],"valid"],[[1631,1631],"valid"],[[1632,1641],"valid"],[[1642,1645],"valid",[],"NV8"],[[1646,1647],"valid"],[[1648,1652],"valid"],[[1653,1653],"mapped",[1575,1652]],[[1654,1654],"mapped",[1608,1652]],[[1655,1655],"mapped",[1735,1652]],[[1656,1656],"mapped",[1610,1652]],[[1657,1719],"valid"],[[1720,1721],"valid"],[[1722,1726],"valid"],[[1727,1727],"valid"],[[1728,1742],"valid"],[[1743,1743],"valid"],[[1744,1747],"valid"],[[1748,1748],"valid",[],"NV8"],[[1749,1756],"valid"],[[1757,1757],"disallowed"],[[1758,1758],"valid",[],"NV8"],[[1759,1768],"valid"],[[1769,1769],"valid",[],"NV8"],[[1770,1773],"valid"],[[1774,1775],"valid"],[[1776,1785],"valid"],[[1786,1790],"valid"],[[1791,1791],"valid"],[[1792,1805],"valid",[],"NV8"],[[1806,1806],"disallowed"],[[1807,1807],"disallowed"],[[1808,1836],"valid"],[[1837,1839],"valid"],[[1840,1866],"valid"],[[1867,1868],"disallowed"],[[1869,1871],"valid"],[[1872,1901],"valid"],[[1902,1919],"valid"],[[1920,1968],"valid"],[[1969,1969],"valid"],[[1970,1983],"disallowed"],[[1984,2037],"valid"],[[2038,2042],"valid",[],"NV8"],[[2043,2047],"disallowed"],[[2048,2093],"valid"],[[2094,2095],"disallowed"],[[2096,2110],"valid",[],"NV8"],[[2111,2111],"disallowed"],[[2112,2139],"valid"],[[2140,2141],"disallowed"],[[2142,2142],"valid",[],"NV8"],[[2143,2207],"disallowed"],[[2208,2208],"valid"],[[2209,2209],"valid"],[[2210,2220],"valid"],[[2221,2226],"valid"],[[2227,2228],"valid"],[[2229,2274],"disallowed"],[[2275,2275],"valid"],[[2276,2302],"valid"],[[2303,2303],"valid"],[[2304,2304],"valid"],[[2305,2307],"valid"],[[2308,2308],"valid"],[[2309,2361],"valid"],[[2362,2363],"valid"],[[2364,2381],"valid"],[[2382,2382],"valid"],[[2383,2383],"valid"],[[2384,2388],"valid"],[[2389,2389],"valid"],[[2390,2391],"valid"],[[2392,2392],"mapped",[2325,2364]],[[2393,2393],"mapped",[2326,2364]],[[2394,2394],"mapped",[2327,2364]],[[2395,2395],"mapped",[2332,2364]],[[2396,2396],"mapped",[2337,2364]],[[2397,2397],"mapped",[2338,2364]],[[2398,2398],"mapped",[2347,2364]],[[2399,2399],"mapped",[2351,2364]],[[2400,2403],"valid"],[[2404,2405],"valid",[],"NV8"],[[2406,2415],"valid"],[[2416,2416],"valid",[],"NV8"],[[2417,2418],"valid"],[[2419,2423],"valid"],[[2424,2424],"valid"],[[2425,2426],"valid"],[[2427,2428],"valid"],[[2429,2429],"valid"],[[2430,2431],"valid"],[[2432,2432],"valid"],[[2433,2435],"valid"],[[2436,2436],"disallowed"],[[2437,2444],"valid"],[[2445,2446],"disallowed"],[[2447,2448],"valid"],[[2449,2450],"disallowed"],[[2451,2472],"valid"],[[2473,2473],"disallowed"],[[2474,2480],"valid"],[[2481,2481],"disallowed"],[[2482,2482],"valid"],[[2483,2485],"disallowed"],[[2486,2489],"valid"],[[2490,2491],"disallowed"],[[2492,2492],"valid"],[[2493,2493],"valid"],[[2494,2500],"valid"],[[2501,2502],"disallowed"],[[2503,2504],"valid"],[[2505,2506],"disallowed"],[[2507,2509],"valid"],[[2510,2510],"valid"],[[2511,2518],"disallowed"],[[2519,2519],"valid"],[[2520,2523],"disallowed"],[[2524,2524],"mapped",[2465,2492]],[[2525,2525],"mapped",[2466,2492]],[[2526,2526],"disallowed"],[[2527,2527],"mapped",[2479,2492]],[[2528,2531],"valid"],[[2532,2533],"disallowed"],[[2534,2545],"valid"],[[2546,2554],"valid",[],"NV8"],[[2555,2555],"valid",[],"NV8"],[[2556,2560],"disallowed"],[[2561,2561],"valid"],[[2562,2562],"valid"],[[2563,2563],"valid"],[[2564,2564],"disallowed"],[[2565,2570],"valid"],[[2571,2574],"disallowed"],[[2575,2576],"valid"],[[2577,2578],"disallowed"],[[2579,2600],"valid"],[[2601,2601],"disallowed"],[[2602,2608],"valid"],[[2609,2609],"disallowed"],[[2610,2610],"valid"],[[2611,2611],"mapped",[2610,2620]],[[2612,2612],"disallowed"],[[2613,2613],"valid"],[[2614,2614],"mapped",[2616,2620]],[[2615,2615],"disallowed"],[[2616,2617],"valid"],[[2618,2619],"disallowed"],[[2620,2620],"valid"],[[2621,2621],"disallowed"],[[2622,2626],"valid"],[[2627,2630],"disallowed"],[[2631,2632],"valid"],[[2633,2634],"disallowed"],[[2635,2637],"valid"],[[2638,2640],"disallowed"],[[2641,2641],"valid"],[[2642,2648],"disallowed"],[[2649,2649],"mapped",[2582,2620]],[[2650,2650],"mapped",[2583,2620]],[[2651,2651],"mapped",[2588,2620]],[[2652,2652],"valid"],[[2653,2653],"disallowed"],[[2654,2654],"mapped",[2603,2620]],[[2655,2661],"disallowed"],[[2662,2676],"valid"],[[2677,2677],"valid"],[[2678,2688],"disallowed"],[[2689,2691],"valid"],[[2692,2692],"disallowed"],[[2693,2699],"valid"],[[2700,2700],"valid"],[[2701,2701],"valid"],[[2702,2702],"disallowed"],[[2703,2705],"valid"],[[2706,2706],"disallowed"],[[2707,2728],"valid"],[[2729,2729],"disallowed"],[[2730,2736],"valid"],[[2737,2737],"disallowed"],[[2738,2739],"valid"],[[2740,2740],"disallowed"],[[2741,2745],"valid"],[[2746,2747],"disallowed"],[[2748,2757],"valid"],[[2758,2758],"disallowed"],[[2759,2761],"valid"],[[2762,2762],"disallowed"],[[2763,2765],"valid"],[[2766,2767],"disallowed"],[[2768,2768],"valid"],[[2769,2783],"disallowed"],[[2784,2784],"valid"],[[2785,2787],"valid"],[[2788,2789],"disallowed"],[[2790,2799],"valid"],[[2800,2800],"valid",[],"NV8"],[[2801,2801],"valid",[],"NV8"],[[2802,2808],"disallowed"],[[2809,2809],"valid"],[[2810,2816],"disallowed"],[[2817,2819],"valid"],[[2820,2820],"disallowed"],[[2821,2828],"valid"],[[2829,2830],"disallowed"],[[2831,2832],"valid"],[[2833,2834],"disallowed"],[[2835,2856],"valid"],[[2857,2857],"disallowed"],[[2858,2864],"valid"],[[2865,2865],"disallowed"],[[2866,2867],"valid"],[[2868,2868],"disallowed"],[[2869,2869],"valid"],[[2870,2873],"valid"],[[2874,2875],"disallowed"],[[2876,2883],"valid"],[[2884,2884],"valid"],[[2885,2886],"disallowed"],[[2887,2888],"valid"],[[2889,2890],"disallowed"],[[2891,2893],"valid"],[[2894,2901],"disallowed"],[[2902,2903],"valid"],[[2904,2907],"disallowed"],[[2908,2908],"mapped",[2849,2876]],[[2909,2909],"mapped",[2850,2876]],[[2910,2910],"disallowed"],[[2911,2913],"valid"],[[2914,2915],"valid"],[[2916,2917],"disallowed"],[[2918,2927],"valid"],[[2928,2928],"valid",[],"NV8"],[[2929,2929],"valid"],[[2930,2935],"valid",[],"NV8"],[[2936,2945],"disallowed"],[[2946,2947],"valid"],[[2948,2948],"disallowed"],[[2949,2954],"valid"],[[2955,2957],"disallowed"],[[2958,2960],"valid"],[[2961,2961],"disallowed"],[[2962,2965],"valid"],[[2966,2968],"disallowed"],[[2969,2970],"valid"],[[2971,2971],"disallowed"],[[2972,2972],"valid"],[[2973,2973],"disallowed"],[[2974,2975],"valid"],[[2976,2978],"disallowed"],[[2979,2980],"valid"],[[2981,2983],"disallowed"],[[2984,2986],"valid"],[[2987,2989],"disallowed"],[[2990,2997],"valid"],[[2998,2998],"valid"],[[2999,3001],"valid"],[[3002,3005],"disallowed"],[[3006,3010],"valid"],[[3011,3013],"disallowed"],[[3014,3016],"valid"],[[3017,3017],"disallowed"],[[3018,3021],"valid"],[[3022,3023],"disallowed"],[[3024,3024],"valid"],[[3025,3030],"disallowed"],[[3031,3031],"valid"],[[3032,3045],"disallowed"],[[3046,3046],"valid"],[[3047,3055],"valid"],[[3056,3058],"valid",[],"NV8"],[[3059,3066],"valid",[],"NV8"],[[3067,3071],"disallowed"],[[3072,3072],"valid"],[[3073,3075],"valid"],[[3076,3076],"disallowed"],[[3077,3084],"valid"],[[3085,3085],"disallowed"],[[3086,3088],"valid"],[[3089,3089],"disallowed"],[[3090,3112],"valid"],[[3113,3113],"disallowed"],[[3114,3123],"valid"],[[3124,3124],"valid"],[[3125,3129],"valid"],[[3130,3132],"disallowed"],[[3133,3133],"valid"],[[3134,3140],"valid"],[[3141,3141],"disallowed"],[[3142,3144],"valid"],[[3145,3145],"disallowed"],[[3146,3149],"valid"],[[3150,3156],"disallowed"],[[3157,3158],"valid"],[[3159,3159],"disallowed"],[[3160,3161],"valid"],[[3162,3162],"valid"],[[3163,3167],"disallowed"],[[3168,3169],"valid"],[[3170,3171],"valid"],[[3172,3173],"disallowed"],[[3174,3183],"valid"],[[3184,3191],"disallowed"],[[3192,3199],"valid",[],"NV8"],[[3200,3200],"disallowed"],[[3201,3201],"valid"],[[3202,3203],"valid"],[[3204,3204],"disallowed"],[[3205,3212],"valid"],[[3213,3213],"disallowed"],[[3214,3216],"valid"],[[3217,3217],"disallowed"],[[3218,3240],"valid"],[[3241,3241],"disallowed"],[[3242,3251],"valid"],[[3252,3252],"disallowed"],[[3253,3257],"valid"],[[3258,3259],"disallowed"],[[3260,3261],"valid"],[[3262,3268],"valid"],[[3269,3269],"disallowed"],[[3270,3272],"valid"],[[3273,3273],"disallowed"],[[3274,3277],"valid"],[[3278,3284],"disallowed"],[[3285,3286],"valid"],[[3287,3293],"disallowed"],[[3294,3294],"valid"],[[3295,3295],"disallowed"],[[3296,3297],"valid"],[[3298,3299],"valid"],[[3300,3301],"disallowed"],[[3302,3311],"valid"],[[3312,3312],"disallowed"],[[3313,3314],"valid"],[[3315,3328],"disallowed"],[[3329,3329],"valid"],[[3330,3331],"valid"],[[3332,3332],"disallowed"],[[3333,3340],"valid"],[[3341,3341],"disallowed"],[[3342,3344],"valid"],[[3345,3345],"disallowed"],[[3346,3368],"valid"],[[3369,3369],"valid"],[[3370,3385],"valid"],[[3386,3386],"valid"],[[3387,3388],"disallowed"],[[3389,3389],"valid"],[[3390,3395],"valid"],[[3396,3396],"valid"],[[3397,3397],"disallowed"],[[3398,3400],"valid"],[[3401,3401],"disallowed"],[[3402,3405],"valid"],[[3406,3406],"valid"],[[3407,3414],"disallowed"],[[3415,3415],"valid"],[[3416,3422],"disallowed"],[[3423,3423],"valid"],[[3424,3425],"valid"],[[3426,3427],"valid"],[[3428,3429],"disallowed"],[[3430,3439],"valid"],[[3440,3445],"valid",[],"NV8"],[[3446,3448],"disallowed"],[[3449,3449],"valid",[],"NV8"],[[3450,3455],"valid"],[[3456,3457],"disallowed"],[[3458,3459],"valid"],[[3460,3460],"disallowed"],[[3461,3478],"valid"],[[3479,3481],"disallowed"],[[3482,3505],"valid"],[[3506,3506],"disallowed"],[[3507,3515],"valid"],[[3516,3516],"disallowed"],[[3517,3517],"valid"],[[3518,3519],"disallowed"],[[3520,3526],"valid"],[[3527,3529],"disallowed"],[[3530,3530],"valid"],[[3531,3534],"disallowed"],[[3535,3540],"valid"],[[3541,3541],"disallowed"],[[3542,3542],"valid"],[[3543,3543],"disallowed"],[[3544,3551],"valid"],[[3552,3557],"disallowed"],[[3558,3567],"valid"],[[3568,3569],"disallowed"],[[3570,3571],"valid"],[[3572,3572],"valid",[],"NV8"],[[3573,3584],"disallowed"],[[3585,3634],"valid"],[[3635,3635],"mapped",[3661,3634]],[[3636,3642],"valid"],[[3643,3646],"disallowed"],[[3647,3647],"valid",[],"NV8"],[[3648,3662],"valid"],[[3663,3663],"valid",[],"NV8"],[[3664,3673],"valid"],[[3674,3675],"valid",[],"NV8"],[[3676,3712],"disallowed"],[[3713,3714],"valid"],[[3715,3715],"disallowed"],[[3716,3716],"valid"],[[3717,3718],"disallowed"],[[3719,3720],"valid"],[[3721,3721],"disallowed"],[[3722,3722],"valid"],[[3723,3724],"disallowed"],[[3725,3725],"valid"],[[3726,3731],"disallowed"],[[3732,3735],"valid"],[[3736,3736],"disallowed"],[[3737,3743],"valid"],[[3744,3744],"disallowed"],[[3745,3747],"valid"],[[3748,3748],"disallowed"],[[3749,3749],"valid"],[[3750,3750],"disallowed"],[[3751,3751],"valid"],[[3752,3753],"disallowed"],[[3754,3755],"valid"],[[3756,3756],"disallowed"],[[3757,3762],"valid"],[[3763,3763],"mapped",[3789,3762]],[[3764,3769],"valid"],[[3770,3770],"disallowed"],[[3771,3773],"valid"],[[3774,3775],"disallowed"],[[3776,3780],"valid"],[[3781,3781],"disallowed"],[[3782,3782],"valid"],[[3783,3783],"disallowed"],[[3784,3789],"valid"],[[3790,3791],"disallowed"],[[3792,3801],"valid"],[[3802,3803],"disallowed"],[[3804,3804],"mapped",[3755,3737]],[[3805,3805],"mapped",[3755,3745]],[[3806,3807],"valid"],[[3808,3839],"disallowed"],[[3840,3840],"valid"],[[3841,3850],"valid",[],"NV8"],[[3851,3851],"valid"],[[3852,3852],"mapped",[3851]],[[3853,3863],"valid",[],"NV8"],[[3864,3865],"valid"],[[3866,3871],"valid",[],"NV8"],[[3872,3881],"valid"],[[3882,3892],"valid",[],"NV8"],[[3893,3893],"valid"],[[3894,3894],"valid",[],"NV8"],[[3895,3895],"valid"],[[3896,3896],"valid",[],"NV8"],[[3897,3897],"valid"],[[3898,3901],"valid",[],"NV8"],[[3902,3906],"valid"],[[3907,3907],"mapped",[3906,4023]],[[3908,3911],"valid"],[[3912,3912],"disallowed"],[[3913,3916],"valid"],[[3917,3917],"mapped",[3916,4023]],[[3918,3921],"valid"],[[3922,3922],"mapped",[3921,4023]],[[3923,3926],"valid"],[[3927,3927],"mapped",[3926,4023]],[[3928,3931],"valid"],[[3932,3932],"mapped",[3931,4023]],[[3933,3944],"valid"],[[3945,3945],"mapped",[3904,4021]],[[3946,3946],"valid"],[[3947,3948],"valid"],[[3949,3952],"disallowed"],[[3953,3954],"valid"],[[3955,3955],"mapped",[3953,3954]],[[3956,3956],"valid"],[[3957,3957],"mapped",[3953,3956]],[[3958,3958],"mapped",[4018,3968]],[[3959,3959],"mapped",[4018,3953,3968]],[[3960,3960],"mapped",[4019,3968]],[[3961,3961],"mapped",[4019,3953,3968]],[[3962,3968],"valid"],[[3969,3969],"mapped",[3953,3968]],[[3970,3972],"valid"],[[3973,3973],"valid",[],"NV8"],[[3974,3979],"valid"],[[3980,3983],"valid"],[[3984,3986],"valid"],[[3987,3987],"mapped",[3986,4023]],[[3988,3989],"valid"],[[3990,3990],"valid"],[[3991,3991],"valid"],[[3992,3992],"disallowed"],[[3993,3996],"valid"],[[3997,3997],"mapped",[3996,4023]],[[3998,4001],"valid"],[[4002,4002],"mapped",[4001,4023]],[[4003,4006],"valid"],[[4007,4007],"mapped",[4006,4023]],[[4008,4011],"valid"],[[4012,4012],"mapped",[4011,4023]],[[4013,4013],"valid"],[[4014,4016],"valid"],[[4017,4023],"valid"],[[4024,4024],"valid"],[[4025,4025],"mapped",[3984,4021]],[[4026,4028],"valid"],[[4029,4029],"disallowed"],[[4030,4037],"valid",[],"NV8"],[[4038,4038],"valid"],[[4039,4044],"valid",[],"NV8"],[[4045,4045],"disallowed"],[[4046,4046],"valid",[],"NV8"],[[4047,4047],"valid",[],"NV8"],[[4048,4049],"valid",[],"NV8"],[[4050,4052],"valid",[],"NV8"],[[4053,4056],"valid",[],"NV8"],[[4057,4058],"valid",[],"NV8"],[[4059,4095],"disallowed"],[[4096,4129],"valid"],[[4130,4130],"valid"],[[4131,4135],"valid"],[[4136,4136],"valid"],[[4137,4138],"valid"],[[4139,4139],"valid"],[[4140,4146],"valid"],[[4147,4149],"valid"],[[4150,4153],"valid"],[[4154,4159],"valid"],[[4160,4169],"valid"],[[4170,4175],"valid",[],"NV8"],[[4176,4185],"valid"],[[4186,4249],"valid"],[[4250,4253],"valid"],[[4254,4255],"valid",[],"NV8"],[[4256,4293],"disallowed"],[[4294,4294],"disallowed"],[[4295,4295],"mapped",[11559]],[[4296,4300],"disallowed"],[[4301,4301],"mapped",[11565]],[[4302,4303],"disallowed"],[[4304,4342],"valid"],[[4343,4344],"valid"],[[4345,4346],"valid"],[[4347,4347],"valid",[],"NV8"],[[4348,4348],"mapped",[4316]],[[4349,4351],"valid"],[[4352,4441],"valid",[],"NV8"],[[4442,4446],"valid",[],"NV8"],[[4447,4448],"disallowed"],[[4449,4514],"valid",[],"NV8"],[[4515,4519],"valid",[],"NV8"],[[4520,4601],"valid",[],"NV8"],[[4602,4607],"valid",[],"NV8"],[[4608,4614],"valid"],[[4615,4615],"valid"],[[4616,4678],"valid"],[[4679,4679],"valid"],[[4680,4680],"valid"],[[4681,4681],"disallowed"],[[4682,4685],"valid"],[[4686,4687],"disallowed"],[[4688,4694],"valid"],[[4695,4695],"disallowed"],[[4696,4696],"valid"],[[4697,4697],"disallowed"],[[4698,4701],"valid"],[[4702,4703],"disallowed"],[[4704,4742],"valid"],[[4743,4743],"valid"],[[4744,4744],"valid"],[[4745,4745],"disallowed"],[[4746,4749],"valid"],[[4750,4751],"disallowed"],[[4752,4782],"valid"],[[4783,4783],"valid"],[[4784,4784],"valid"],[[4785,4785],"disallowed"],[[4786,4789],"valid"],[[4790,4791],"disallowed"],[[4792,4798],"valid"],[[4799,4799],"disallowed"],[[4800,4800],"valid"],[[4801,4801],"disallowed"],[[4802,4805],"valid"],[[4806,4807],"disallowed"],[[4808,4814],"valid"],[[4815,4815],"valid"],[[4816,4822],"valid"],[[4823,4823],"disallowed"],[[4824,4846],"valid"],[[4847,4847],"valid"],[[4848,4878],"valid"],[[4879,4879],"valid"],[[4880,4880],"valid"],[[4881,4881],"disallowed"],[[4882,4885],"valid"],[[4886,4887],"disallowed"],[[4888,4894],"valid"],[[4895,4895],"valid"],[[4896,4934],"valid"],[[4935,4935],"valid"],[[4936,4954],"valid"],[[4955,4956],"disallowed"],[[4957,4958],"valid"],[[4959,4959],"valid"],[[4960,4960],"valid",[],"NV8"],[[4961,4988],"valid",[],"NV8"],[[4989,4991],"disallowed"],[[4992,5007],"valid"],[[5008,5017],"valid",[],"NV8"],[[5018,5023],"disallowed"],[[5024,5108],"valid"],[[5109,5109],"valid"],[[5110,5111],"disallowed"],[[5112,5112],"mapped",[5104]],[[5113,5113],"mapped",[5105]],[[5114,5114],"mapped",[5106]],[[5115,5115],"mapped",[5107]],[[5116,5116],"mapped",[5108]],[[5117,5117],"mapped",[5109]],[[5118,5119],"disallowed"],[[5120,5120],"valid",[],"NV8"],[[5121,5740],"valid"],[[5741,5742],"valid",[],"NV8"],[[5743,5750],"valid"],[[5751,5759],"valid"],[[5760,5760],"disallowed"],[[5761,5786],"valid"],[[5787,5788],"valid",[],"NV8"],[[5789,5791],"disallowed"],[[5792,5866],"valid"],[[5867,5872],"valid",[],"NV8"],[[5873,5880],"valid"],[[5881,5887],"disallowed"],[[5888,5900],"valid"],[[5901,5901],"disallowed"],[[5902,5908],"valid"],[[5909,5919],"disallowed"],[[5920,5940],"valid"],[[5941,5942],"valid",[],"NV8"],[[5943,5951],"disallowed"],[[5952,5971],"valid"],[[5972,5983],"disallowed"],[[5984,5996],"valid"],[[5997,5997],"disallowed"],[[5998,6000],"valid"],[[6001,6001],"disallowed"],[[6002,6003],"valid"],[[6004,6015],"disallowed"],[[6016,6067],"valid"],[[6068,6069],"disallowed"],[[6070,6099],"valid"],[[6100,6102],"valid",[],"NV8"],[[6103,6103],"valid"],[[6104,6107],"valid",[],"NV8"],[[6108,6108],"valid"],[[6109,6109],"valid"],[[6110,6111],"disallowed"],[[6112,6121],"valid"],[[6122,6127],"disallowed"],[[6128,6137],"valid",[],"NV8"],[[6138,6143],"disallowed"],[[6144,6149],"valid",[],"NV8"],[[6150,6150],"disallowed"],[[6151,6154],"valid",[],"NV8"],[[6155,6157],"ignored"],[[6158,6158],"disallowed"],[[6159,6159],"disallowed"],[[6160,6169],"valid"],[[6170,6175],"disallowed"],[[6176,6263],"valid"],[[6264,6271],"disallowed"],[[6272,6313],"valid"],[[6314,6314],"valid"],[[6315,6319],"disallowed"],[[6320,6389],"valid"],[[6390,6399],"disallowed"],[[6400,6428],"valid"],[[6429,6430],"valid"],[[6431,6431],"disallowed"],[[6432,6443],"valid"],[[6444,6447],"disallowed"],[[6448,6459],"valid"],[[6460,6463],"disallowed"],[[6464,6464],"valid",[],"NV8"],[[6465,6467],"disallowed"],[[6468,6469],"valid",[],"NV8"],[[6470,6509],"valid"],[[6510,6511],"disallowed"],[[6512,6516],"valid"],[[6517,6527],"disallowed"],[[6528,6569],"valid"],[[6570,6571],"valid"],[[6572,6575],"disallowed"],[[6576,6601],"valid"],[[6602,6607],"disallowed"],[[6608,6617],"valid"],[[6618,6618],"valid",[],"XV8"],[[6619,6621],"disallowed"],[[6622,6623],"valid",[],"NV8"],[[6624,6655],"valid",[],"NV8"],[[6656,6683],"valid"],[[6684,6685],"disallowed"],[[6686,6687],"valid",[],"NV8"],[[6688,6750],"valid"],[[6751,6751],"disallowed"],[[6752,6780],"valid"],[[6781,6782],"disallowed"],[[6783,6793],"valid"],[[6794,6799],"disallowed"],[[6800,6809],"valid"],[[6810,6815],"disallowed"],[[6816,6822],"valid",[],"NV8"],[[6823,6823],"valid"],[[6824,6829],"valid",[],"NV8"],[[6830,6831],"disallowed"],[[6832,6845],"valid"],[[6846,6846],"valid",[],"NV8"],[[6847,6911],"disallowed"],[[6912,6987],"valid"],[[6988,6991],"disallowed"],[[6992,7001],"valid"],[[7002,7018],"valid",[],"NV8"],[[7019,7027],"valid"],[[7028,7036],"valid",[],"NV8"],[[7037,7039],"disallowed"],[[7040,7082],"valid"],[[7083,7085],"valid"],[[7086,7097],"valid"],[[7098,7103],"valid"],[[7104,7155],"valid"],[[7156,7163],"disallowed"],[[7164,7167],"valid",[],"NV8"],[[7168,7223],"valid"],[[7224,7226],"disallowed"],[[7227,7231],"valid",[],"NV8"],[[7232,7241],"valid"],[[7242,7244],"disallowed"],[[7245,7293],"valid"],[[7294,7295],"valid",[],"NV8"],[[7296,7359],"disallowed"],[[7360,7367],"valid",[],"NV8"],[[7368,7375],"disallowed"],[[7376,7378],"valid"],[[7379,7379],"valid",[],"NV8"],[[7380,7410],"valid"],[[7411,7414],"valid"],[[7415,7415],"disallowed"],[[7416,7417],"valid"],[[7418,7423],"disallowed"],[[7424,7467],"valid"],[[7468,7468],"mapped",[97]],[[7469,7469],"mapped",[230]],[[7470,7470],"mapped",[98]],[[7471,7471],"valid"],[[7472,7472],"mapped",[100]],[[7473,7473],"mapped",[101]],[[7474,7474],"mapped",[477]],[[7475,7475],"mapped",[103]],[[7476,7476],"mapped",[104]],[[7477,7477],"mapped",[105]],[[7478,7478],"mapped",[106]],[[7479,7479],"mapped",[107]],[[7480,7480],"mapped",[108]],[[7481,7481],"mapped",[109]],[[7482,7482],"mapped",[110]],[[7483,7483],"valid"],[[7484,7484],"mapped",[111]],[[7485,7485],"mapped",[547]],[[7486,7486],"mapped",[112]],[[7487,7487],"mapped",[114]],[[7488,7488],"mapped",[116]],[[7489,7489],"mapped",[117]],[[7490,7490],"mapped",[119]],[[7491,7491],"mapped",[97]],[[7492,7492],"mapped",[592]],[[7493,7493],"mapped",[593]],[[7494,7494],"mapped",[7426]],[[7495,7495],"mapped",[98]],[[7496,7496],"mapped",[100]],[[7497,7497],"mapped",[101]],[[7498,7498],"mapped",[601]],[[7499,7499],"mapped",[603]],[[7500,7500],"mapped",[604]],[[7501,7501],"mapped",[103]],[[7502,7502],"valid"],[[7503,7503],"mapped",[107]],[[7504,7504],"mapped",[109]],[[7505,7505],"mapped",[331]],[[7506,7506],"mapped",[111]],[[7507,7507],"mapped",[596]],[[7508,7508],"mapped",[7446]],[[7509,7509],"mapped",[7447]],[[7510,7510],"mapped",[112]],[[7511,7511],"mapped",[116]],[[7512,7512],"mapped",[117]],[[7513,7513],"mapped",[7453]],[[7514,7514],"mapped",[623]],[[7515,7515],"mapped",[118]],[[7516,7516],"mapped",[7461]],[[7517,7517],"mapped",[946]],[[7518,7518],"mapped",[947]],[[7519,7519],"mapped",[948]],[[7520,7520],"mapped",[966]],[[7521,7521],"mapped",[967]],[[7522,7522],"mapped",[105]],[[7523,7523],"mapped",[114]],[[7524,7524],"mapped",[117]],[[7525,7525],"mapped",[118]],[[7526,7526],"mapped",[946]],[[7527,7527],"mapped",[947]],[[7528,7528],"mapped",[961]],[[7529,7529],"mapped",[966]],[[7530,7530],"mapped",[967]],[[7531,7531],"valid"],[[7532,7543],"valid"],[[7544,7544],"mapped",[1085]],[[7545,7578],"valid"],[[7579,7579],"mapped",[594]],[[7580,7580],"mapped",[99]],[[7581,7581],"mapped",[597]],[[7582,7582],"mapped",[240]],[[7583,7583],"mapped",[604]],[[7584,7584],"mapped",[102]],[[7585,7585],"mapped",[607]],[[7586,7586],"mapped",[609]],[[7587,7587],"mapped",[613]],[[7588,7588],"mapped",[616]],[[7589,7589],"mapped",[617]],[[7590,7590],"mapped",[618]],[[7591,7591],"mapped",[7547]],[[7592,7592],"mapped",[669]],[[7593,7593],"mapped",[621]],[[7594,7594],"mapped",[7557]],[[7595,7595],"mapped",[671]],[[7596,7596],"mapped",[625]],[[7597,7597],"mapped",[624]],[[7598,7598],"mapped",[626]],[[7599,7599],"mapped",[627]],[[7600,7600],"mapped",[628]],[[7601,7601],"mapped",[629]],[[7602,7602],"mapped",[632]],[[7603,7603],"mapped",[642]],[[7604,7604],"mapped",[643]],[[7605,7605],"mapped",[427]],[[7606,7606],"mapped",[649]],[[7607,7607],"mapped",[650]],[[7608,7608],"mapped",[7452]],[[7609,7609],"mapped",[651]],[[7610,7610],"mapped",[652]],[[7611,7611],"mapped",[122]],[[7612,7612],"mapped",[656]],[[7613,7613],"mapped",[657]],[[7614,7614],"mapped",[658]],[[7615,7615],"mapped",[952]],[[7616,7619],"valid"],[[7620,7626],"valid"],[[7627,7654],"valid"],[[7655,7669],"valid"],[[7670,7675],"disallowed"],[[7676,7676],"valid"],[[7677,7677],"valid"],[[7678,7679],"valid"],[[7680,7680],"mapped",[7681]],[[7681,7681],"valid"],[[7682,7682],"mapped",[7683]],[[7683,7683],"valid"],[[7684,7684],"mapped",[7685]],[[7685,7685],"valid"],[[7686,7686],"mapped",[7687]],[[7687,7687],"valid"],[[7688,7688],"mapped",[7689]],[[7689,7689],"valid"],[[7690,7690],"mapped",[7691]],[[7691,7691],"valid"],[[7692,7692],"mapped",[7693]],[[7693,7693],"valid"],[[7694,7694],"mapped",[7695]],[[7695,7695],"valid"],[[7696,7696],"mapped",[7697]],[[7697,7697],"valid"],[[7698,7698],"mapped",[7699]],[[7699,7699],"valid"],[[7700,7700],"mapped",[7701]],[[7701,7701],"valid"],[[7702,7702],"mapped",[7703]],[[7703,7703],"valid"],[[7704,7704],"mapped",[7705]],[[7705,7705],"valid"],[[7706,7706],"mapped",[7707]],[[7707,7707],"valid"],[[7708,7708],"mapped",[7709]],[[7709,7709],"valid"],[[7710,7710],"mapped",[7711]],[[7711,7711],"valid"],[[7712,7712],"mapped",[7713]],[[7713,7713],"valid"],[[7714,7714],"mapped",[7715]],[[7715,7715],"valid"],[[7716,7716],"mapped",[7717]],[[7717,7717],"valid"],[[7718,7718],"mapped",[7719]],[[7719,7719],"valid"],[[7720,7720],"mapped",[7721]],[[7721,7721],"valid"],[[7722,7722],"mapped",[7723]],[[7723,7723],"valid"],[[7724,7724],"mapped",[7725]],[[7725,7725],"valid"],[[7726,7726],"mapped",[7727]],[[7727,7727],"valid"],[[7728,7728],"mapped",[7729]],[[7729,7729],"valid"],[[7730,7730],"mapped",[7731]],[[7731,7731],"valid"],[[7732,7732],"mapped",[7733]],[[7733,7733],"valid"],[[7734,7734],"mapped",[7735]],[[7735,7735],"valid"],[[7736,7736],"mapped",[7737]],[[7737,7737],"valid"],[[7738,7738],"mapped",[7739]],[[7739,7739],"valid"],[[7740,7740],"mapped",[7741]],[[7741,7741],"valid"],[[7742,7742],"mapped",[7743]],[[7743,7743],"valid"],[[7744,7744],"mapped",[7745]],[[7745,7745],"valid"],[[7746,7746],"mapped",[7747]],[[7747,7747],"valid"],[[7748,7748],"mapped",[7749]],[[7749,7749],"valid"],[[7750,7750],"mapped",[7751]],[[7751,7751],"valid"],[[7752,7752],"mapped",[7753]],[[7753,7753],"valid"],[[7754,7754],"mapped",[7755]],[[7755,7755],"valid"],[[7756,7756],"mapped",[7757]],[[7757,7757],"valid"],[[7758,7758],"mapped",[7759]],[[7759,7759],"valid"],[[7760,7760],"mapped",[7761]],[[7761,7761],"valid"],[[7762,7762],"mapped",[7763]],[[7763,7763],"valid"],[[7764,7764],"mapped",[7765]],[[7765,7765],"valid"],[[7766,7766],"mapped",[7767]],[[7767,7767],"valid"],[[7768,7768],"mapped",[7769]],[[7769,7769],"valid"],[[7770,7770],"mapped",[7771]],[[7771,7771],"valid"],[[7772,7772],"mapped",[7773]],[[7773,7773],"valid"],[[7774,7774],"mapped",[7775]],[[7775,7775],"valid"],[[7776,7776],"mapped",[7777]],[[7777,7777],"valid"],[[7778,7778],"mapped",[7779]],[[7779,7779],"valid"],[[7780,7780],"mapped",[7781]],[[7781,7781],"valid"],[[7782,7782],"mapped",[7783]],[[7783,7783],"valid"],[[7784,7784],"mapped",[7785]],[[7785,7785],"valid"],[[7786,7786],"mapped",[7787]],[[7787,7787],"valid"],[[7788,7788],"mapped",[7789]],[[7789,7789],"valid"],[[7790,7790],"mapped",[7791]],[[7791,7791],"valid"],[[7792,7792],"mapped",[7793]],[[7793,7793],"valid"],[[7794,7794],"mapped",[7795]],[[7795,7795],"valid"],[[7796,7796],"mapped",[7797]],[[7797,7797],"valid"],[[7798,7798],"mapped",[7799]],[[7799,7799],"valid"],[[7800,7800],"mapped",[7801]],[[7801,7801],"valid"],[[7802,7802],"mapped",[7803]],[[7803,7803],"valid"],[[7804,7804],"mapped",[7805]],[[7805,7805],"valid"],[[7806,7806],"mapped",[7807]],[[7807,7807],"valid"],[[7808,7808],"mapped",[7809]],[[7809,7809],"valid"],[[7810,7810],"mapped",[7811]],[[7811,7811],"valid"],[[7812,7812],"mapped",[7813]],[[7813,7813],"valid"],[[7814,7814],"mapped",[7815]],[[7815,7815],"valid"],[[7816,7816],"mapped",[7817]],[[7817,7817],"valid"],[[7818,7818],"mapped",[7819]],[[7819,7819],"valid"],[[7820,7820],"mapped",[7821]],[[7821,7821],"valid"],[[7822,7822],"mapped",[7823]],[[7823,7823],"valid"],[[7824,7824],"mapped",[7825]],[[7825,7825],"valid"],[[7826,7826],"mapped",[7827]],[[7827,7827],"valid"],[[7828,7828],"mapped",[7829]],[[7829,7833],"valid"],[[7834,7834],"mapped",[97,702]],[[7835,7835],"mapped",[7777]],[[7836,7837],"valid"],[[7838,7838],"mapped",[115,115]],[[7839,7839],"valid"],[[7840,7840],"mapped",[7841]],[[7841,7841],"valid"],[[7842,7842],"mapped",[7843]],[[7843,7843],"valid"],[[7844,7844],"mapped",[7845]],[[7845,7845],"valid"],[[7846,7846],"mapped",[7847]],[[7847,7847],"valid"],[[7848,7848],"mapped",[7849]],[[7849,7849],"valid"],[[7850,7850],"mapped",[7851]],[[7851,7851],"valid"],[[7852,7852],"mapped",[7853]],[[7853,7853],"valid"],[[7854,7854],"mapped",[7855]],[[7855,7855],"valid"],[[7856,7856],"mapped",[7857]],[[7857,7857],"valid"],[[7858,7858],"mapped",[7859]],[[7859,7859],"valid"],[[7860,7860],"mapped",[7861]],[[7861,7861],"valid"],[[7862,7862],"mapped",[7863]],[[7863,7863],"valid"],[[7864,7864],"mapped",[7865]],[[7865,7865],"valid"],[[7866,7866],"mapped",[7867]],[[7867,7867],"valid"],[[7868,7868],"mapped",[7869]],[[7869,7869],"valid"],[[7870,7870],"mapped",[7871]],[[7871,7871],"valid"],[[7872,7872],"mapped",[7873]],[[7873,7873],"valid"],[[7874,7874],"mapped",[7875]],[[7875,7875],"valid"],[[7876,7876],"mapped",[7877]],[[7877,7877],"valid"],[[7878,7878],"mapped",[7879]],[[7879,7879],"valid"],[[7880,7880],"mapped",[7881]],[[7881,7881],"valid"],[[7882,7882],"mapped",[7883]],[[7883,7883],"valid"],[[7884,7884],"mapped",[7885]],[[7885,7885],"valid"],[[7886,7886],"mapped",[7887]],[[7887,7887],"valid"],[[7888,7888],"mapped",[7889]],[[7889,7889],"valid"],[[7890,7890],"mapped",[7891]],[[7891,7891],"valid"],[[7892,7892],"mapped",[7893]],[[7893,7893],"valid"],[[7894,7894],"mapped",[7895]],[[7895,7895],"valid"],[[7896,7896],"mapped",[7897]],[[7897,7897],"valid"],[[7898,7898],"mapped",[7899]],[[7899,7899],"valid"],[[7900,7900],"mapped",[7901]],[[7901,7901],"valid"],[[7902,7902],"mapped",[7903]],[[7903,7903],"valid"],[[7904,7904],"mapped",[7905]],[[7905,7905],"valid"],[[7906,7906],"mapped",[7907]],[[7907,7907],"valid"],[[7908,7908],"mapped",[7909]],[[7909,7909],"valid"],[[7910,7910],"mapped",[7911]],[[7911,7911],"valid"],[[7912,7912],"mapped",[7913]],[[7913,7913],"valid"],[[7914,7914],"mapped",[7915]],[[7915,7915],"valid"],[[7916,7916],"mapped",[7917]],[[7917,7917],"valid"],[[7918,7918],"mapped",[7919]],[[7919,7919],"valid"],[[7920,7920],"mapped",[7921]],[[7921,7921],"valid"],[[7922,7922],"mapped",[7923]],[[7923,7923],"valid"],[[7924,7924],"mapped",[7925]],[[7925,7925],"valid"],[[7926,7926],"mapped",[7927]],[[7927,7927],"valid"],[[7928,7928],"mapped",[7929]],[[7929,7929],"valid"],[[7930,7930],"mapped",[7931]],[[7931,7931],"valid"],[[7932,7932],"mapped",[7933]],[[7933,7933],"valid"],[[7934,7934],"mapped",[7935]],[[7935,7935],"valid"],[[7936,7943],"valid"],[[7944,7944],"mapped",[7936]],[[7945,7945],"mapped",[7937]],[[7946,7946],"mapped",[7938]],[[7947,7947],"mapped",[7939]],[[7948,7948],"mapped",[7940]],[[7949,7949],"mapped",[7941]],[[7950,7950],"mapped",[7942]],[[7951,7951],"mapped",[7943]],[[7952,7957],"valid"],[[7958,7959],"disallowed"],[[7960,7960],"mapped",[7952]],[[7961,7961],"mapped",[7953]],[[7962,7962],"mapped",[7954]],[[7963,7963],"mapped",[7955]],[[7964,7964],"mapped",[7956]],[[7965,7965],"mapped",[7957]],[[7966,7967],"disallowed"],[[7968,7975],"valid"],[[7976,7976],"mapped",[7968]],[[7977,7977],"mapped",[7969]],[[7978,7978],"mapped",[7970]],[[7979,7979],"mapped",[7971]],[[7980,7980],"mapped",[7972]],[[7981,7981],"mapped",[7973]],[[7982,7982],"mapped",[7974]],[[7983,7983],"mapped",[7975]],[[7984,7991],"valid"],[[7992,7992],"mapped",[7984]],[[7993,7993],"mapped",[7985]],[[7994,7994],"mapped",[7986]],[[7995,7995],"mapped",[7987]],[[7996,7996],"mapped",[7988]],[[7997,7997],"mapped",[7989]],[[7998,7998],"mapped",[7990]],[[7999,7999],"mapped",[7991]],[[8000,8005],"valid"],[[8006,8007],"disallowed"],[[8008,8008],"mapped",[8000]],[[8009,8009],"mapped",[8001]],[[8010,8010],"mapped",[8002]],[[8011,8011],"mapped",[8003]],[[8012,8012],"mapped",[8004]],[[8013,8013],"mapped",[8005]],[[8014,8015],"disallowed"],[[8016,8023],"valid"],[[8024,8024],"disallowed"],[[8025,8025],"mapped",[8017]],[[8026,8026],"disallowed"],[[8027,8027],"mapped",[8019]],[[8028,8028],"disallowed"],[[8029,8029],"mapped",[8021]],[[8030,8030],"disallowed"],[[8031,8031],"mapped",[8023]],[[8032,8039],"valid"],[[8040,8040],"mapped",[8032]],[[8041,8041],"mapped",[8033]],[[8042,8042],"mapped",[8034]],[[8043,8043],"mapped",[8035]],[[8044,8044],"mapped",[8036]],[[8045,8045],"mapped",[8037]],[[8046,8046],"mapped",[8038]],[[8047,8047],"mapped",[8039]],[[8048,8048],"valid"],[[8049,8049],"mapped",[940]],[[8050,8050],"valid"],[[8051,8051],"mapped",[941]],[[8052,8052],"valid"],[[8053,8053],"mapped",[942]],[[8054,8054],"valid"],[[8055,8055],"mapped",[943]],[[8056,8056],"valid"],[[8057,8057],"mapped",[972]],[[8058,8058],"valid"],[[8059,8059],"mapped",[973]],[[8060,8060],"valid"],[[8061,8061],"mapped",[974]],[[8062,8063],"disallowed"],[[8064,8064],"mapped",[7936,953]],[[8065,8065],"mapped",[7937,953]],[[8066,8066],"mapped",[7938,953]],[[8067,8067],"mapped",[7939,953]],[[8068,8068],"mapped",[7940,953]],[[8069,8069],"mapped",[7941,953]],[[8070,8070],"mapped",[7942,953]],[[8071,8071],"mapped",[7943,953]],[[8072,8072],"mapped",[7936,953]],[[8073,8073],"mapped",[7937,953]],[[8074,8074],"mapped",[7938,953]],[[8075,8075],"mapped",[7939,953]],[[8076,8076],"mapped",[7940,953]],[[8077,8077],"mapped",[7941,953]],[[8078,8078],"mapped",[7942,953]],[[8079,8079],"mapped",[7943,953]],[[8080,8080],"mapped",[7968,953]],[[8081,8081],"mapped",[7969,953]],[[8082,8082],"mapped",[7970,953]],[[8083,8083],"mapped",[7971,953]],[[8084,8084],"mapped",[7972,953]],[[8085,8085],"mapped",[7973,953]],[[8086,8086],"mapped",[7974,953]],[[8087,8087],"mapped",[7975,953]],[[8088,8088],"mapped",[7968,953]],[[8089,8089],"mapped",[7969,953]],[[8090,8090],"mapped",[7970,953]],[[8091,8091],"mapped",[7971,953]],[[8092,8092],"mapped",[7972,953]],[[8093,8093],"mapped",[7973,953]],[[8094,8094],"mapped",[7974,953]],[[8095,8095],"mapped",[7975,953]],[[8096,8096],"mapped",[8032,953]],[[8097,8097],"mapped",[8033,953]],[[8098,8098],"mapped",[8034,953]],[[8099,8099],"mapped",[8035,953]],[[8100,8100],"mapped",[8036,953]],[[8101,8101],"mapped",[8037,953]],[[8102,8102],"mapped",[8038,953]],[[8103,8103],"mapped",[8039,953]],[[8104,8104],"mapped",[8032,953]],[[8105,8105],"mapped",[8033,953]],[[8106,8106],"mapped",[8034,953]],[[8107,8107],"mapped",[8035,953]],[[8108,8108],"mapped",[8036,953]],[[8109,8109],"mapped",[8037,953]],[[8110,8110],"mapped",[8038,953]],[[8111,8111],"mapped",[8039,953]],[[8112,8113],"valid"],[[8114,8114],"mapped",[8048,953]],[[8115,8115],"mapped",[945,953]],[[8116,8116],"mapped",[940,953]],[[8117,8117],"disallowed"],[[8118,8118],"valid"],[[8119,8119],"mapped",[8118,953]],[[8120,8120],"mapped",[8112]],[[8121,8121],"mapped",[8113]],[[8122,8122],"mapped",[8048]],[[8123,8123],"mapped",[940]],[[8124,8124],"mapped",[945,953]],[[8125,8125],"disallowed_STD3_mapped",[32,787]],[[8126,8126],"mapped",[953]],[[8127,8127],"disallowed_STD3_mapped",[32,787]],[[8128,8128],"disallowed_STD3_mapped",[32,834]],[[8129,8129],"disallowed_STD3_mapped",[32,776,834]],[[8130,8130],"mapped",[8052,953]],[[8131,8131],"mapped",[951,953]],[[8132,8132],"mapped",[942,953]],[[8133,8133],"disallowed"],[[8134,8134],"valid"],[[8135,8135],"mapped",[8134,953]],[[8136,8136],"mapped",[8050]],[[8137,8137],"mapped",[941]],[[8138,8138],"mapped",[8052]],[[8139,8139],"mapped",[942]],[[8140,8140],"mapped",[951,953]],[[8141,8141],"disallowed_STD3_mapped",[32,787,768]],[[8142,8142],"disallowed_STD3_mapped",[32,787,769]],[[8143,8143],"disallowed_STD3_mapped",[32,787,834]],[[8144,8146],"valid"],[[8147,8147],"mapped",[912]],[[8148,8149],"disallowed"],[[8150,8151],"valid"],[[8152,8152],"mapped",[8144]],[[8153,8153],"mapped",[8145]],[[8154,8154],"mapped",[8054]],[[8155,8155],"mapped",[943]],[[8156,8156],"disallowed"],[[8157,8157],"disallowed_STD3_mapped",[32,788,768]],[[8158,8158],"disallowed_STD3_mapped",[32,788,769]],[[8159,8159],"disallowed_STD3_mapped",[32,788,834]],[[8160,8162],"valid"],[[8163,8163],"mapped",[944]],[[8164,8167],"valid"],[[8168,8168],"mapped",[8160]],[[8169,8169],"mapped",[8161]],[[8170,8170],"mapped",[8058]],[[8171,8171],"mapped",[973]],[[8172,8172],"mapped",[8165]],[[8173,8173],"disallowed_STD3_mapped",[32,776,768]],[[8174,8174],"disallowed_STD3_mapped",[32,776,769]],[[8175,8175],"disallowed_STD3_mapped",[96]],[[8176,8177],"disallowed"],[[8178,8178],"mapped",[8060,953]],[[8179,8179],"mapped",[969,953]],[[8180,8180],"mapped",[974,953]],[[8181,8181],"disallowed"],[[8182,8182],"valid"],[[8183,8183],"mapped",[8182,953]],[[8184,8184],"mapped",[8056]],[[8185,8185],"mapped",[972]],[[8186,8186],"mapped",[8060]],[[8187,8187],"mapped",[974]],[[8188,8188],"mapped",[969,953]],[[8189,8189],"disallowed_STD3_mapped",[32,769]],[[8190,8190],"disallowed_STD3_mapped",[32,788]],[[8191,8191],"disallowed"],[[8192,8202],"disallowed_STD3_mapped",[32]],[[8203,8203],"ignored"],[[8204,8205],"deviation",[]],[[8206,8207],"disallowed"],[[8208,8208],"valid",[],"NV8"],[[8209,8209],"mapped",[8208]],[[8210,8214],"valid",[],"NV8"],[[8215,8215],"disallowed_STD3_mapped",[32,819]],[[8216,8227],"valid",[],"NV8"],[[8228,8230],"disallowed"],[[8231,8231],"valid",[],"NV8"],[[8232,8238],"disallowed"],[[8239,8239],"disallowed_STD3_mapped",[32]],[[8240,8242],"valid",[],"NV8"],[[8243,8243],"mapped",[8242,8242]],[[8244,8244],"mapped",[8242,8242,8242]],[[8245,8245],"valid",[],"NV8"],[[8246,8246],"mapped",[8245,8245]],[[8247,8247],"mapped",[8245,8245,8245]],[[8248,8251],"valid",[],"NV8"],[[8252,8252],"disallowed_STD3_mapped",[33,33]],[[8253,8253],"valid",[],"NV8"],[[8254,8254],"disallowed_STD3_mapped",[32,773]],[[8255,8262],"valid",[],"NV8"],[[8263,8263],"disallowed_STD3_mapped",[63,63]],[[8264,8264],"disallowed_STD3_mapped",[63,33]],[[8265,8265],"disallowed_STD3_mapped",[33,63]],[[8266,8269],"valid",[],"NV8"],[[8270,8274],"valid",[],"NV8"],[[8275,8276],"valid",[],"NV8"],[[8277,8278],"valid",[],"NV8"],[[8279,8279],"mapped",[8242,8242,8242,8242]],[[8280,8286],"valid",[],"NV8"],[[8287,8287],"disallowed_STD3_mapped",[32]],[[8288,8288],"ignored"],[[8289,8291],"disallowed"],[[8292,8292],"ignored"],[[8293,8293],"disallowed"],[[8294,8297],"disallowed"],[[8298,8303],"disallowed"],[[8304,8304],"mapped",[48]],[[8305,8305],"mapped",[105]],[[8306,8307],"disallowed"],[[8308,8308],"mapped",[52]],[[8309,8309],"mapped",[53]],[[8310,8310],"mapped",[54]],[[8311,8311],"mapped",[55]],[[8312,8312],"mapped",[56]],[[8313,8313],"mapped",[57]],[[8314,8314],"disallowed_STD3_mapped",[43]],[[8315,8315],"mapped",[8722]],[[8316,8316],"disallowed_STD3_mapped",[61]],[[8317,8317],"disallowed_STD3_mapped",[40]],[[8318,8318],"disallowed_STD3_mapped",[41]],[[8319,8319],"mapped",[110]],[[8320,8320],"mapped",[48]],[[8321,8321],"mapped",[49]],[[8322,8322],"mapped",[50]],[[8323,8323],"mapped",[51]],[[8324,8324],"mapped",[52]],[[8325,8325],"mapped",[53]],[[8326,8326],"mapped",[54]],[[8327,8327],"mapped",[55]],[[8328,8328],"mapped",[56]],[[8329,8329],"mapped",[57]],[[8330,8330],"disallowed_STD3_mapped",[43]],[[8331,8331],"mapped",[8722]],[[8332,8332],"disallowed_STD3_mapped",[61]],[[8333,8333],"disallowed_STD3_mapped",[40]],[[8334,8334],"disallowed_STD3_mapped",[41]],[[8335,8335],"disallowed"],[[8336,8336],"mapped",[97]],[[8337,8337],"mapped",[101]],[[8338,8338],"mapped",[111]],[[8339,8339],"mapped",[120]],[[8340,8340],"mapped",[601]],[[8341,8341],"mapped",[104]],[[8342,8342],"mapped",[107]],[[8343,8343],"mapped",[108]],[[8344,8344],"mapped",[109]],[[8345,8345],"mapped",[110]],[[8346,8346],"mapped",[112]],[[8347,8347],"mapped",[115]],[[8348,8348],"mapped",[116]],[[8349,8351],"disallowed"],[[8352,8359],"valid",[],"NV8"],[[8360,8360],"mapped",[114,115]],[[8361,8362],"valid",[],"NV8"],[[8363,8363],"valid",[],"NV8"],[[8364,8364],"valid",[],"NV8"],[[8365,8367],"valid",[],"NV8"],[[8368,8369],"valid",[],"NV8"],[[8370,8373],"valid",[],"NV8"],[[8374,8376],"valid",[],"NV8"],[[8377,8377],"valid",[],"NV8"],[[8378,8378],"valid",[],"NV8"],[[8379,8381],"valid",[],"NV8"],[[8382,8382],"valid",[],"NV8"],[[8383,8399],"disallowed"],[[8400,8417],"valid",[],"NV8"],[[8418,8419],"valid",[],"NV8"],[[8420,8426],"valid",[],"NV8"],[[8427,8427],"valid",[],"NV8"],[[8428,8431],"valid",[],"NV8"],[[8432,8432],"valid",[],"NV8"],[[8433,8447],"disallowed"],[[8448,8448],"disallowed_STD3_mapped",[97,47,99]],[[8449,8449],"disallowed_STD3_mapped",[97,47,115]],[[8450,8450],"mapped",[99]],[[8451,8451],"mapped",[176,99]],[[8452,8452],"valid",[],"NV8"],[[8453,8453],"disallowed_STD3_mapped",[99,47,111]],[[8454,8454],"disallowed_STD3_mapped",[99,47,117]],[[8455,8455],"mapped",[603]],[[8456,8456],"valid",[],"NV8"],[[8457,8457],"mapped",[176,102]],[[8458,8458],"mapped",[103]],[[8459,8462],"mapped",[104]],[[8463,8463],"mapped",[295]],[[8464,8465],"mapped",[105]],[[8466,8467],"mapped",[108]],[[8468,8468],"valid",[],"NV8"],[[8469,8469],"mapped",[110]],[[8470,8470],"mapped",[110,111]],[[8471,8472],"valid",[],"NV8"],[[8473,8473],"mapped",[112]],[[8474,8474],"mapped",[113]],[[8475,8477],"mapped",[114]],[[8478,8479],"valid",[],"NV8"],[[8480,8480],"mapped",[115,109]],[[8481,8481],"mapped",[116,101,108]],[[8482,8482],"mapped",[116,109]],[[8483,8483],"valid",[],"NV8"],[[8484,8484],"mapped",[122]],[[8485,8485],"valid",[],"NV8"],[[8486,8486],"mapped",[969]],[[8487,8487],"valid",[],"NV8"],[[8488,8488],"mapped",[122]],[[8489,8489],"valid",[],"NV8"],[[8490,8490],"mapped",[107]],[[8491,8491],"mapped",[229]],[[8492,8492],"mapped",[98]],[[8493,8493],"mapped",[99]],[[8494,8494],"valid",[],"NV8"],[[8495,8496],"mapped",[101]],[[8497,8497],"mapped",[102]],[[8498,8498],"disallowed"],[[8499,8499],"mapped",[109]],[[8500,8500],"mapped",[111]],[[8501,8501],"mapped",[1488]],[[8502,8502],"mapped",[1489]],[[8503,8503],"mapped",[1490]],[[8504,8504],"mapped",[1491]],[[8505,8505],"mapped",[105]],[[8506,8506],"valid",[],"NV8"],[[8507,8507],"mapped",[102,97,120]],[[8508,8508],"mapped",[960]],[[8509,8510],"mapped",[947]],[[8511,8511],"mapped",[960]],[[8512,8512],"mapped",[8721]],[[8513,8516],"valid",[],"NV8"],[[8517,8518],"mapped",[100]],[[8519,8519],"mapped",[101]],[[8520,8520],"mapped",[105]],[[8521,8521],"mapped",[106]],[[8522,8523],"valid",[],"NV8"],[[8524,8524],"valid",[],"NV8"],[[8525,8525],"valid",[],"NV8"],[[8526,8526],"valid"],[[8527,8527],"valid",[],"NV8"],[[8528,8528],"mapped",[49,8260,55]],[[8529,8529],"mapped",[49,8260,57]],[[8530,8530],"mapped",[49,8260,49,48]],[[8531,8531],"mapped",[49,8260,51]],[[8532,8532],"mapped",[50,8260,51]],[[8533,8533],"mapped",[49,8260,53]],[[8534,8534],"mapped",[50,8260,53]],[[8535,8535],"mapped",[51,8260,53]],[[8536,8536],"mapped",[52,8260,53]],[[8537,8537],"mapped",[49,8260,54]],[[8538,8538],"mapped",[53,8260,54]],[[8539,8539],"mapped",[49,8260,56]],[[8540,8540],"mapped",[51,8260,56]],[[8541,8541],"mapped",[53,8260,56]],[[8542,8542],"mapped",[55,8260,56]],[[8543,8543],"mapped",[49,8260]],[[8544,8544],"mapped",[105]],[[8545,8545],"mapped",[105,105]],[[8546,8546],"mapped",[105,105,105]],[[8547,8547],"mapped",[105,118]],[[8548,8548],"mapped",[118]],[[8549,8549],"mapped",[118,105]],[[8550,8550],"mapped",[118,105,105]],[[8551,8551],"mapped",[118,105,105,105]],[[8552,8552],"mapped",[105,120]],[[8553,8553],"mapped",[120]],[[8554,8554],"mapped",[120,105]],[[8555,8555],"mapped",[120,105,105]],[[8556,8556],"mapped",[108]],[[8557,8557],"mapped",[99]],[[8558,8558],"mapped",[100]],[[8559,8559],"mapped",[109]],[[8560,8560],"mapped",[105]],[[8561,8561],"mapped",[105,105]],[[8562,8562],"mapped",[105,105,105]],[[8563,8563],"mapped",[105,118]],[[8564,8564],"mapped",[118]],[[8565,8565],"mapped",[118,105]],[[8566,8566],"mapped",[118,105,105]],[[8567,8567],"mapped",[118,105,105,105]],[[8568,8568],"mapped",[105,120]],[[8569,8569],"mapped",[120]],[[8570,8570],"mapped",[120,105]],[[8571,8571],"mapped",[120,105,105]],[[8572,8572],"mapped",[108]],[[8573,8573],"mapped",[99]],[[8574,8574],"mapped",[100]],[[8575,8575],"mapped",[109]],[[8576,8578],"valid",[],"NV8"],[[8579,8579],"disallowed"],[[8580,8580],"valid"],[[8581,8584],"valid",[],"NV8"],[[8585,8585],"mapped",[48,8260,51]],[[8586,8587],"valid",[],"NV8"],[[8588,8591],"disallowed"],[[8592,8682],"valid",[],"NV8"],[[8683,8691],"valid",[],"NV8"],[[8692,8703],"valid",[],"NV8"],[[8704,8747],"valid",[],"NV8"],[[8748,8748],"mapped",[8747,8747]],[[8749,8749],"mapped",[8747,8747,8747]],[[8750,8750],"valid",[],"NV8"],[[8751,8751],"mapped",[8750,8750]],[[8752,8752],"mapped",[8750,8750,8750]],[[8753,8799],"valid",[],"NV8"],[[8800,8800],"disallowed_STD3_valid"],[[8801,8813],"valid",[],"NV8"],[[8814,8815],"disallowed_STD3_valid"],[[8816,8945],"valid",[],"NV8"],[[8946,8959],"valid",[],"NV8"],[[8960,8960],"valid",[],"NV8"],[[8961,8961],"valid",[],"NV8"],[[8962,9000],"valid",[],"NV8"],[[9001,9001],"mapped",[12296]],[[9002,9002],"mapped",[12297]],[[9003,9082],"valid",[],"NV8"],[[9083,9083],"valid",[],"NV8"],[[9084,9084],"valid",[],"NV8"],[[9085,9114],"valid",[],"NV8"],[[9115,9166],"valid",[],"NV8"],[[9167,9168],"valid",[],"NV8"],[[9169,9179],"valid",[],"NV8"],[[9180,9191],"valid",[],"NV8"],[[9192,9192],"valid",[],"NV8"],[[9193,9203],"valid",[],"NV8"],[[9204,9210],"valid",[],"NV8"],[[9211,9215],"disallowed"],[[9216,9252],"valid",[],"NV8"],[[9253,9254],"valid",[],"NV8"],[[9255,9279],"disallowed"],[[9280,9290],"valid",[],"NV8"],[[9291,9311],"disallowed"],[[9312,9312],"mapped",[49]],[[9313,9313],"mapped",[50]],[[9314,9314],"mapped",[51]],[[9315,9315],"mapped",[52]],[[9316,9316],"mapped",[53]],[[9317,9317],"mapped",[54]],[[9318,9318],"mapped",[55]],[[9319,9319],"mapped",[56]],[[9320,9320],"mapped",[57]],[[9321,9321],"mapped",[49,48]],[[9322,9322],"mapped",[49,49]],[[9323,9323],"mapped",[49,50]],[[9324,9324],"mapped",[49,51]],[[9325,9325],"mapped",[49,52]],[[9326,9326],"mapped",[49,53]],[[9327,9327],"mapped",[49,54]],[[9328,9328],"mapped",[49,55]],[[9329,9329],"mapped",[49,56]],[[9330,9330],"mapped",[49,57]],[[9331,9331],"mapped",[50,48]],[[9332,9332],"disallowed_STD3_mapped",[40,49,41]],[[9333,9333],"disallowed_STD3_mapped",[40,50,41]],[[9334,9334],"disallowed_STD3_mapped",[40,51,41]],[[9335,9335],"disallowed_STD3_mapped",[40,52,41]],[[9336,9336],"disallowed_STD3_mapped",[40,53,41]],[[9337,9337],"disallowed_STD3_mapped",[40,54,41]],[[9338,9338],"disallowed_STD3_mapped",[40,55,41]],[[9339,9339],"disallowed_STD3_mapped",[40,56,41]],[[9340,9340],"disallowed_STD3_mapped",[40,57,41]],[[9341,9341],"disallowed_STD3_mapped",[40,49,48,41]],[[9342,9342],"disallowed_STD3_mapped",[40,49,49,41]],[[9343,9343],"disallowed_STD3_mapped",[40,49,50,41]],[[9344,9344],"disallowed_STD3_mapped",[40,49,51,41]],[[9345,9345],"disallowed_STD3_mapped",[40,49,52,41]],[[9346,9346],"disallowed_STD3_mapped",[40,49,53,41]],[[9347,9347],"disallowed_STD3_mapped",[40,49,54,41]],[[9348,9348],"disallowed_STD3_mapped",[40,49,55,41]],[[9349,9349],"disallowed_STD3_mapped",[40,49,56,41]],[[9350,9350],"disallowed_STD3_mapped",[40,49,57,41]],[[9351,9351],"disallowed_STD3_mapped",[40,50,48,41]],[[9352,9371],"disallowed"],[[9372,9372],"disallowed_STD3_mapped",[40,97,41]],[[9373,9373],"disallowed_STD3_mapped",[40,98,41]],[[9374,9374],"disallowed_STD3_mapped",[40,99,41]],[[9375,9375],"disallowed_STD3_mapped",[40,100,41]],[[9376,9376],"disallowed_STD3_mapped",[40,101,41]],[[9377,9377],"disallowed_STD3_mapped",[40,102,41]],[[9378,9378],"disallowed_STD3_mapped",[40,103,41]],[[9379,9379],"disallowed_STD3_mapped",[40,104,41]],[[9380,9380],"disallowed_STD3_mapped",[40,105,41]],[[9381,9381],"disallowed_STD3_mapped",[40,106,41]],[[9382,9382],"disallowed_STD3_mapped",[40,107,41]],[[9383,9383],"disallowed_STD3_mapped",[40,108,41]],[[9384,9384],"disallowed_STD3_mapped",[40,109,41]],[[9385,9385],"disallowed_STD3_mapped",[40,110,41]],[[9386,9386],"disallowed_STD3_mapped",[40,111,41]],[[9387,9387],"disallowed_STD3_mapped",[40,112,41]],[[9388,9388],"disallowed_STD3_mapped",[40,113,41]],[[9389,9389],"disallowed_STD3_mapped",[40,114,41]],[[9390,9390],"disallowed_STD3_mapped",[40,115,41]],[[9391,9391],"disallowed_STD3_mapped",[40,116,41]],[[9392,9392],"disallowed_STD3_mapped",[40,117,41]],[[9393,9393],"disallowed_STD3_mapped",[40,118,41]],[[9394,9394],"disallowed_STD3_mapped",[40,119,41]],[[9395,9395],"disallowed_STD3_mapped",[40,120,41]],[[9396,9396],"disallowed_STD3_mapped",[40,121,41]],[[9397,9397],"disallowed_STD3_mapped",[40,122,41]],[[9398,9398],"mapped",[97]],[[9399,9399],"mapped",[98]],[[9400,9400],"mapped",[99]],[[9401,9401],"mapped",[100]],[[9402,9402],"mapped",[101]],[[9403,9403],"mapped",[102]],[[9404,9404],"mapped",[103]],[[9405,9405],"mapped",[104]],[[9406,9406],"mapped",[105]],[[9407,9407],"mapped",[106]],[[9408,9408],"mapped",[107]],[[9409,9409],"mapped",[108]],[[9410,9410],"mapped",[109]],[[9411,9411],"mapped",[110]],[[9412,9412],"mapped",[111]],[[9413,9413],"mapped",[112]],[[9414,9414],"mapped",[113]],[[9415,9415],"mapped",[114]],[[9416,9416],"mapped",[115]],[[9417,9417],"mapped",[116]],[[9418,9418],"mapped",[117]],[[9419,9419],"mapped",[118]],[[9420,9420],"mapped",[119]],[[9421,9421],"mapped",[120]],[[9422,9422],"mapped",[121]],[[9423,9423],"mapped",[122]],[[9424,9424],"mapped",[97]],[[9425,9425],"mapped",[98]],[[9426,9426],"mapped",[99]],[[9427,9427],"mapped",[100]],[[9428,9428],"mapped",[101]],[[9429,9429],"mapped",[102]],[[9430,9430],"mapped",[103]],[[9431,9431],"mapped",[104]],[[9432,9432],"mapped",[105]],[[9433,9433],"mapped",[106]],[[9434,9434],"mapped",[107]],[[9435,9435],"mapped",[108]],[[9436,9436],"mapped",[109]],[[9437,9437],"mapped",[110]],[[9438,9438],"mapped",[111]],[[9439,9439],"mapped",[112]],[[9440,9440],"mapped",[113]],[[9441,9441],"mapped",[114]],[[9442,9442],"mapped",[115]],[[9443,9443],"mapped",[116]],[[9444,9444],"mapped",[117]],[[9445,9445],"mapped",[118]],[[9446,9446],"mapped",[119]],[[9447,9447],"mapped",[120]],[[9448,9448],"mapped",[121]],[[9449,9449],"mapped",[122]],[[9450,9450],"mapped",[48]],[[9451,9470],"valid",[],"NV8"],[[9471,9471],"valid",[],"NV8"],[[9472,9621],"valid",[],"NV8"],[[9622,9631],"valid",[],"NV8"],[[9632,9711],"valid",[],"NV8"],[[9712,9719],"valid",[],"NV8"],[[9720,9727],"valid",[],"NV8"],[[9728,9747],"valid",[],"NV8"],[[9748,9749],"valid",[],"NV8"],[[9750,9751],"valid",[],"NV8"],[[9752,9752],"valid",[],"NV8"],[[9753,9753],"valid",[],"NV8"],[[9754,9839],"valid",[],"NV8"],[[9840,9841],"valid",[],"NV8"],[[9842,9853],"valid",[],"NV8"],[[9854,9855],"valid",[],"NV8"],[[9856,9865],"valid",[],"NV8"],[[9866,9873],"valid",[],"NV8"],[[9874,9884],"valid",[],"NV8"],[[9885,9885],"valid",[],"NV8"],[[9886,9887],"valid",[],"NV8"],[[9888,9889],"valid",[],"NV8"],[[9890,9905],"valid",[],"NV8"],[[9906,9906],"valid",[],"NV8"],[[9907,9916],"valid",[],"NV8"],[[9917,9919],"valid",[],"NV8"],[[9920,9923],"valid",[],"NV8"],[[9924,9933],"valid",[],"NV8"],[[9934,9934],"valid",[],"NV8"],[[9935,9953],"valid",[],"NV8"],[[9954,9954],"valid",[],"NV8"],[[9955,9955],"valid",[],"NV8"],[[9956,9959],"valid",[],"NV8"],[[9960,9983],"valid",[],"NV8"],[[9984,9984],"valid",[],"NV8"],[[9985,9988],"valid",[],"NV8"],[[9989,9989],"valid",[],"NV8"],[[9990,9993],"valid",[],"NV8"],[[9994,9995],"valid",[],"NV8"],[[9996,10023],"valid",[],"NV8"],[[10024,10024],"valid",[],"NV8"],[[10025,10059],"valid",[],"NV8"],[[10060,10060],"valid",[],"NV8"],[[10061,10061],"valid",[],"NV8"],[[10062,10062],"valid",[],"NV8"],[[10063,10066],"valid",[],"NV8"],[[10067,10069],"valid",[],"NV8"],[[10070,10070],"valid",[],"NV8"],[[10071,10071],"valid",[],"NV8"],[[10072,10078],"valid",[],"NV8"],[[10079,10080],"valid",[],"NV8"],[[10081,10087],"valid",[],"NV8"],[[10088,10101],"valid",[],"NV8"],[[10102,10132],"valid",[],"NV8"],[[10133,10135],"valid",[],"NV8"],[[10136,10159],"valid",[],"NV8"],[[10160,10160],"valid",[],"NV8"],[[10161,10174],"valid",[],"NV8"],[[10175,10175],"valid",[],"NV8"],[[10176,10182],"valid",[],"NV8"],[[10183,10186],"valid",[],"NV8"],[[10187,10187],"valid",[],"NV8"],[[10188,10188],"valid",[],"NV8"],[[10189,10189],"valid",[],"NV8"],[[10190,10191],"valid",[],"NV8"],[[10192,10219],"valid",[],"NV8"],[[10220,10223],"valid",[],"NV8"],[[10224,10239],"valid",[],"NV8"],[[10240,10495],"valid",[],"NV8"],[[10496,10763],"valid",[],"NV8"],[[10764,10764],"mapped",[8747,8747,8747,8747]],[[10765,10867],"valid",[],"NV8"],[[10868,10868],"disallowed_STD3_mapped",[58,58,61]],[[10869,10869],"disallowed_STD3_mapped",[61,61]],[[10870,10870],"disallowed_STD3_mapped",[61,61,61]],[[10871,10971],"valid",[],"NV8"],[[10972,10972],"mapped",[10973,824]],[[10973,11007],"valid",[],"NV8"],[[11008,11021],"valid",[],"NV8"],[[11022,11027],"valid",[],"NV8"],[[11028,11034],"valid",[],"NV8"],[[11035,11039],"valid",[],"NV8"],[[11040,11043],"valid",[],"NV8"],[[11044,11084],"valid",[],"NV8"],[[11085,11087],"valid",[],"NV8"],[[11088,11092],"valid",[],"NV8"],[[11093,11097],"valid",[],"NV8"],[[11098,11123],"valid",[],"NV8"],[[11124,11125],"disallowed"],[[11126,11157],"valid",[],"NV8"],[[11158,11159],"disallowed"],[[11160,11193],"valid",[],"NV8"],[[11194,11196],"disallowed"],[[11197,11208],"valid",[],"NV8"],[[11209,11209],"disallowed"],[[11210,11217],"valid",[],"NV8"],[[11218,11243],"disallowed"],[[11244,11247],"valid",[],"NV8"],[[11248,11263],"disallowed"],[[11264,11264],"mapped",[11312]],[[11265,11265],"mapped",[11313]],[[11266,11266],"mapped",[11314]],[[11267,11267],"mapped",[11315]],[[11268,11268],"mapped",[11316]],[[11269,11269],"mapped",[11317]],[[11270,11270],"mapped",[11318]],[[11271,11271],"mapped",[11319]],[[11272,11272],"mapped",[11320]],[[11273,11273],"mapped",[11321]],[[11274,11274],"mapped",[11322]],[[11275,11275],"mapped",[11323]],[[11276,11276],"mapped",[11324]],[[11277,11277],"mapped",[11325]],[[11278,11278],"mapped",[11326]],[[11279,11279],"mapped",[11327]],[[11280,11280],"mapped",[11328]],[[11281,11281],"mapped",[11329]],[[11282,11282],"mapped",[11330]],[[11283,11283],"mapped",[11331]],[[11284,11284],"mapped",[11332]],[[11285,11285],"mapped",[11333]],[[11286,11286],"mapped",[11334]],[[11287,11287],"mapped",[11335]],[[11288,11288],"mapped",[11336]],[[11289,11289],"mapped",[11337]],[[11290,11290],"mapped",[11338]],[[11291,11291],"mapped",[11339]],[[11292,11292],"mapped",[11340]],[[11293,11293],"mapped",[11341]],[[11294,11294],"mapped",[11342]],[[11295,11295],"mapped",[11343]],[[11296,11296],"mapped",[11344]],[[11297,11297],"mapped",[11345]],[[11298,11298],"mapped",[11346]],[[11299,11299],"mapped",[11347]],[[11300,11300],"mapped",[11348]],[[11301,11301],"mapped",[11349]],[[11302,11302],"mapped",[11350]],[[11303,11303],"mapped",[11351]],[[11304,11304],"mapped",[11352]],[[11305,11305],"mapped",[11353]],[[11306,11306],"mapped",[11354]],[[11307,11307],"mapped",[11355]],[[11308,11308],"mapped",[11356]],[[11309,11309],"mapped",[11357]],[[11310,11310],"mapped",[11358]],[[11311,11311],"disallowed"],[[11312,11358],"valid"],[[11359,11359],"disallowed"],[[11360,11360],"mapped",[11361]],[[11361,11361],"valid"],[[11362,11362],"mapped",[619]],[[11363,11363],"mapped",[7549]],[[11364,11364],"mapped",[637]],[[11365,11366],"valid"],[[11367,11367],"mapped",[11368]],[[11368,11368],"valid"],[[11369,11369],"mapped",[11370]],[[11370,11370],"valid"],[[11371,11371],"mapped",[11372]],[[11372,11372],"valid"],[[11373,11373],"mapped",[593]],[[11374,11374],"mapped",[625]],[[11375,11375],"mapped",[592]],[[11376,11376],"mapped",[594]],[[11377,11377],"valid"],[[11378,11378],"mapped",[11379]],[[11379,11379],"valid"],[[11380,11380],"valid"],[[11381,11381],"mapped",[11382]],[[11382,11383],"valid"],[[11384,11387],"valid"],[[11388,11388],"mapped",[106]],[[11389,11389],"mapped",[118]],[[11390,11390],"mapped",[575]],[[11391,11391],"mapped",[576]],[[11392,11392],"mapped",[11393]],[[11393,11393],"valid"],[[11394,11394],"mapped",[11395]],[[11395,11395],"valid"],[[11396,11396],"mapped",[11397]],[[11397,11397],"valid"],[[11398,11398],"mapped",[11399]],[[11399,11399],"valid"],[[11400,11400],"mapped",[11401]],[[11401,11401],"valid"],[[11402,11402],"mapped",[11403]],[[11403,11403],"valid"],[[11404,11404],"mapped",[11405]],[[11405,11405],"valid"],[[11406,11406],"mapped",[11407]],[[11407,11407],"valid"],[[11408,11408],"mapped",[11409]],[[11409,11409],"valid"],[[11410,11410],"mapped",[11411]],[[11411,11411],"valid"],[[11412,11412],"mapped",[11413]],[[11413,11413],"valid"],[[11414,11414],"mapped",[11415]],[[11415,11415],"valid"],[[11416,11416],"mapped",[11417]],[[11417,11417],"valid"],[[11418,11418],"mapped",[11419]],[[11419,11419],"valid"],[[11420,11420],"mapped",[11421]],[[11421,11421],"valid"],[[11422,11422],"mapped",[11423]],[[11423,11423],"valid"],[[11424,11424],"mapped",[11425]],[[11425,11425],"valid"],[[11426,11426],"mapped",[11427]],[[11427,11427],"valid"],[[11428,11428],"mapped",[11429]],[[11429,11429],"valid"],[[11430,11430],"mapped",[11431]],[[11431,11431],"valid"],[[11432,11432],"mapped",[11433]],[[11433,11433],"valid"],[[11434,11434],"mapped",[11435]],[[11435,11435],"valid"],[[11436,11436],"mapped",[11437]],[[11437,11437],"valid"],[[11438,11438],"mapped",[11439]],[[11439,11439],"valid"],[[11440,11440],"mapped",[11441]],[[11441,11441],"valid"],[[11442,11442],"mapped",[11443]],[[11443,11443],"valid"],[[11444,11444],"mapped",[11445]],[[11445,11445],"valid"],[[11446,11446],"mapped",[11447]],[[11447,11447],"valid"],[[11448,11448],"mapped",[11449]],[[11449,11449],"valid"],[[11450,11450],"mapped",[11451]],[[11451,11451],"valid"],[[11452,11452],"mapped",[11453]],[[11453,11453],"valid"],[[11454,11454],"mapped",[11455]],[[11455,11455],"valid"],[[11456,11456],"mapped",[11457]],[[11457,11457],"valid"],[[11458,11458],"mapped",[11459]],[[11459,11459],"valid"],[[11460,11460],"mapped",[11461]],[[11461,11461],"valid"],[[11462,11462],"mapped",[11463]],[[11463,11463],"valid"],[[11464,11464],"mapped",[11465]],[[11465,11465],"valid"],[[11466,11466],"mapped",[11467]],[[11467,11467],"valid"],[[11468,11468],"mapped",[11469]],[[11469,11469],"valid"],[[11470,11470],"mapped",[11471]],[[11471,11471],"valid"],[[11472,11472],"mapped",[11473]],[[11473,11473],"valid"],[[11474,11474],"mapped",[11475]],[[11475,11475],"valid"],[[11476,11476],"mapped",[11477]],[[11477,11477],"valid"],[[11478,11478],"mapped",[11479]],[[11479,11479],"valid"],[[11480,11480],"mapped",[11481]],[[11481,11481],"valid"],[[11482,11482],"mapped",[11483]],[[11483,11483],"valid"],[[11484,11484],"mapped",[11485]],[[11485,11485],"valid"],[[11486,11486],"mapped",[11487]],[[11487,11487],"valid"],[[11488,11488],"mapped",[11489]],[[11489,11489],"valid"],[[11490,11490],"mapped",[11491]],[[11491,11492],"valid"],[[11493,11498],"valid",[],"NV8"],[[11499,11499],"mapped",[11500]],[[11500,11500],"valid"],[[11501,11501],"mapped",[11502]],[[11502,11505],"valid"],[[11506,11506],"mapped",[11507]],[[11507,11507],"valid"],[[11508,11512],"disallowed"],[[11513,11519],"valid",[],"NV8"],[[11520,11557],"valid"],[[11558,11558],"disallowed"],[[11559,11559],"valid"],[[11560,11564],"disallowed"],[[11565,11565],"valid"],[[11566,11567],"disallowed"],[[11568,11621],"valid"],[[11622,11623],"valid"],[[11624,11630],"disallowed"],[[11631,11631],"mapped",[11617]],[[11632,11632],"valid",[],"NV8"],[[11633,11646],"disallowed"],[[11647,11647],"valid"],[[11648,11670],"valid"],[[11671,11679],"disallowed"],[[11680,11686],"valid"],[[11687,11687],"disallowed"],[[11688,11694],"valid"],[[11695,11695],"disallowed"],[[11696,11702],"valid"],[[11703,11703],"disallowed"],[[11704,11710],"valid"],[[11711,11711],"disallowed"],[[11712,11718],"valid"],[[11719,11719],"disallowed"],[[11720,11726],"valid"],[[11727,11727],"disallowed"],[[11728,11734],"valid"],[[11735,11735],"disallowed"],[[11736,11742],"valid"],[[11743,11743],"disallowed"],[[11744,11775],"valid"],[[11776,11799],"valid",[],"NV8"],[[11800,11803],"valid",[],"NV8"],[[11804,11805],"valid",[],"NV8"],[[11806,11822],"valid",[],"NV8"],[[11823,11823],"valid"],[[11824,11824],"valid",[],"NV8"],[[11825,11825],"valid",[],"NV8"],[[11826,11835],"valid",[],"NV8"],[[11836,11842],"valid",[],"NV8"],[[11843,11903],"disallowed"],[[11904,11929],"valid",[],"NV8"],[[11930,11930],"disallowed"],[[11931,11934],"valid",[],"NV8"],[[11935,11935],"mapped",[27597]],[[11936,12018],"valid",[],"NV8"],[[12019,12019],"mapped",[40863]],[[12020,12031],"disallowed"],[[12032,12032],"mapped",[19968]],[[12033,12033],"mapped",[20008]],[[12034,12034],"mapped",[20022]],[[12035,12035],"mapped",[20031]],[[12036,12036],"mapped",[20057]],[[12037,12037],"mapped",[20101]],[[12038,12038],"mapped",[20108]],[[12039,12039],"mapped",[20128]],[[12040,12040],"mapped",[20154]],[[12041,12041],"mapped",[20799]],[[12042,12042],"mapped",[20837]],[[12043,12043],"mapped",[20843]],[[12044,12044],"mapped",[20866]],[[12045,12045],"mapped",[20886]],[[12046,12046],"mapped",[20907]],[[12047,12047],"mapped",[20960]],[[12048,12048],"mapped",[20981]],[[12049,12049],"mapped",[20992]],[[12050,12050],"mapped",[21147]],[[12051,12051],"mapped",[21241]],[[12052,12052],"mapped",[21269]],[[12053,12053],"mapped",[21274]],[[12054,12054],"mapped",[21304]],[[12055,12055],"mapped",[21313]],[[12056,12056],"mapped",[21340]],[[12057,12057],"mapped",[21353]],[[12058,12058],"mapped",[21378]],[[12059,12059],"mapped",[21430]],[[12060,12060],"mapped",[21448]],[[12061,12061],"mapped",[21475]],[[12062,12062],"mapped",[22231]],[[12063,12063],"mapped",[22303]],[[12064,12064],"mapped",[22763]],[[12065,12065],"mapped",[22786]],[[12066,12066],"mapped",[22794]],[[12067,12067],"mapped",[22805]],[[12068,12068],"mapped",[22823]],[[12069,12069],"mapped",[22899]],[[12070,12070],"mapped",[23376]],[[12071,12071],"mapped",[23424]],[[12072,12072],"mapped",[23544]],[[12073,12073],"mapped",[23567]],[[12074,12074],"mapped",[23586]],[[12075,12075],"mapped",[23608]],[[12076,12076],"mapped",[23662]],[[12077,12077],"mapped",[23665]],[[12078,12078],"mapped",[24027]],[[12079,12079],"mapped",[24037]],[[12080,12080],"mapped",[24049]],[[12081,12081],"mapped",[24062]],[[12082,12082],"mapped",[24178]],[[12083,12083],"mapped",[24186]],[[12084,12084],"mapped",[24191]],[[12085,12085],"mapped",[24308]],[[12086,12086],"mapped",[24318]],[[12087,12087],"mapped",[24331]],[[12088,12088],"mapped",[24339]],[[12089,12089],"mapped",[24400]],[[12090,12090],"mapped",[24417]],[[12091,12091],"mapped",[24435]],[[12092,12092],"mapped",[24515]],[[12093,12093],"mapped",[25096]],[[12094,12094],"mapped",[25142]],[[12095,12095],"mapped",[25163]],[[12096,12096],"mapped",[25903]],[[12097,12097],"mapped",[25908]],[[12098,12098],"mapped",[25991]],[[12099,12099],"mapped",[26007]],[[12100,12100],"mapped",[26020]],[[12101,12101],"mapped",[26041]],[[12102,12102],"mapped",[26080]],[[12103,12103],"mapped",[26085]],[[12104,12104],"mapped",[26352]],[[12105,12105],"mapped",[26376]],[[12106,12106],"mapped",[26408]],[[12107,12107],"mapped",[27424]],[[12108,12108],"mapped",[27490]],[[12109,12109],"mapped",[27513]],[[12110,12110],"mapped",[27571]],[[12111,12111],"mapped",[27595]],[[12112,12112],"mapped",[27604]],[[12113,12113],"mapped",[27611]],[[12114,12114],"mapped",[27663]],[[12115,12115],"mapped",[27668]],[[12116,12116],"mapped",[27700]],[[12117,12117],"mapped",[28779]],[[12118,12118],"mapped",[29226]],[[12119,12119],"mapped",[29238]],[[12120,12120],"mapped",[29243]],[[12121,12121],"mapped",[29247]],[[12122,12122],"mapped",[29255]],[[12123,12123],"mapped",[29273]],[[12124,12124],"mapped",[29275]],[[12125,12125],"mapped",[29356]],[[12126,12126],"mapped",[29572]],[[12127,12127],"mapped",[29577]],[[12128,12128],"mapped",[29916]],[[12129,12129],"mapped",[29926]],[[12130,12130],"mapped",[29976]],[[12131,12131],"mapped",[29983]],[[12132,12132],"mapped",[29992]],[[12133,12133],"mapped",[30000]],[[12134,12134],"mapped",[30091]],[[12135,12135],"mapped",[30098]],[[12136,12136],"mapped",[30326]],[[12137,12137],"mapped",[30333]],[[12138,12138],"mapped",[30382]],[[12139,12139],"mapped",[30399]],[[12140,12140],"mapped",[30446]],[[12141,12141],"mapped",[30683]],[[12142,12142],"mapped",[30690]],[[12143,12143],"mapped",[30707]],[[12144,12144],"mapped",[31034]],[[12145,12145],"mapped",[31160]],[[12146,12146],"mapped",[31166]],[[12147,12147],"mapped",[31348]],[[12148,12148],"mapped",[31435]],[[12149,12149],"mapped",[31481]],[[12150,12150],"mapped",[31859]],[[12151,12151],"mapped",[31992]],[[12152,12152],"mapped",[32566]],[[12153,12153],"mapped",[32593]],[[12154,12154],"mapped",[32650]],[[12155,12155],"mapped",[32701]],[[12156,12156],"mapped",[32769]],[[12157,12157],"mapped",[32780]],[[12158,12158],"mapped",[32786]],[[12159,12159],"mapped",[32819]],[[12160,12160],"mapped",[32895]],[[12161,12161],"mapped",[32905]],[[12162,12162],"mapped",[33251]],[[12163,12163],"mapped",[33258]],[[12164,12164],"mapped",[33267]],[[12165,12165],"mapped",[33276]],[[12166,12166],"mapped",[33292]],[[12167,12167],"mapped",[33307]],[[12168,12168],"mapped",[33311]],[[12169,12169],"mapped",[33390]],[[12170,12170],"mapped",[33394]],[[12171,12171],"mapped",[33400]],[[12172,12172],"mapped",[34381]],[[12173,12173],"mapped",[34411]],[[12174,12174],"mapped",[34880]],[[12175,12175],"mapped",[34892]],[[12176,12176],"mapped",[34915]],[[12177,12177],"mapped",[35198]],[[12178,12178],"mapped",[35211]],[[12179,12179],"mapped",[35282]],[[12180,12180],"mapped",[35328]],[[12181,12181],"mapped",[35895]],[[12182,12182],"mapped",[35910]],[[12183,12183],"mapped",[35925]],[[12184,12184],"mapped",[35960]],[[12185,12185],"mapped",[35997]],[[12186,12186],"mapped",[36196]],[[12187,12187],"mapped",[36208]],[[12188,12188],"mapped",[36275]],[[12189,12189],"mapped",[36523]],[[12190,12190],"mapped",[36554]],[[12191,12191],"mapped",[36763]],[[12192,12192],"mapped",[36784]],[[12193,12193],"mapped",[36789]],[[12194,12194],"mapped",[37009]],[[12195,12195],"mapped",[37193]],[[12196,12196],"mapped",[37318]],[[12197,12197],"mapped",[37324]],[[12198,12198],"mapped",[37329]],[[12199,12199],"mapped",[38263]],[[12200,12200],"mapped",[38272]],[[12201,12201],"mapped",[38428]],[[12202,12202],"mapped",[38582]],[[12203,12203],"mapped",[38585]],[[12204,12204],"mapped",[38632]],[[12205,12205],"mapped",[38737]],[[12206,12206],"mapped",[38750]],[[12207,12207],"mapped",[38754]],[[12208,12208],"mapped",[38761]],[[12209,12209],"mapped",[38859]],[[12210,12210],"mapped",[38893]],[[12211,12211],"mapped",[38899]],[[12212,12212],"mapped",[38913]],[[12213,12213],"mapped",[39080]],[[12214,12214],"mapped",[39131]],[[12215,12215],"mapped",[39135]],[[12216,12216],"mapped",[39318]],[[12217,12217],"mapped",[39321]],[[12218,12218],"mapped",[39340]],[[12219,12219],"mapped",[39592]],[[12220,12220],"mapped",[39640]],[[12221,12221],"mapped",[39647]],[[12222,12222],"mapped",[39717]],[[12223,12223],"mapped",[39727]],[[12224,12224],"mapped",[39730]],[[12225,12225],"mapped",[39740]],[[12226,12226],"mapped",[39770]],[[12227,12227],"mapped",[40165]],[[12228,12228],"mapped",[40565]],[[12229,12229],"mapped",[40575]],[[12230,12230],"mapped",[40613]],[[12231,12231],"mapped",[40635]],[[12232,12232],"mapped",[40643]],[[12233,12233],"mapped",[40653]],[[12234,12234],"mapped",[40657]],[[12235,12235],"mapped",[40697]],[[12236,12236],"mapped",[40701]],[[12237,12237],"mapped",[40718]],[[12238,12238],"mapped",[40723]],[[12239,12239],"mapped",[40736]],[[12240,12240],"mapped",[40763]],[[12241,12241],"mapped",[40778]],[[12242,12242],"mapped",[40786]],[[12243,12243],"mapped",[40845]],[[12244,12244],"mapped",[40860]],[[12245,12245],"mapped",[40864]],[[12246,12271],"disallowed"],[[12272,12283],"disallowed"],[[12284,12287],"disallowed"],[[12288,12288],"disallowed_STD3_mapped",[32]],[[12289,12289],"valid",[],"NV8"],[[12290,12290],"mapped",[46]],[[12291,12292],"valid",[],"NV8"],[[12293,12295],"valid"],[[12296,12329],"valid",[],"NV8"],[[12330,12333],"valid"],[[12334,12341],"valid",[],"NV8"],[[12342,12342],"mapped",[12306]],[[12343,12343],"valid",[],"NV8"],[[12344,12344],"mapped",[21313]],[[12345,12345],"mapped",[21316]],[[12346,12346],"mapped",[21317]],[[12347,12347],"valid",[],"NV8"],[[12348,12348],"valid"],[[12349,12349],"valid",[],"NV8"],[[12350,12350],"valid",[],"NV8"],[[12351,12351],"valid",[],"NV8"],[[12352,12352],"disallowed"],[[12353,12436],"valid"],[[12437,12438],"valid"],[[12439,12440],"disallowed"],[[12441,12442],"valid"],[[12443,12443],"disallowed_STD3_mapped",[32,12441]],[[12444,12444],"disallowed_STD3_mapped",[32,12442]],[[12445,12446],"valid"],[[12447,12447],"mapped",[12424,12426]],[[12448,12448],"valid",[],"NV8"],[[12449,12542],"valid"],[[12543,12543],"mapped",[12467,12488]],[[12544,12548],"disallowed"],[[12549,12588],"valid"],[[12589,12589],"valid"],[[12590,12592],"disallowed"],[[12593,12593],"mapped",[4352]],[[12594,12594],"mapped",[4353]],[[12595,12595],"mapped",[4522]],[[12596,12596],"mapped",[4354]],[[12597,12597],"mapped",[4524]],[[12598,12598],"mapped",[4525]],[[12599,12599],"mapped",[4355]],[[12600,12600],"mapped",[4356]],[[12601,12601],"mapped",[4357]],[[12602,12602],"mapped",[4528]],[[12603,12603],"mapped",[4529]],[[12604,12604],"mapped",[4530]],[[12605,12605],"mapped",[4531]],[[12606,12606],"mapped",[4532]],[[12607,12607],"mapped",[4533]],[[12608,12608],"mapped",[4378]],[[12609,12609],"mapped",[4358]],[[12610,12610],"mapped",[4359]],[[12611,12611],"mapped",[4360]],[[12612,12612],"mapped",[4385]],[[12613,12613],"mapped",[4361]],[[12614,12614],"mapped",[4362]],[[12615,12615],"mapped",[4363]],[[12616,12616],"mapped",[4364]],[[12617,12617],"mapped",[4365]],[[12618,12618],"mapped",[4366]],[[12619,12619],"mapped",[4367]],[[12620,12620],"mapped",[4368]],[[12621,12621],"mapped",[4369]],[[12622,12622],"mapped",[4370]],[[12623,12623],"mapped",[4449]],[[12624,12624],"mapped",[4450]],[[12625,12625],"mapped",[4451]],[[12626,12626],"mapped",[4452]],[[12627,12627],"mapped",[4453]],[[12628,12628],"mapped",[4454]],[[12629,12629],"mapped",[4455]],[[12630,12630],"mapped",[4456]],[[12631,12631],"mapped",[4457]],[[12632,12632],"mapped",[4458]],[[12633,12633],"mapped",[4459]],[[12634,12634],"mapped",[4460]],[[12635,12635],"mapped",[4461]],[[12636,12636],"mapped",[4462]],[[12637,12637],"mapped",[4463]],[[12638,12638],"mapped",[4464]],[[12639,12639],"mapped",[4465]],[[12640,12640],"mapped",[4466]],[[12641,12641],"mapped",[4467]],[[12642,12642],"mapped",[4468]],[[12643,12643],"mapped",[4469]],[[12644,12644],"disallowed"],[[12645,12645],"mapped",[4372]],[[12646,12646],"mapped",[4373]],[[12647,12647],"mapped",[4551]],[[12648,12648],"mapped",[4552]],[[12649,12649],"mapped",[4556]],[[12650,12650],"mapped",[4558]],[[12651,12651],"mapped",[4563]],[[12652,12652],"mapped",[4567]],[[12653,12653],"mapped",[4569]],[[12654,12654],"mapped",[4380]],[[12655,12655],"mapped",[4573]],[[12656,12656],"mapped",[4575]],[[12657,12657],"mapped",[4381]],[[12658,12658],"mapped",[4382]],[[12659,12659],"mapped",[4384]],[[12660,12660],"mapped",[4386]],[[12661,12661],"mapped",[4387]],[[12662,12662],"mapped",[4391]],[[12663,12663],"mapped",[4393]],[[12664,12664],"mapped",[4395]],[[12665,12665],"mapped",[4396]],[[12666,12666],"mapped",[4397]],[[12667,12667],"mapped",[4398]],[[12668,12668],"mapped",[4399]],[[12669,12669],"mapped",[4402]],[[12670,12670],"mapped",[4406]],[[12671,12671],"mapped",[4416]],[[12672,12672],"mapped",[4423]],[[12673,12673],"mapped",[4428]],[[12674,12674],"mapped",[4593]],[[12675,12675],"mapped",[4594]],[[12676,12676],"mapped",[4439]],[[12677,12677],"mapped",[4440]],[[12678,12678],"mapped",[4441]],[[12679,12679],"mapped",[4484]],[[12680,12680],"mapped",[4485]],[[12681,12681],"mapped",[4488]],[[12682,12682],"mapped",[4497]],[[12683,12683],"mapped",[4498]],[[12684,12684],"mapped",[4500]],[[12685,12685],"mapped",[4510]],[[12686,12686],"mapped",[4513]],[[12687,12687],"disallowed"],[[12688,12689],"valid",[],"NV8"],[[12690,12690],"mapped",[19968]],[[12691,12691],"mapped",[20108]],[[12692,12692],"mapped",[19977]],[[12693,12693],"mapped",[22235]],[[12694,12694],"mapped",[19978]],[[12695,12695],"mapped",[20013]],[[12696,12696],"mapped",[19979]],[[12697,12697],"mapped",[30002]],[[12698,12698],"mapped",[20057]],[[12699,12699],"mapped",[19993]],[[12700,12700],"mapped",[19969]],[[12701,12701],"mapped",[22825]],[[12702,12702],"mapped",[22320]],[[12703,12703],"mapped",[20154]],[[12704,12727],"valid"],[[12728,12730],"valid"],[[12731,12735],"disallowed"],[[12736,12751],"valid",[],"NV8"],[[12752,12771],"valid",[],"NV8"],[[12772,12783],"disallowed"],[[12784,12799],"valid"],[[12800,12800],"disallowed_STD3_mapped",[40,4352,41]],[[12801,12801],"disallowed_STD3_mapped",[40,4354,41]],[[12802,12802],"disallowed_STD3_mapped",[40,4355,41]],[[12803,12803],"disallowed_STD3_mapped",[40,4357,41]],[[12804,12804],"disallowed_STD3_mapped",[40,4358,41]],[[12805,12805],"disallowed_STD3_mapped",[40,4359,41]],[[12806,12806],"disallowed_STD3_mapped",[40,4361,41]],[[12807,12807],"disallowed_STD3_mapped",[40,4363,41]],[[12808,12808],"disallowed_STD3_mapped",[40,4364,41]],[[12809,12809],"disallowed_STD3_mapped",[40,4366,41]],[[12810,12810],"disallowed_STD3_mapped",[40,4367,41]],[[12811,12811],"disallowed_STD3_mapped",[40,4368,41]],[[12812,12812],"disallowed_STD3_mapped",[40,4369,41]],[[12813,12813],"disallowed_STD3_mapped",[40,4370,41]],[[12814,12814],"disallowed_STD3_mapped",[40,44032,41]],[[12815,12815],"disallowed_STD3_mapped",[40,45208,41]],[[12816,12816],"disallowed_STD3_mapped",[40,45796,41]],[[12817,12817],"disallowed_STD3_mapped",[40,46972,41]],[[12818,12818],"disallowed_STD3_mapped",[40,47560,41]],[[12819,12819],"disallowed_STD3_mapped",[40,48148,41]],[[12820,12820],"disallowed_STD3_mapped",[40,49324,41]],[[12821,12821],"disallowed_STD3_mapped",[40,50500,41]],[[12822,12822],"disallowed_STD3_mapped",[40,51088,41]],[[12823,12823],"disallowed_STD3_mapped",[40,52264,41]],[[12824,12824],"disallowed_STD3_mapped",[40,52852,41]],[[12825,12825],"disallowed_STD3_mapped",[40,53440,41]],[[12826,12826],"disallowed_STD3_mapped",[40,54028,41]],[[12827,12827],"disallowed_STD3_mapped",[40,54616,41]],[[12828,12828],"disallowed_STD3_mapped",[40,51452,41]],[[12829,12829],"disallowed_STD3_mapped",[40,50724,51204,41]],[[12830,12830],"disallowed_STD3_mapped",[40,50724,54980,41]],[[12831,12831],"disallowed"],[[12832,12832],"disallowed_STD3_mapped",[40,19968,41]],[[12833,12833],"disallowed_STD3_mapped",[40,20108,41]],[[12834,12834],"disallowed_STD3_mapped",[40,19977,41]],[[12835,12835],"disallowed_STD3_mapped",[40,22235,41]],[[12836,12836],"disallowed_STD3_mapped",[40,20116,41]],[[12837,12837],"disallowed_STD3_mapped",[40,20845,41]],[[12838,12838],"disallowed_STD3_mapped",[40,19971,41]],[[12839,12839],"disallowed_STD3_mapped",[40,20843,41]],[[12840,12840],"disallowed_STD3_mapped",[40,20061,41]],[[12841,12841],"disallowed_STD3_mapped",[40,21313,41]],[[12842,12842],"disallowed_STD3_mapped",[40,26376,41]],[[12843,12843],"disallowed_STD3_mapped",[40,28779,41]],[[12844,12844],"disallowed_STD3_mapped",[40,27700,41]],[[12845,12845],"disallowed_STD3_mapped",[40,26408,41]],[[12846,12846],"disallowed_STD3_mapped",[40,37329,41]],[[12847,12847],"disallowed_STD3_mapped",[40,22303,41]],[[12848,12848],"disallowed_STD3_mapped",[40,26085,41]],[[12849,12849],"disallowed_STD3_mapped",[40,26666,41]],[[12850,12850],"disallowed_STD3_mapped",[40,26377,41]],[[12851,12851],"disallowed_STD3_mapped",[40,31038,41]],[[12852,12852],"disallowed_STD3_mapped",[40,21517,41]],[[12853,12853],"disallowed_STD3_mapped",[40,29305,41]],[[12854,12854],"disallowed_STD3_mapped",[40,36001,41]],[[12855,12855],"disallowed_STD3_mapped",[40,31069,41]],[[12856,12856],"disallowed_STD3_mapped",[40,21172,41]],[[12857,12857],"disallowed_STD3_mapped",[40,20195,41]],[[12858,12858],"disallowed_STD3_mapped",[40,21628,41]],[[12859,12859],"disallowed_STD3_mapped",[40,23398,41]],[[12860,12860],"disallowed_STD3_mapped",[40,30435,41]],[[12861,12861],"disallowed_STD3_mapped",[40,20225,41]],[[12862,12862],"disallowed_STD3_mapped",[40,36039,41]],[[12863,12863],"disallowed_STD3_mapped",[40,21332,41]],[[12864,12864],"disallowed_STD3_mapped",[40,31085,41]],[[12865,12865],"disallowed_STD3_mapped",[40,20241,41]],[[12866,12866],"disallowed_STD3_mapped",[40,33258,41]],[[12867,12867],"disallowed_STD3_mapped",[40,33267,41]],[[12868,12868],"mapped",[21839]],[[12869,12869],"mapped",[24188]],[[12870,12870],"mapped",[25991]],[[12871,12871],"mapped",[31631]],[[12872,12879],"valid",[],"NV8"],[[12880,12880],"mapped",[112,116,101]],[[12881,12881],"mapped",[50,49]],[[12882,12882],"mapped",[50,50]],[[12883,12883],"mapped",[50,51]],[[12884,12884],"mapped",[50,52]],[[12885,12885],"mapped",[50,53]],[[12886,12886],"mapped",[50,54]],[[12887,12887],"mapped",[50,55]],[[12888,12888],"mapped",[50,56]],[[12889,12889],"mapped",[50,57]],[[12890,12890],"mapped",[51,48]],[[12891,12891],"mapped",[51,49]],[[12892,12892],"mapped",[51,50]],[[12893,12893],"mapped",[51,51]],[[12894,12894],"mapped",[51,52]],[[12895,12895],"mapped",[51,53]],[[12896,12896],"mapped",[4352]],[[12897,12897],"mapped",[4354]],[[12898,12898],"mapped",[4355]],[[12899,12899],"mapped",[4357]],[[12900,12900],"mapped",[4358]],[[12901,12901],"mapped",[4359]],[[12902,12902],"mapped",[4361]],[[12903,12903],"mapped",[4363]],[[12904,12904],"mapped",[4364]],[[12905,12905],"mapped",[4366]],[[12906,12906],"mapped",[4367]],[[12907,12907],"mapped",[4368]],[[12908,12908],"mapped",[4369]],[[12909,12909],"mapped",[4370]],[[12910,12910],"mapped",[44032]],[[12911,12911],"mapped",[45208]],[[12912,12912],"mapped",[45796]],[[12913,12913],"mapped",[46972]],[[12914,12914],"mapped",[47560]],[[12915,12915],"mapped",[48148]],[[12916,12916],"mapped",[49324]],[[12917,12917],"mapped",[50500]],[[12918,12918],"mapped",[51088]],[[12919,12919],"mapped",[52264]],[[12920,12920],"mapped",[52852]],[[12921,12921],"mapped",[53440]],[[12922,12922],"mapped",[54028]],[[12923,12923],"mapped",[54616]],[[12924,12924],"mapped",[52280,44256]],[[12925,12925],"mapped",[51452,51032]],[[12926,12926],"mapped",[50864]],[[12927,12927],"valid",[],"NV8"],[[12928,12928],"mapped",[19968]],[[12929,12929],"mapped",[20108]],[[12930,12930],"mapped",[19977]],[[12931,12931],"mapped",[22235]],[[12932,12932],"mapped",[20116]],[[12933,12933],"mapped",[20845]],[[12934,12934],"mapped",[19971]],[[12935,12935],"mapped",[20843]],[[12936,12936],"mapped",[20061]],[[12937,12937],"mapped",[21313]],[[12938,12938],"mapped",[26376]],[[12939,12939],"mapped",[28779]],[[12940,12940],"mapped",[27700]],[[12941,12941],"mapped",[26408]],[[12942,12942],"mapped",[37329]],[[12943,12943],"mapped",[22303]],[[12944,12944],"mapped",[26085]],[[12945,12945],"mapped",[26666]],[[12946,12946],"mapped",[26377]],[[12947,12947],"mapped",[31038]],[[12948,12948],"mapped",[21517]],[[12949,12949],"mapped",[29305]],[[12950,12950],"mapped",[36001]],[[12951,12951],"mapped",[31069]],[[12952,12952],"mapped",[21172]],[[12953,12953],"mapped",[31192]],[[12954,12954],"mapped",[30007]],[[12955,12955],"mapped",[22899]],[[12956,12956],"mapped",[36969]],[[12957,12957],"mapped",[20778]],[[12958,12958],"mapped",[21360]],[[12959,12959],"mapped",[27880]],[[12960,12960],"mapped",[38917]],[[12961,12961],"mapped",[20241]],[[12962,12962],"mapped",[20889]],[[12963,12963],"mapped",[27491]],[[12964,12964],"mapped",[19978]],[[12965,12965],"mapped",[20013]],[[12966,12966],"mapped",[19979]],[[12967,12967],"mapped",[24038]],[[12968,12968],"mapped",[21491]],[[12969,12969],"mapped",[21307]],[[12970,12970],"mapped",[23447]],[[12971,12971],"mapped",[23398]],[[12972,12972],"mapped",[30435]],[[12973,12973],"mapped",[20225]],[[12974,12974],"mapped",[36039]],[[12975,12975],"mapped",[21332]],[[12976,12976],"mapped",[22812]],[[12977,12977],"mapped",[51,54]],[[12978,12978],"mapped",[51,55]],[[12979,12979],"mapped",[51,56]],[[12980,12980],"mapped",[51,57]],[[12981,12981],"mapped",[52,48]],[[12982,12982],"mapped",[52,49]],[[12983,12983],"mapped",[52,50]],[[12984,12984],"mapped",[52,51]],[[12985,12985],"mapped",[52,52]],[[12986,12986],"mapped",[52,53]],[[12987,12987],"mapped",[52,54]],[[12988,12988],"mapped",[52,55]],[[12989,12989],"mapped",[52,56]],[[12990,12990],"mapped",[52,57]],[[12991,12991],"mapped",[53,48]],[[12992,12992],"mapped",[49,26376]],[[12993,12993],"mapped",[50,26376]],[[12994,12994],"mapped",[51,26376]],[[12995,12995],"mapped",[52,26376]],[[12996,12996],"mapped",[53,26376]],[[12997,12997],"mapped",[54,26376]],[[12998,12998],"mapped",[55,26376]],[[12999,12999],"mapped",[56,26376]],[[13000,13000],"mapped",[57,26376]],[[13001,13001],"mapped",[49,48,26376]],[[13002,13002],"mapped",[49,49,26376]],[[13003,13003],"mapped",[49,50,26376]],[[13004,13004],"mapped",[104,103]],[[13005,13005],"mapped",[101,114,103]],[[13006,13006],"mapped",[101,118]],[[13007,13007],"mapped",[108,116,100]],[[13008,13008],"mapped",[12450]],[[13009,13009],"mapped",[12452]],[[13010,13010],"mapped",[12454]],[[13011,13011],"mapped",[12456]],[[13012,13012],"mapped",[12458]],[[13013,13013],"mapped",[12459]],[[13014,13014],"mapped",[12461]],[[13015,13015],"mapped",[12463]],[[13016,13016],"mapped",[12465]],[[13017,13017],"mapped",[12467]],[[13018,13018],"mapped",[12469]],[[13019,13019],"mapped",[12471]],[[13020,13020],"mapped",[12473]],[[13021,13021],"mapped",[12475]],[[13022,13022],"mapped",[12477]],[[13023,13023],"mapped",[12479]],[[13024,13024],"mapped",[12481]],[[13025,13025],"mapped",[12484]],[[13026,13026],"mapped",[12486]],[[13027,13027],"mapped",[12488]],[[13028,13028],"mapped",[12490]],[[13029,13029],"mapped",[12491]],[[13030,13030],"mapped",[12492]],[[13031,13031],"mapped",[12493]],[[13032,13032],"mapped",[12494]],[[13033,13033],"mapped",[12495]],[[13034,13034],"mapped",[12498]],[[13035,13035],"mapped",[12501]],[[13036,13036],"mapped",[12504]],[[13037,13037],"mapped",[12507]],[[13038,13038],"mapped",[12510]],[[13039,13039],"mapped",[12511]],[[13040,13040],"mapped",[12512]],[[13041,13041],"mapped",[12513]],[[13042,13042],"mapped",[12514]],[[13043,13043],"mapped",[12516]],[[13044,13044],"mapped",[12518]],[[13045,13045],"mapped",[12520]],[[13046,13046],"mapped",[12521]],[[13047,13047],"mapped",[12522]],[[13048,13048],"mapped",[12523]],[[13049,13049],"mapped",[12524]],[[13050,13050],"mapped",[12525]],[[13051,13051],"mapped",[12527]],[[13052,13052],"mapped",[12528]],[[13053,13053],"mapped",[12529]],[[13054,13054],"mapped",[12530]],[[13055,13055],"disallowed"],[[13056,13056],"mapped",[12450,12497,12540,12488]],[[13057,13057],"mapped",[12450,12523,12501,12449]],[[13058,13058],"mapped",[12450,12531,12506,12450]],[[13059,13059],"mapped",[12450,12540,12523]],[[13060,13060],"mapped",[12452,12491,12531,12464]],[[13061,13061],"mapped",[12452,12531,12481]],[[13062,13062],"mapped",[12454,12457,12531]],[[13063,13063],"mapped",[12456,12473,12463,12540,12489]],[[13064,13064],"mapped",[12456,12540,12459,12540]],[[13065,13065],"mapped",[12458,12531,12473]],[[13066,13066],"mapped",[12458,12540,12512]],[[13067,13067],"mapped",[12459,12452,12522]],[[13068,13068],"mapped",[12459,12521,12483,12488]],[[13069,13069],"mapped",[12459,12525,12522,12540]],[[13070,13070],"mapped",[12460,12525,12531]],[[13071,13071],"mapped",[12460,12531,12510]],[[13072,13072],"mapped",[12462,12460]],[[13073,13073],"mapped",[12462,12491,12540]],[[13074,13074],"mapped",[12461,12517,12522,12540]],[[13075,13075],"mapped",[12462,12523,12480,12540]],[[13076,13076],"mapped",[12461,12525]],[[13077,13077],"mapped",[12461,12525,12464,12521,12512]],[[13078,13078],"mapped",[12461,12525,12513,12540,12488,12523]],[[13079,13079],"mapped",[12461,12525,12527,12483,12488]],[[13080,13080],"mapped",[12464,12521,12512]],[[13081,13081],"mapped",[12464,12521,12512,12488,12531]],[[13082,13082],"mapped",[12463,12523,12476,12452,12525]],[[13083,13083],"mapped",[12463,12525,12540,12493]],[[13084,13084],"mapped",[12465,12540,12473]],[[13085,13085],"mapped",[12467,12523,12490]],[[13086,13086],"mapped",[12467,12540,12509]],[[13087,13087],"mapped",[12469,12452,12463,12523]],[[13088,13088],"mapped",[12469,12531,12481,12540,12512]],[[13089,13089],"mapped",[12471,12522,12531,12464]],[[13090,13090],"mapped",[12475,12531,12481]],[[13091,13091],"mapped",[12475,12531,12488]],[[13092,13092],"mapped",[12480,12540,12473]],[[13093,13093],"mapped",[12487,12471]],[[13094,13094],"mapped",[12489,12523]],[[13095,13095],"mapped",[12488,12531]],[[13096,13096],"mapped",[12490,12494]],[[13097,13097],"mapped",[12494,12483,12488]],[[13098,13098],"mapped",[12495,12452,12484]],[[13099,13099],"mapped",[12497,12540,12475,12531,12488]],[[13100,13100],"mapped",[12497,12540,12484]],[[13101,13101],"mapped",[12496,12540,12524,12523]],[[13102,13102],"mapped",[12500,12450,12473,12488,12523]],[[13103,13103],"mapped",[12500,12463,12523]],[[13104,13104],"mapped",[12500,12467]],[[13105,13105],"mapped",[12499,12523]],[[13106,13106],"mapped",[12501,12449,12521,12483,12489]],[[13107,13107],"mapped",[12501,12451,12540,12488]],[[13108,13108],"mapped",[12502,12483,12471,12455,12523]],[[13109,13109],"mapped",[12501,12521,12531]],[[13110,13110],"mapped",[12504,12463,12479,12540,12523]],[[13111,13111],"mapped",[12506,12477]],[[13112,13112],"mapped",[12506,12491,12498]],[[13113,13113],"mapped",[12504,12523,12484]],[[13114,13114],"mapped",[12506,12531,12473]],[[13115,13115],"mapped",[12506,12540,12472]],[[13116,13116],"mapped",[12505,12540,12479]],[[13117,13117],"mapped",[12509,12452,12531,12488]],[[13118,13118],"mapped",[12508,12523,12488]],[[13119,13119],"mapped",[12507,12531]],[[13120,13120],"mapped",[12509,12531,12489]],[[13121,13121],"mapped",[12507,12540,12523]],[[13122,13122],"mapped",[12507,12540,12531]],[[13123,13123],"mapped",[12510,12452,12463,12525]],[[13124,13124],"mapped",[12510,12452,12523]],[[13125,13125],"mapped",[12510,12483,12495]],[[13126,13126],"mapped",[12510,12523,12463]],[[13127,13127],"mapped",[12510,12531,12471,12519,12531]],[[13128,13128],"mapped",[12511,12463,12525,12531]],[[13129,13129],"mapped",[12511,12522]],[[13130,13130],"mapped",[12511,12522,12496,12540,12523]],[[13131,13131],"mapped",[12513,12460]],[[13132,13132],"mapped",[12513,12460,12488,12531]],[[13133,13133],"mapped",[12513,12540,12488,12523]],[[13134,13134],"mapped",[12516,12540,12489]],[[13135,13135],"mapped",[12516,12540,12523]],[[13136,13136],"mapped",[12518,12450,12531]],[[13137,13137],"mapped",[12522,12483,12488,12523]],[[13138,13138],"mapped",[12522,12521]],[[13139,13139],"mapped",[12523,12500,12540]],[[13140,13140],"mapped",[12523,12540,12502,12523]],[[13141,13141],"mapped",[12524,12512]],[[13142,13142],"mapped",[12524,12531,12488,12466,12531]],[[13143,13143],"mapped",[12527,12483,12488]],[[13144,13144],"mapped",[48,28857]],[[13145,13145],"mapped",[49,28857]],[[13146,13146],"mapped",[50,28857]],[[13147,13147],"mapped",[51,28857]],[[13148,13148],"mapped",[52,28857]],[[13149,13149],"mapped",[53,28857]],[[13150,13150],"mapped",[54,28857]],[[13151,13151],"mapped",[55,28857]],[[13152,13152],"mapped",[56,28857]],[[13153,13153],"mapped",[57,28857]],[[13154,13154],"mapped",[49,48,28857]],[[13155,13155],"mapped",[49,49,28857]],[[13156,13156],"mapped",[49,50,28857]],[[13157,13157],"mapped",[49,51,28857]],[[13158,13158],"mapped",[49,52,28857]],[[13159,13159],"mapped",[49,53,28857]],[[13160,13160],"mapped",[49,54,28857]],[[13161,13161],"mapped",[49,55,28857]],[[13162,13162],"mapped",[49,56,28857]],[[13163,13163],"mapped",[49,57,28857]],[[13164,13164],"mapped",[50,48,28857]],[[13165,13165],"mapped",[50,49,28857]],[[13166,13166],"mapped",[50,50,28857]],[[13167,13167],"mapped",[50,51,28857]],[[13168,13168],"mapped",[50,52,28857]],[[13169,13169],"mapped",[104,112,97]],[[13170,13170],"mapped",[100,97]],[[13171,13171],"mapped",[97,117]],[[13172,13172],"mapped",[98,97,114]],[[13173,13173],"mapped",[111,118]],[[13174,13174],"mapped",[112,99]],[[13175,13175],"mapped",[100,109]],[[13176,13176],"mapped",[100,109,50]],[[13177,13177],"mapped",[100,109,51]],[[13178,13178],"mapped",[105,117]],[[13179,13179],"mapped",[24179,25104]],[[13180,13180],"mapped",[26157,21644]],[[13181,13181],"mapped",[22823,27491]],[[13182,13182],"mapped",[26126,27835]],[[13183,13183],"mapped",[26666,24335,20250,31038]],[[13184,13184],"mapped",[112,97]],[[13185,13185],"mapped",[110,97]],[[13186,13186],"mapped",[956,97]],[[13187,13187],"mapped",[109,97]],[[13188,13188],"mapped",[107,97]],[[13189,13189],"mapped",[107,98]],[[13190,13190],"mapped",[109,98]],[[13191,13191],"mapped",[103,98]],[[13192,13192],"mapped",[99,97,108]],[[13193,13193],"mapped",[107,99,97,108]],[[13194,13194],"mapped",[112,102]],[[13195,13195],"mapped",[110,102]],[[13196,13196],"mapped",[956,102]],[[13197,13197],"mapped",[956,103]],[[13198,13198],"mapped",[109,103]],[[13199,13199],"mapped",[107,103]],[[13200,13200],"mapped",[104,122]],[[13201,13201],"mapped",[107,104,122]],[[13202,13202],"mapped",[109,104,122]],[[13203,13203],"mapped",[103,104,122]],[[13204,13204],"mapped",[116,104,122]],[[13205,13205],"mapped",[956,108]],[[13206,13206],"mapped",[109,108]],[[13207,13207],"mapped",[100,108]],[[13208,13208],"mapped",[107,108]],[[13209,13209],"mapped",[102,109]],[[13210,13210],"mapped",[110,109]],[[13211,13211],"mapped",[956,109]],[[13212,13212],"mapped",[109,109]],[[13213,13213],"mapped",[99,109]],[[13214,13214],"mapped",[107,109]],[[13215,13215],"mapped",[109,109,50]],[[13216,13216],"mapped",[99,109,50]],[[13217,13217],"mapped",[109,50]],[[13218,13218],"mapped",[107,109,50]],[[13219,13219],"mapped",[109,109,51]],[[13220,13220],"mapped",[99,109,51]],[[13221,13221],"mapped",[109,51]],[[13222,13222],"mapped",[107,109,51]],[[13223,13223],"mapped",[109,8725,115]],[[13224,13224],"mapped",[109,8725,115,50]],[[13225,13225],"mapped",[112,97]],[[13226,13226],"mapped",[107,112,97]],[[13227,13227],"mapped",[109,112,97]],[[13228,13228],"mapped",[103,112,97]],[[13229,13229],"mapped",[114,97,100]],[[13230,13230],"mapped",[114,97,100,8725,115]],[[13231,13231],"mapped",[114,97,100,8725,115,50]],[[13232,13232],"mapped",[112,115]],[[13233,13233],"mapped",[110,115]],[[13234,13234],"mapped",[956,115]],[[13235,13235],"mapped",[109,115]],[[13236,13236],"mapped",[112,118]],[[13237,13237],"mapped",[110,118]],[[13238,13238],"mapped",[956,118]],[[13239,13239],"mapped",[109,118]],[[13240,13240],"mapped",[107,118]],[[13241,13241],"mapped",[109,118]],[[13242,13242],"mapped",[112,119]],[[13243,13243],"mapped",[110,119]],[[13244,13244],"mapped",[956,119]],[[13245,13245],"mapped",[109,119]],[[13246,13246],"mapped",[107,119]],[[13247,13247],"mapped",[109,119]],[[13248,13248],"mapped",[107,969]],[[13249,13249],"mapped",[109,969]],[[13250,13250],"disallowed"],[[13251,13251],"mapped",[98,113]],[[13252,13252],"mapped",[99,99]],[[13253,13253],"mapped",[99,100]],[[13254,13254],"mapped",[99,8725,107,103]],[[13255,13255],"disallowed"],[[13256,13256],"mapped",[100,98]],[[13257,13257],"mapped",[103,121]],[[13258,13258],"mapped",[104,97]],[[13259,13259],"mapped",[104,112]],[[13260,13260],"mapped",[105,110]],[[13261,13261],"mapped",[107,107]],[[13262,13262],"mapped",[107,109]],[[13263,13263],"mapped",[107,116]],[[13264,13264],"mapped",[108,109]],[[13265,13265],"mapped",[108,110]],[[13266,13266],"mapped",[108,111,103]],[[13267,13267],"mapped",[108,120]],[[13268,13268],"mapped",[109,98]],[[13269,13269],"mapped",[109,105,108]],[[13270,13270],"mapped",[109,111,108]],[[13271,13271],"mapped",[112,104]],[[13272,13272],"disallowed"],[[13273,13273],"mapped",[112,112,109]],[[13274,13274],"mapped",[112,114]],[[13275,13275],"mapped",[115,114]],[[13276,13276],"mapped",[115,118]],[[13277,13277],"mapped",[119,98]],[[13278,13278],"mapped",[118,8725,109]],[[13279,13279],"mapped",[97,8725,109]],[[13280,13280],"mapped",[49,26085]],[[13281,13281],"mapped",[50,26085]],[[13282,13282],"mapped",[51,26085]],[[13283,13283],"mapped",[52,26085]],[[13284,13284],"mapped",[53,26085]],[[13285,13285],"mapped",[54,26085]],[[13286,13286],"mapped",[55,26085]],[[13287,13287],"mapped",[56,26085]],[[13288,13288],"mapped",[57,26085]],[[13289,13289],"mapped",[49,48,26085]],[[13290,13290],"mapped",[49,49,26085]],[[13291,13291],"mapped",[49,50,26085]],[[13292,13292],"mapped",[49,51,26085]],[[13293,13293],"mapped",[49,52,26085]],[[13294,13294],"mapped",[49,53,26085]],[[13295,13295],"mapped",[49,54,26085]],[[13296,13296],"mapped",[49,55,26085]],[[13297,13297],"mapped",[49,56,26085]],[[13298,13298],"mapped",[49,57,26085]],[[13299,13299],"mapped",[50,48,26085]],[[13300,13300],"mapped",[50,49,26085]],[[13301,13301],"mapped",[50,50,26085]],[[13302,13302],"mapped",[50,51,26085]],[[13303,13303],"mapped",[50,52,26085]],[[13304,13304],"mapped",[50,53,26085]],[[13305,13305],"mapped",[50,54,26085]],[[13306,13306],"mapped",[50,55,26085]],[[13307,13307],"mapped",[50,56,26085]],[[13308,13308],"mapped",[50,57,26085]],[[13309,13309],"mapped",[51,48,26085]],[[13310,13310],"mapped",[51,49,26085]],[[13311,13311],"mapped",[103,97,108]],[[13312,19893],"valid"],[[19894,19903],"disallowed"],[[19904,19967],"valid",[],"NV8"],[[19968,40869],"valid"],[[40870,40891],"valid"],[[40892,40899],"valid"],[[40900,40907],"valid"],[[40908,40908],"valid"],[[40909,40917],"valid"],[[40918,40959],"disallowed"],[[40960,42124],"valid"],[[42125,42127],"disallowed"],[[42128,42145],"valid",[],"NV8"],[[42146,42147],"valid",[],"NV8"],[[42148,42163],"valid",[],"NV8"],[[42164,42164],"valid",[],"NV8"],[[42165,42176],"valid",[],"NV8"],[[42177,42177],"valid",[],"NV8"],[[42178,42180],"valid",[],"NV8"],[[42181,42181],"valid",[],"NV8"],[[42182,42182],"valid",[],"NV8"],[[42183,42191],"disallowed"],[[42192,42237],"valid"],[[42238,42239],"valid",[],"NV8"],[[42240,42508],"valid"],[[42509,42511],"valid",[],"NV8"],[[42512,42539],"valid"],[[42540,42559],"disallowed"],[[42560,42560],"mapped",[42561]],[[42561,42561],"valid"],[[42562,42562],"mapped",[42563]],[[42563,42563],"valid"],[[42564,42564],"mapped",[42565]],[[42565,42565],"valid"],[[42566,42566],"mapped",[42567]],[[42567,42567],"valid"],[[42568,42568],"mapped",[42569]],[[42569,42569],"valid"],[[42570,42570],"mapped",[42571]],[[42571,42571],"valid"],[[42572,42572],"mapped",[42573]],[[42573,42573],"valid"],[[42574,42574],"mapped",[42575]],[[42575,42575],"valid"],[[42576,42576],"mapped",[42577]],[[42577,42577],"valid"],[[42578,42578],"mapped",[42579]],[[42579,42579],"valid"],[[42580,42580],"mapped",[42581]],[[42581,42581],"valid"],[[42582,42582],"mapped",[42583]],[[42583,42583],"valid"],[[42584,42584],"mapped",[42585]],[[42585,42585],"valid"],[[42586,42586],"mapped",[42587]],[[42587,42587],"valid"],[[42588,42588],"mapped",[42589]],[[42589,42589],"valid"],[[42590,42590],"mapped",[42591]],[[42591,42591],"valid"],[[42592,42592],"mapped",[42593]],[[42593,42593],"valid"],[[42594,42594],"mapped",[42595]],[[42595,42595],"valid"],[[42596,42596],"mapped",[42597]],[[42597,42597],"valid"],[[42598,42598],"mapped",[42599]],[[42599,42599],"valid"],[[42600,42600],"mapped",[42601]],[[42601,42601],"valid"],[[42602,42602],"mapped",[42603]],[[42603,42603],"valid"],[[42604,42604],"mapped",[42605]],[[42605,42607],"valid"],[[42608,42611],"valid",[],"NV8"],[[42612,42619],"valid"],[[42620,42621],"valid"],[[42622,42622],"valid",[],"NV8"],[[42623,42623],"valid"],[[42624,42624],"mapped",[42625]],[[42625,42625],"valid"],[[42626,42626],"mapped",[42627]],[[42627,42627],"valid"],[[42628,42628],"mapped",[42629]],[[42629,42629],"valid"],[[42630,42630],"mapped",[42631]],[[42631,42631],"valid"],[[42632,42632],"mapped",[42633]],[[42633,42633],"valid"],[[42634,42634],"mapped",[42635]],[[42635,42635],"valid"],[[42636,42636],"mapped",[42637]],[[42637,42637],"valid"],[[42638,42638],"mapped",[42639]],[[42639,42639],"valid"],[[42640,42640],"mapped",[42641]],[[42641,42641],"valid"],[[42642,42642],"mapped",[42643]],[[42643,42643],"valid"],[[42644,42644],"mapped",[42645]],[[42645,42645],"valid"],[[42646,42646],"mapped",[42647]],[[42647,42647],"valid"],[[42648,42648],"mapped",[42649]],[[42649,42649],"valid"],[[42650,42650],"mapped",[42651]],[[42651,42651],"valid"],[[42652,42652],"mapped",[1098]],[[42653,42653],"mapped",[1100]],[[42654,42654],"valid"],[[42655,42655],"valid"],[[42656,42725],"valid"],[[42726,42735],"valid",[],"NV8"],[[42736,42737],"valid"],[[42738,42743],"valid",[],"NV8"],[[42744,42751],"disallowed"],[[42752,42774],"valid",[],"NV8"],[[42775,42778],"valid"],[[42779,42783],"valid"],[[42784,42785],"valid",[],"NV8"],[[42786,42786],"mapped",[42787]],[[42787,42787],"valid"],[[42788,42788],"mapped",[42789]],[[42789,42789],"valid"],[[42790,42790],"mapped",[42791]],[[42791,42791],"valid"],[[42792,42792],"mapped",[42793]],[[42793,42793],"valid"],[[42794,42794],"mapped",[42795]],[[42795,42795],"valid"],[[42796,42796],"mapped",[42797]],[[42797,42797],"valid"],[[42798,42798],"mapped",[42799]],[[42799,42801],"valid"],[[42802,42802],"mapped",[42803]],[[42803,42803],"valid"],[[42804,42804],"mapped",[42805]],[[42805,42805],"valid"],[[42806,42806],"mapped",[42807]],[[42807,42807],"valid"],[[42808,42808],"mapped",[42809]],[[42809,42809],"valid"],[[42810,42810],"mapped",[42811]],[[42811,42811],"valid"],[[42812,42812],"mapped",[42813]],[[42813,42813],"valid"],[[42814,42814],"mapped",[42815]],[[42815,42815],"valid"],[[42816,42816],"mapped",[42817]],[[42817,42817],"valid"],[[42818,42818],"mapped",[42819]],[[42819,42819],"valid"],[[42820,42820],"mapped",[42821]],[[42821,42821],"valid"],[[42822,42822],"mapped",[42823]],[[42823,42823],"valid"],[[42824,42824],"mapped",[42825]],[[42825,42825],"valid"],[[42826,42826],"mapped",[42827]],[[42827,42827],"valid"],[[42828,42828],"mapped",[42829]],[[42829,42829],"valid"],[[42830,42830],"mapped",[42831]],[[42831,42831],"valid"],[[42832,42832],"mapped",[42833]],[[42833,42833],"valid"],[[42834,42834],"mapped",[42835]],[[42835,42835],"valid"],[[42836,42836],"mapped",[42837]],[[42837,42837],"valid"],[[42838,42838],"mapped",[42839]],[[42839,42839],"valid"],[[42840,42840],"mapped",[42841]],[[42841,42841],"valid"],[[42842,42842],"mapped",[42843]],[[42843,42843],"valid"],[[42844,42844],"mapped",[42845]],[[42845,42845],"valid"],[[42846,42846],"mapped",[42847]],[[42847,42847],"valid"],[[42848,42848],"mapped",[42849]],[[42849,42849],"valid"],[[42850,42850],"mapped",[42851]],[[42851,42851],"valid"],[[42852,42852],"mapped",[42853]],[[42853,42853],"valid"],[[42854,42854],"mapped",[42855]],[[42855,42855],"valid"],[[42856,42856],"mapped",[42857]],[[42857,42857],"valid"],[[42858,42858],"mapped",[42859]],[[42859,42859],"valid"],[[42860,42860],"mapped",[42861]],[[42861,42861],"valid"],[[42862,42862],"mapped",[42863]],[[42863,42863],"valid"],[[42864,42864],"mapped",[42863]],[[42865,42872],"valid"],[[42873,42873],"mapped",[42874]],[[42874,42874],"valid"],[[42875,42875],"mapped",[42876]],[[42876,42876],"valid"],[[42877,42877],"mapped",[7545]],[[42878,42878],"mapped",[42879]],[[42879,42879],"valid"],[[42880,42880],"mapped",[42881]],[[42881,42881],"valid"],[[42882,42882],"mapped",[42883]],[[42883,42883],"valid"],[[42884,42884],"mapped",[42885]],[[42885,42885],"valid"],[[42886,42886],"mapped",[42887]],[[42887,42888],"valid"],[[42889,42890],"valid",[],"NV8"],[[42891,42891],"mapped",[42892]],[[42892,42892],"valid"],[[42893,42893],"mapped",[613]],[[42894,42894],"valid"],[[42895,42895],"valid"],[[42896,42896],"mapped",[42897]],[[42897,42897],"valid"],[[42898,42898],"mapped",[42899]],[[42899,42899],"valid"],[[42900,42901],"valid"],[[42902,42902],"mapped",[42903]],[[42903,42903],"valid"],[[42904,42904],"mapped",[42905]],[[42905,42905],"valid"],[[42906,42906],"mapped",[42907]],[[42907,42907],"valid"],[[42908,42908],"mapped",[42909]],[[42909,42909],"valid"],[[42910,42910],"mapped",[42911]],[[42911,42911],"valid"],[[42912,42912],"mapped",[42913]],[[42913,42913],"valid"],[[42914,42914],"mapped",[42915]],[[42915,42915],"valid"],[[42916,42916],"mapped",[42917]],[[42917,42917],"valid"],[[42918,42918],"mapped",[42919]],[[42919,42919],"valid"],[[42920,42920],"mapped",[42921]],[[42921,42921],"valid"],[[42922,42922],"mapped",[614]],[[42923,42923],"mapped",[604]],[[42924,42924],"mapped",[609]],[[42925,42925],"mapped",[620]],[[42926,42927],"disallowed"],[[42928,42928],"mapped",[670]],[[42929,42929],"mapped",[647]],[[42930,42930],"mapped",[669]],[[42931,42931],"mapped",[43859]],[[42932,42932],"mapped",[42933]],[[42933,42933],"valid"],[[42934,42934],"mapped",[42935]],[[42935,42935],"valid"],[[42936,42998],"disallowed"],[[42999,42999],"valid"],[[43000,43000],"mapped",[295]],[[43001,43001],"mapped",[339]],[[43002,43002],"valid"],[[43003,43007],"valid"],[[43008,43047],"valid"],[[43048,43051],"valid",[],"NV8"],[[43052,43055],"disallowed"],[[43056,43065],"valid",[],"NV8"],[[43066,43071],"disallowed"],[[43072,43123],"valid"],[[43124,43127],"valid",[],"NV8"],[[43128,43135],"disallowed"],[[43136,43204],"valid"],[[43205,43213],"disallowed"],[[43214,43215],"valid",[],"NV8"],[[43216,43225],"valid"],[[43226,43231],"disallowed"],[[43232,43255],"valid"],[[43256,43258],"valid",[],"NV8"],[[43259,43259],"valid"],[[43260,43260],"valid",[],"NV8"],[[43261,43261],"valid"],[[43262,43263],"disallowed"],[[43264,43309],"valid"],[[43310,43311],"valid",[],"NV8"],[[43312,43347],"valid"],[[43348,43358],"disallowed"],[[43359,43359],"valid",[],"NV8"],[[43360,43388],"valid",[],"NV8"],[[43389,43391],"disallowed"],[[43392,43456],"valid"],[[43457,43469],"valid",[],"NV8"],[[43470,43470],"disallowed"],[[43471,43481],"valid"],[[43482,43485],"disallowed"],[[43486,43487],"valid",[],"NV8"],[[43488,43518],"valid"],[[43519,43519],"disallowed"],[[43520,43574],"valid"],[[43575,43583],"disallowed"],[[43584,43597],"valid"],[[43598,43599],"disallowed"],[[43600,43609],"valid"],[[43610,43611],"disallowed"],[[43612,43615],"valid",[],"NV8"],[[43616,43638],"valid"],[[43639,43641],"valid",[],"NV8"],[[43642,43643],"valid"],[[43644,43647],"valid"],[[43648,43714],"valid"],[[43715,43738],"disallowed"],[[43739,43741],"valid"],[[43742,43743],"valid",[],"NV8"],[[43744,43759],"valid"],[[43760,43761],"valid",[],"NV8"],[[43762,43766],"valid"],[[43767,43776],"disallowed"],[[43777,43782],"valid"],[[43783,43784],"disallowed"],[[43785,43790],"valid"],[[43791,43792],"disallowed"],[[43793,43798],"valid"],[[43799,43807],"disallowed"],[[43808,43814],"valid"],[[43815,43815],"disallowed"],[[43816,43822],"valid"],[[43823,43823],"disallowed"],[[43824,43866],"valid"],[[43867,43867],"valid",[],"NV8"],[[43868,43868],"mapped",[42791]],[[43869,43869],"mapped",[43831]],[[43870,43870],"mapped",[619]],[[43871,43871],"mapped",[43858]],[[43872,43875],"valid"],[[43876,43877],"valid"],[[43878,43887],"disallowed"],[[43888,43888],"mapped",[5024]],[[43889,43889],"mapped",[5025]],[[43890,43890],"mapped",[5026]],[[43891,43891],"mapped",[5027]],[[43892,43892],"mapped",[5028]],[[43893,43893],"mapped",[5029]],[[43894,43894],"mapped",[5030]],[[43895,43895],"mapped",[5031]],[[43896,43896],"mapped",[5032]],[[43897,43897],"mapped",[5033]],[[43898,43898],"mapped",[5034]],[[43899,43899],"mapped",[5035]],[[43900,43900],"mapped",[5036]],[[43901,43901],"mapped",[5037]],[[43902,43902],"mapped",[5038]],[[43903,43903],"mapped",[5039]],[[43904,43904],"mapped",[5040]],[[43905,43905],"mapped",[5041]],[[43906,43906],"mapped",[5042]],[[43907,43907],"mapped",[5043]],[[43908,43908],"mapped",[5044]],[[43909,43909],"mapped",[5045]],[[43910,43910],"mapped",[5046]],[[43911,43911],"mapped",[5047]],[[43912,43912],"mapped",[5048]],[[43913,43913],"mapped",[5049]],[[43914,43914],"mapped",[5050]],[[43915,43915],"mapped",[5051]],[[43916,43916],"mapped",[5052]],[[43917,43917],"mapped",[5053]],[[43918,43918],"mapped",[5054]],[[43919,43919],"mapped",[5055]],[[43920,43920],"mapped",[5056]],[[43921,43921],"mapped",[5057]],[[43922,43922],"mapped",[5058]],[[43923,43923],"mapped",[5059]],[[43924,43924],"mapped",[5060]],[[43925,43925],"mapped",[5061]],[[43926,43926],"mapped",[5062]],[[43927,43927],"mapped",[5063]],[[43928,43928],"mapped",[5064]],[[43929,43929],"mapped",[5065]],[[43930,43930],"mapped",[5066]],[[43931,43931],"mapped",[5067]],[[43932,43932],"mapped",[5068]],[[43933,43933],"mapped",[5069]],[[43934,43934],"mapped",[5070]],[[43935,43935],"mapped",[5071]],[[43936,43936],"mapped",[5072]],[[43937,43937],"mapped",[5073]],[[43938,43938],"mapped",[5074]],[[43939,43939],"mapped",[5075]],[[43940,43940],"mapped",[5076]],[[43941,43941],"mapped",[5077]],[[43942,43942],"mapped",[5078]],[[43943,43943],"mapped",[5079]],[[43944,43944],"mapped",[5080]],[[43945,43945],"mapped",[5081]],[[43946,43946],"mapped",[5082]],[[43947,43947],"mapped",[5083]],[[43948,43948],"mapped",[5084]],[[43949,43949],"mapped",[5085]],[[43950,43950],"mapped",[5086]],[[43951,43951],"mapped",[5087]],[[43952,43952],"mapped",[5088]],[[43953,43953],"mapped",[5089]],[[43954,43954],"mapped",[5090]],[[43955,43955],"mapped",[5091]],[[43956,43956],"mapped",[5092]],[[43957,43957],"mapped",[5093]],[[43958,43958],"mapped",[5094]],[[43959,43959],"mapped",[5095]],[[43960,43960],"mapped",[5096]],[[43961,43961],"mapped",[5097]],[[43962,43962],"mapped",[5098]],[[43963,43963],"mapped",[5099]],[[43964,43964],"mapped",[5100]],[[43965,43965],"mapped",[5101]],[[43966,43966],"mapped",[5102]],[[43967,43967],"mapped",[5103]],[[43968,44010],"valid"],[[44011,44011],"valid",[],"NV8"],[[44012,44013],"valid"],[[44014,44015],"disallowed"],[[44016,44025],"valid"],[[44026,44031],"disallowed"],[[44032,55203],"valid"],[[55204,55215],"disallowed"],[[55216,55238],"valid",[],"NV8"],[[55239,55242],"disallowed"],[[55243,55291],"valid",[],"NV8"],[[55292,55295],"disallowed"],[[55296,57343],"disallowed"],[[57344,63743],"disallowed"],[[63744,63744],"mapped",[35912]],[[63745,63745],"mapped",[26356]],[[63746,63746],"mapped",[36554]],[[63747,63747],"mapped",[36040]],[[63748,63748],"mapped",[28369]],[[63749,63749],"mapped",[20018]],[[63750,63750],"mapped",[21477]],[[63751,63752],"mapped",[40860]],[[63753,63753],"mapped",[22865]],[[63754,63754],"mapped",[37329]],[[63755,63755],"mapped",[21895]],[[63756,63756],"mapped",[22856]],[[63757,63757],"mapped",[25078]],[[63758,63758],"mapped",[30313]],[[63759,63759],"mapped",[32645]],[[63760,63760],"mapped",[34367]],[[63761,63761],"mapped",[34746]],[[63762,63762],"mapped",[35064]],[[63763,63763],"mapped",[37007]],[[63764,63764],"mapped",[27138]],[[63765,63765],"mapped",[27931]],[[63766,63766],"mapped",[28889]],[[63767,63767],"mapped",[29662]],[[63768,63768],"mapped",[33853]],[[63769,63769],"mapped",[37226]],[[63770,63770],"mapped",[39409]],[[63771,63771],"mapped",[20098]],[[63772,63772],"mapped",[21365]],[[63773,63773],"mapped",[27396]],[[63774,63774],"mapped",[29211]],[[63775,63775],"mapped",[34349]],[[63776,63776],"mapped",[40478]],[[63777,63777],"mapped",[23888]],[[63778,63778],"mapped",[28651]],[[63779,63779],"mapped",[34253]],[[63780,63780],"mapped",[35172]],[[63781,63781],"mapped",[25289]],[[63782,63782],"mapped",[33240]],[[63783,63783],"mapped",[34847]],[[63784,63784],"mapped",[24266]],[[63785,63785],"mapped",[26391]],[[63786,63786],"mapped",[28010]],[[63787,63787],"mapped",[29436]],[[63788,63788],"mapped",[37070]],[[63789,63789],"mapped",[20358]],[[63790,63790],"mapped",[20919]],[[63791,63791],"mapped",[21214]],[[63792,63792],"mapped",[25796]],[[63793,63793],"mapped",[27347]],[[63794,63794],"mapped",[29200]],[[63795,63795],"mapped",[30439]],[[63796,63796],"mapped",[32769]],[[63797,63797],"mapped",[34310]],[[63798,63798],"mapped",[34396]],[[63799,63799],"mapped",[36335]],[[63800,63800],"mapped",[38706]],[[63801,63801],"mapped",[39791]],[[63802,63802],"mapped",[40442]],[[63803,63803],"mapped",[30860]],[[63804,63804],"mapped",[31103]],[[63805,63805],"mapped",[32160]],[[63806,63806],"mapped",[33737]],[[63807,63807],"mapped",[37636]],[[63808,63808],"mapped",[40575]],[[63809,63809],"mapped",[35542]],[[63810,63810],"mapped",[22751]],[[63811,63811],"mapped",[24324]],[[63812,63812],"mapped",[31840]],[[63813,63813],"mapped",[32894]],[[63814,63814],"mapped",[29282]],[[63815,63815],"mapped",[30922]],[[63816,63816],"mapped",[36034]],[[63817,63817],"mapped",[38647]],[[63818,63818],"mapped",[22744]],[[63819,63819],"mapped",[23650]],[[63820,63820],"mapped",[27155]],[[63821,63821],"mapped",[28122]],[[63822,63822],"mapped",[28431]],[[63823,63823],"mapped",[32047]],[[63824,63824],"mapped",[32311]],[[63825,63825],"mapped",[38475]],[[63826,63826],"mapped",[21202]],[[63827,63827],"mapped",[32907]],[[63828,63828],"mapped",[20956]],[[63829,63829],"mapped",[20940]],[[63830,63830],"mapped",[31260]],[[63831,63831],"mapped",[32190]],[[63832,63832],"mapped",[33777]],[[63833,63833],"mapped",[38517]],[[63834,63834],"mapped",[35712]],[[63835,63835],"mapped",[25295]],[[63836,63836],"mapped",[27138]],[[63837,63837],"mapped",[35582]],[[63838,63838],"mapped",[20025]],[[63839,63839],"mapped",[23527]],[[63840,63840],"mapped",[24594]],[[63841,63841],"mapped",[29575]],[[63842,63842],"mapped",[30064]],[[63843,63843],"mapped",[21271]],[[63844,63844],"mapped",[30971]],[[63845,63845],"mapped",[20415]],[[63846,63846],"mapped",[24489]],[[63847,63847],"mapped",[19981]],[[63848,63848],"mapped",[27852]],[[63849,63849],"mapped",[25976]],[[63850,63850],"mapped",[32034]],[[63851,63851],"mapped",[21443]],[[63852,63852],"mapped",[22622]],[[63853,63853],"mapped",[30465]],[[63854,63854],"mapped",[33865]],[[63855,63855],"mapped",[35498]],[[63856,63856],"mapped",[27578]],[[63857,63857],"mapped",[36784]],[[63858,63858],"mapped",[27784]],[[63859,63859],"mapped",[25342]],[[63860,63860],"mapped",[33509]],[[63861,63861],"mapped",[25504]],[[63862,63862],"mapped",[30053]],[[63863,63863],"mapped",[20142]],[[63864,63864],"mapped",[20841]],[[63865,63865],"mapped",[20937]],[[63866,63866],"mapped",[26753]],[[63867,63867],"mapped",[31975]],[[63868,63868],"mapped",[33391]],[[63869,63869],"mapped",[35538]],[[63870,63870],"mapped",[37327]],[[63871,63871],"mapped",[21237]],[[63872,63872],"mapped",[21570]],[[63873,63873],"mapped",[22899]],[[63874,63874],"mapped",[24300]],[[63875,63875],"mapped",[26053]],[[63876,63876],"mapped",[28670]],[[63877,63877],"mapped",[31018]],[[63878,63878],"mapped",[38317]],[[63879,63879],"mapped",[39530]],[[63880,63880],"mapped",[40599]],[[63881,63881],"mapped",[40654]],[[63882,63882],"mapped",[21147]],[[63883,63883],"mapped",[26310]],[[63884,63884],"mapped",[27511]],[[63885,63885],"mapped",[36706]],[[63886,63886],"mapped",[24180]],[[63887,63887],"mapped",[24976]],[[63888,63888],"mapped",[25088]],[[63889,63889],"mapped",[25754]],[[63890,63890],"mapped",[28451]],[[63891,63891],"mapped",[29001]],[[63892,63892],"mapped",[29833]],[[63893,63893],"mapped",[31178]],[[63894,63894],"mapped",[32244]],[[63895,63895],"mapped",[32879]],[[63896,63896],"mapped",[36646]],[[63897,63897],"mapped",[34030]],[[63898,63898],"mapped",[36899]],[[63899,63899],"mapped",[37706]],[[63900,63900],"mapped",[21015]],[[63901,63901],"mapped",[21155]],[[63902,63902],"mapped",[21693]],[[63903,63903],"mapped",[28872]],[[63904,63904],"mapped",[35010]],[[63905,63905],"mapped",[35498]],[[63906,63906],"mapped",[24265]],[[63907,63907],"mapped",[24565]],[[63908,63908],"mapped",[25467]],[[63909,63909],"mapped",[27566]],[[63910,63910],"mapped",[31806]],[[63911,63911],"mapped",[29557]],[[63912,63912],"mapped",[20196]],[[63913,63913],"mapped",[22265]],[[63914,63914],"mapped",[23527]],[[63915,63915],"mapped",[23994]],[[63916,63916],"mapped",[24604]],[[63917,63917],"mapped",[29618]],[[63918,63918],"mapped",[29801]],[[63919,63919],"mapped",[32666]],[[63920,63920],"mapped",[32838]],[[63921,63921],"mapped",[37428]],[[63922,63922],"mapped",[38646]],[[63923,63923],"mapped",[38728]],[[63924,63924],"mapped",[38936]],[[63925,63925],"mapped",[20363]],[[63926,63926],"mapped",[31150]],[[63927,63927],"mapped",[37300]],[[63928,63928],"mapped",[38584]],[[63929,63929],"mapped",[24801]],[[63930,63930],"mapped",[20102]],[[63931,63931],"mapped",[20698]],[[63932,63932],"mapped",[23534]],[[63933,63933],"mapped",[23615]],[[63934,63934],"mapped",[26009]],[[63935,63935],"mapped",[27138]],[[63936,63936],"mapped",[29134]],[[63937,63937],"mapped",[30274]],[[63938,63938],"mapped",[34044]],[[63939,63939],"mapped",[36988]],[[63940,63940],"mapped",[40845]],[[63941,63941],"mapped",[26248]],[[63942,63942],"mapped",[38446]],[[63943,63943],"mapped",[21129]],[[63944,63944],"mapped",[26491]],[[63945,63945],"mapped",[26611]],[[63946,63946],"mapped",[27969]],[[63947,63947],"mapped",[28316]],[[63948,63948],"mapped",[29705]],[[63949,63949],"mapped",[30041]],[[63950,63950],"mapped",[30827]],[[63951,63951],"mapped",[32016]],[[63952,63952],"mapped",[39006]],[[63953,63953],"mapped",[20845]],[[63954,63954],"mapped",[25134]],[[63955,63955],"mapped",[38520]],[[63956,63956],"mapped",[20523]],[[63957,63957],"mapped",[23833]],[[63958,63958],"mapped",[28138]],[[63959,63959],"mapped",[36650]],[[63960,63960],"mapped",[24459]],[[63961,63961],"mapped",[24900]],[[63962,63962],"mapped",[26647]],[[63963,63963],"mapped",[29575]],[[63964,63964],"mapped",[38534]],[[63965,63965],"mapped",[21033]],[[63966,63966],"mapped",[21519]],[[63967,63967],"mapped",[23653]],[[63968,63968],"mapped",[26131]],[[63969,63969],"mapped",[26446]],[[63970,63970],"mapped",[26792]],[[63971,63971],"mapped",[27877]],[[63972,63972],"mapped",[29702]],[[63973,63973],"mapped",[30178]],[[63974,63974],"mapped",[32633]],[[63975,63975],"mapped",[35023]],[[63976,63976],"mapped",[35041]],[[63977,63977],"mapped",[37324]],[[63978,63978],"mapped",[38626]],[[63979,63979],"mapped",[21311]],[[63980,63980],"mapped",[28346]],[[63981,63981],"mapped",[21533]],[[63982,63982],"mapped",[29136]],[[63983,63983],"mapped",[29848]],[[63984,63984],"mapped",[34298]],[[63985,63985],"mapped",[38563]],[[63986,63986],"mapped",[40023]],[[63987,63987],"mapped",[40607]],[[63988,63988],"mapped",[26519]],[[63989,63989],"mapped",[28107]],[[63990,63990],"mapped",[33256]],[[63991,63991],"mapped",[31435]],[[63992,63992],"mapped",[31520]],[[63993,63993],"mapped",[31890]],[[63994,63994],"mapped",[29376]],[[63995,63995],"mapped",[28825]],[[63996,63996],"mapped",[35672]],[[63997,63997],"mapped",[20160]],[[63998,63998],"mapped",[33590]],[[63999,63999],"mapped",[21050]],[[64000,64000],"mapped",[20999]],[[64001,64001],"mapped",[24230]],[[64002,64002],"mapped",[25299]],[[64003,64003],"mapped",[31958]],[[64004,64004],"mapped",[23429]],[[64005,64005],"mapped",[27934]],[[64006,64006],"mapped",[26292]],[[64007,64007],"mapped",[36667]],[[64008,64008],"mapped",[34892]],[[64009,64009],"mapped",[38477]],[[64010,64010],"mapped",[35211]],[[64011,64011],"mapped",[24275]],[[64012,64012],"mapped",[20800]],[[64013,64013],"mapped",[21952]],[[64014,64015],"valid"],[[64016,64016],"mapped",[22618]],[[64017,64017],"valid"],[[64018,64018],"mapped",[26228]],[[64019,64020],"valid"],[[64021,64021],"mapped",[20958]],[[64022,64022],"mapped",[29482]],[[64023,64023],"mapped",[30410]],[[64024,64024],"mapped",[31036]],[[64025,64025],"mapped",[31070]],[[64026,64026],"mapped",[31077]],[[64027,64027],"mapped",[31119]],[[64028,64028],"mapped",[38742]],[[64029,64029],"mapped",[31934]],[[64030,64030],"mapped",[32701]],[[64031,64031],"valid"],[[64032,64032],"mapped",[34322]],[[64033,64033],"valid"],[[64034,64034],"mapped",[35576]],[[64035,64036],"valid"],[[64037,64037],"mapped",[36920]],[[64038,64038],"mapped",[37117]],[[64039,64041],"valid"],[[64042,64042],"mapped",[39151]],[[64043,64043],"mapped",[39164]],[[64044,64044],"mapped",[39208]],[[64045,64045],"mapped",[40372]],[[64046,64046],"mapped",[37086]],[[64047,64047],"mapped",[38583]],[[64048,64048],"mapped",[20398]],[[64049,64049],"mapped",[20711]],[[64050,64050],"mapped",[20813]],[[64051,64051],"mapped",[21193]],[[64052,64052],"mapped",[21220]],[[64053,64053],"mapped",[21329]],[[64054,64054],"mapped",[21917]],[[64055,64055],"mapped",[22022]],[[64056,64056],"mapped",[22120]],[[64057,64057],"mapped",[22592]],[[64058,64058],"mapped",[22696]],[[64059,64059],"mapped",[23652]],[[64060,64060],"mapped",[23662]],[[64061,64061],"mapped",[24724]],[[64062,64062],"mapped",[24936]],[[64063,64063],"mapped",[24974]],[[64064,64064],"mapped",[25074]],[[64065,64065],"mapped",[25935]],[[64066,64066],"mapped",[26082]],[[64067,64067],"mapped",[26257]],[[64068,64068],"mapped",[26757]],[[64069,64069],"mapped",[28023]],[[64070,64070],"mapped",[28186]],[[64071,64071],"mapped",[28450]],[[64072,64072],"mapped",[29038]],[[64073,64073],"mapped",[29227]],[[64074,64074],"mapped",[29730]],[[64075,64075],"mapped",[30865]],[[64076,64076],"mapped",[31038]],[[64077,64077],"mapped",[31049]],[[64078,64078],"mapped",[31048]],[[64079,64079],"mapped",[31056]],[[64080,64080],"mapped",[31062]],[[64081,64081],"mapped",[31069]],[[64082,64082],"mapped",[31117]],[[64083,64083],"mapped",[31118]],[[64084,64084],"mapped",[31296]],[[64085,64085],"mapped",[31361]],[[64086,64086],"mapped",[31680]],[[64087,64087],"mapped",[32244]],[[64088,64088],"mapped",[32265]],[[64089,64089],"mapped",[32321]],[[64090,64090],"mapped",[32626]],[[64091,64091],"mapped",[32773]],[[64092,64092],"mapped",[33261]],[[64093,64094],"mapped",[33401]],[[64095,64095],"mapped",[33879]],[[64096,64096],"mapped",[35088]],[[64097,64097],"mapped",[35222]],[[64098,64098],"mapped",[35585]],[[64099,64099],"mapped",[35641]],[[64100,64100],"mapped",[36051]],[[64101,64101],"mapped",[36104]],[[64102,64102],"mapped",[36790]],[[64103,64103],"mapped",[36920]],[[64104,64104],"mapped",[38627]],[[64105,64105],"mapped",[38911]],[[64106,64106],"mapped",[38971]],[[64107,64107],"mapped",[24693]],[[64108,64108],"mapped",[148206]],[[64109,64109],"mapped",[33304]],[[64110,64111],"disallowed"],[[64112,64112],"mapped",[20006]],[[64113,64113],"mapped",[20917]],[[64114,64114],"mapped",[20840]],[[64115,64115],"mapped",[20352]],[[64116,64116],"mapped",[20805]],[[64117,64117],"mapped",[20864]],[[64118,64118],"mapped",[21191]],[[64119,64119],"mapped",[21242]],[[64120,64120],"mapped",[21917]],[[64121,64121],"mapped",[21845]],[[64122,64122],"mapped",[21913]],[[64123,64123],"mapped",[21986]],[[64124,64124],"mapped",[22618]],[[64125,64125],"mapped",[22707]],[[64126,64126],"mapped",[22852]],[[64127,64127],"mapped",[22868]],[[64128,64128],"mapped",[23138]],[[64129,64129],"mapped",[23336]],[[64130,64130],"mapped",[24274]],[[64131,64131],"mapped",[24281]],[[64132,64132],"mapped",[24425]],[[64133,64133],"mapped",[24493]],[[64134,64134],"mapped",[24792]],[[64135,64135],"mapped",[24910]],[[64136,64136],"mapped",[24840]],[[64137,64137],"mapped",[24974]],[[64138,64138],"mapped",[24928]],[[64139,64139],"mapped",[25074]],[[64140,64140],"mapped",[25140]],[[64141,64141],"mapped",[25540]],[[64142,64142],"mapped",[25628]],[[64143,64143],"mapped",[25682]],[[64144,64144],"mapped",[25942]],[[64145,64145],"mapped",[26228]],[[64146,64146],"mapped",[26391]],[[64147,64147],"mapped",[26395]],[[64148,64148],"mapped",[26454]],[[64149,64149],"mapped",[27513]],[[64150,64150],"mapped",[27578]],[[64151,64151],"mapped",[27969]],[[64152,64152],"mapped",[28379]],[[64153,64153],"mapped",[28363]],[[64154,64154],"mapped",[28450]],[[64155,64155],"mapped",[28702]],[[64156,64156],"mapped",[29038]],[[64157,64157],"mapped",[30631]],[[64158,64158],"mapped",[29237]],[[64159,64159],"mapped",[29359]],[[64160,64160],"mapped",[29482]],[[64161,64161],"mapped",[29809]],[[64162,64162],"mapped",[29958]],[[64163,64163],"mapped",[30011]],[[64164,64164],"mapped",[30237]],[[64165,64165],"mapped",[30239]],[[64166,64166],"mapped",[30410]],[[64167,64167],"mapped",[30427]],[[64168,64168],"mapped",[30452]],[[64169,64169],"mapped",[30538]],[[64170,64170],"mapped",[30528]],[[64171,64171],"mapped",[30924]],[[64172,64172],"mapped",[31409]],[[64173,64173],"mapped",[31680]],[[64174,64174],"mapped",[31867]],[[64175,64175],"mapped",[32091]],[[64176,64176],"mapped",[32244]],[[64177,64177],"mapped",[32574]],[[64178,64178],"mapped",[32773]],[[64179,64179],"mapped",[33618]],[[64180,64180],"mapped",[33775]],[[64181,64181],"mapped",[34681]],[[64182,64182],"mapped",[35137]],[[64183,64183],"mapped",[35206]],[[64184,64184],"mapped",[35222]],[[64185,64185],"mapped",[35519]],[[64186,64186],"mapped",[35576]],[[64187,64187],"mapped",[35531]],[[64188,64188],"mapped",[35585]],[[64189,64189],"mapped",[35582]],[[64190,64190],"mapped",[35565]],[[64191,64191],"mapped",[35641]],[[64192,64192],"mapped",[35722]],[[64193,64193],"mapped",[36104]],[[64194,64194],"mapped",[36664]],[[64195,64195],"mapped",[36978]],[[64196,64196],"mapped",[37273]],[[64197,64197],"mapped",[37494]],[[64198,64198],"mapped",[38524]],[[64199,64199],"mapped",[38627]],[[64200,64200],"mapped",[38742]],[[64201,64201],"mapped",[38875]],[[64202,64202],"mapped",[38911]],[[64203,64203],"mapped",[38923]],[[64204,64204],"mapped",[38971]],[[64205,64205],"mapped",[39698]],[[64206,64206],"mapped",[40860]],[[64207,64207],"mapped",[141386]],[[64208,64208],"mapped",[141380]],[[64209,64209],"mapped",[144341]],[[64210,64210],"mapped",[15261]],[[64211,64211],"mapped",[16408]],[[64212,64212],"mapped",[16441]],[[64213,64213],"mapped",[152137]],[[64214,64214],"mapped",[154832]],[[64215,64215],"mapped",[163539]],[[64216,64216],"mapped",[40771]],[[64217,64217],"mapped",[40846]],[[64218,64255],"disallowed"],[[64256,64256],"mapped",[102,102]],[[64257,64257],"mapped",[102,105]],[[64258,64258],"mapped",[102,108]],[[64259,64259],"mapped",[102,102,105]],[[64260,64260],"mapped",[102,102,108]],[[64261,64262],"mapped",[115,116]],[[64263,64274],"disallowed"],[[64275,64275],"mapped",[1396,1398]],[[64276,64276],"mapped",[1396,1381]],[[64277,64277],"mapped",[1396,1387]],[[64278,64278],"mapped",[1406,1398]],[[64279,64279],"mapped",[1396,1389]],[[64280,64284],"disallowed"],[[64285,64285],"mapped",[1497,1460]],[[64286,64286],"valid"],[[64287,64287],"mapped",[1522,1463]],[[64288,64288],"mapped",[1506]],[[64289,64289],"mapped",[1488]],[[64290,64290],"mapped",[1491]],[[64291,64291],"mapped",[1492]],[[64292,64292],"mapped",[1499]],[[64293,64293],"mapped",[1500]],[[64294,64294],"mapped",[1501]],[[64295,64295],"mapped",[1512]],[[64296,64296],"mapped",[1514]],[[64297,64297],"disallowed_STD3_mapped",[43]],[[64298,64298],"mapped",[1513,1473]],[[64299,64299],"mapped",[1513,1474]],[[64300,64300],"mapped",[1513,1468,1473]],[[64301,64301],"mapped",[1513,1468,1474]],[[64302,64302],"mapped",[1488,1463]],[[64303,64303],"mapped",[1488,1464]],[[64304,64304],"mapped",[1488,1468]],[[64305,64305],"mapped",[1489,1468]],[[64306,64306],"mapped",[1490,1468]],[[64307,64307],"mapped",[1491,1468]],[[64308,64308],"mapped",[1492,1468]],[[64309,64309],"mapped",[1493,1468]],[[64310,64310],"mapped",[1494,1468]],[[64311,64311],"disallowed"],[[64312,64312],"mapped",[1496,1468]],[[64313,64313],"mapped",[1497,1468]],[[64314,64314],"mapped",[1498,1468]],[[64315,64315],"mapped",[1499,1468]],[[64316,64316],"mapped",[1500,1468]],[[64317,64317],"disallowed"],[[64318,64318],"mapped",[1502,1468]],[[64319,64319],"disallowed"],[[64320,64320],"mapped",[1504,1468]],[[64321,64321],"mapped",[1505,1468]],[[64322,64322],"disallowed"],[[64323,64323],"mapped",[1507,1468]],[[64324,64324],"mapped",[1508,1468]],[[64325,64325],"disallowed"],[[64326,64326],"mapped",[1510,1468]],[[64327,64327],"mapped",[1511,1468]],[[64328,64328],"mapped",[1512,1468]],[[64329,64329],"mapped",[1513,1468]],[[64330,64330],"mapped",[1514,1468]],[[64331,64331],"mapped",[1493,1465]],[[64332,64332],"mapped",[1489,1471]],[[64333,64333],"mapped",[1499,1471]],[[64334,64334],"mapped",[1508,1471]],[[64335,64335],"mapped",[1488,1500]],[[64336,64337],"mapped",[1649]],[[64338,64341],"mapped",[1659]],[[64342,64345],"mapped",[1662]],[[64346,64349],"mapped",[1664]],[[64350,64353],"mapped",[1658]],[[64354,64357],"mapped",[1663]],[[64358,64361],"mapped",[1657]],[[64362,64365],"mapped",[1700]],[[64366,64369],"mapped",[1702]],[[64370,64373],"mapped",[1668]],[[64374,64377],"mapped",[1667]],[[64378,64381],"mapped",[1670]],[[64382,64385],"mapped",[1671]],[[64386,64387],"mapped",[1677]],[[64388,64389],"mapped",[1676]],[[64390,64391],"mapped",[1678]],[[64392,64393],"mapped",[1672]],[[64394,64395],"mapped",[1688]],[[64396,64397],"mapped",[1681]],[[64398,64401],"mapped",[1705]],[[64402,64405],"mapped",[1711]],[[64406,64409],"mapped",[1715]],[[64410,64413],"mapped",[1713]],[[64414,64415],"mapped",[1722]],[[64416,64419],"mapped",[1723]],[[64420,64421],"mapped",[1728]],[[64422,64425],"mapped",[1729]],[[64426,64429],"mapped",[1726]],[[64430,64431],"mapped",[1746]],[[64432,64433],"mapped",[1747]],[[64434,64449],"valid",[],"NV8"],[[64450,64466],"disallowed"],[[64467,64470],"mapped",[1709]],[[64471,64472],"mapped",[1735]],[[64473,64474],"mapped",[1734]],[[64475,64476],"mapped",[1736]],[[64477,64477],"mapped",[1735,1652]],[[64478,64479],"mapped",[1739]],[[64480,64481],"mapped",[1733]],[[64482,64483],"mapped",[1737]],[[64484,64487],"mapped",[1744]],[[64488,64489],"mapped",[1609]],[[64490,64491],"mapped",[1574,1575]],[[64492,64493],"mapped",[1574,1749]],[[64494,64495],"mapped",[1574,1608]],[[64496,64497],"mapped",[1574,1735]],[[64498,64499],"mapped",[1574,1734]],[[64500,64501],"mapped",[1574,1736]],[[64502,64504],"mapped",[1574,1744]],[[64505,64507],"mapped",[1574,1609]],[[64508,64511],"mapped",[1740]],[[64512,64512],"mapped",[1574,1580]],[[64513,64513],"mapped",[1574,1581]],[[64514,64514],"mapped",[1574,1605]],[[64515,64515],"mapped",[1574,1609]],[[64516,64516],"mapped",[1574,1610]],[[64517,64517],"mapped",[1576,1580]],[[64518,64518],"mapped",[1576,1581]],[[64519,64519],"mapped",[1576,1582]],[[64520,64520],"mapped",[1576,1605]],[[64521,64521],"mapped",[1576,1609]],[[64522,64522],"mapped",[1576,1610]],[[64523,64523],"mapped",[1578,1580]],[[64524,64524],"mapped",[1578,1581]],[[64525,64525],"mapped",[1578,1582]],[[64526,64526],"mapped",[1578,1605]],[[64527,64527],"mapped",[1578,1609]],[[64528,64528],"mapped",[1578,1610]],[[64529,64529],"mapped",[1579,1580]],[[64530,64530],"mapped",[1579,1605]],[[64531,64531],"mapped",[1579,1609]],[[64532,64532],"mapped",[1579,1610]],[[64533,64533],"mapped",[1580,1581]],[[64534,64534],"mapped",[1580,1605]],[[64535,64535],"mapped",[1581,1580]],[[64536,64536],"mapped",[1581,1605]],[[64537,64537],"mapped",[1582,1580]],[[64538,64538],"mapped",[1582,1581]],[[64539,64539],"mapped",[1582,1605]],[[64540,64540],"mapped",[1587,1580]],[[64541,64541],"mapped",[1587,1581]],[[64542,64542],"mapped",[1587,1582]],[[64543,64543],"mapped",[1587,1605]],[[64544,64544],"mapped",[1589,1581]],[[64545,64545],"mapped",[1589,1605]],[[64546,64546],"mapped",[1590,1580]],[[64547,64547],"mapped",[1590,1581]],[[64548,64548],"mapped",[1590,1582]],[[64549,64549],"mapped",[1590,1605]],[[64550,64550],"mapped",[1591,1581]],[[64551,64551],"mapped",[1591,1605]],[[64552,64552],"mapped",[1592,1605]],[[64553,64553],"mapped",[1593,1580]],[[64554,64554],"mapped",[1593,1605]],[[64555,64555],"mapped",[1594,1580]],[[64556,64556],"mapped",[1594,1605]],[[64557,64557],"mapped",[1601,1580]],[[64558,64558],"mapped",[1601,1581]],[[64559,64559],"mapped",[1601,1582]],[[64560,64560],"mapped",[1601,1605]],[[64561,64561],"mapped",[1601,1609]],[[64562,64562],"mapped",[1601,1610]],[[64563,64563],"mapped",[1602,1581]],[[64564,64564],"mapped",[1602,1605]],[[64565,64565],"mapped",[1602,1609]],[[64566,64566],"mapped",[1602,1610]],[[64567,64567],"mapped",[1603,1575]],[[64568,64568],"mapped",[1603,1580]],[[64569,64569],"mapped",[1603,1581]],[[64570,64570],"mapped",[1603,1582]],[[64571,64571],"mapped",[1603,1604]],[[64572,64572],"mapped",[1603,1605]],[[64573,64573],"mapped",[1603,1609]],[[64574,64574],"mapped",[1603,1610]],[[64575,64575],"mapped",[1604,1580]],[[64576,64576],"mapped",[1604,1581]],[[64577,64577],"mapped",[1604,1582]],[[64578,64578],"mapped",[1604,1605]],[[64579,64579],"mapped",[1604,1609]],[[64580,64580],"mapped",[1604,1610]],[[64581,64581],"mapped",[1605,1580]],[[64582,64582],"mapped",[1605,1581]],[[64583,64583],"mapped",[1605,1582]],[[64584,64584],"mapped",[1605,1605]],[[64585,64585],"mapped",[1605,1609]],[[64586,64586],"mapped",[1605,1610]],[[64587,64587],"mapped",[1606,1580]],[[64588,64588],"mapped",[1606,1581]],[[64589,64589],"mapped",[1606,1582]],[[64590,64590],"mapped",[1606,1605]],[[64591,64591],"mapped",[1606,1609]],[[64592,64592],"mapped",[1606,1610]],[[64593,64593],"mapped",[1607,1580]],[[64594,64594],"mapped",[1607,1605]],[[64595,64595],"mapped",[1607,1609]],[[64596,64596],"mapped",[1607,1610]],[[64597,64597],"mapped",[1610,1580]],[[64598,64598],"mapped",[1610,1581]],[[64599,64599],"mapped",[1610,1582]],[[64600,64600],"mapped",[1610,1605]],[[64601,64601],"mapped",[1610,1609]],[[64602,64602],"mapped",[1610,1610]],[[64603,64603],"mapped",[1584,1648]],[[64604,64604],"mapped",[1585,1648]],[[64605,64605],"mapped",[1609,1648]],[[64606,64606],"disallowed_STD3_mapped",[32,1612,1617]],[[64607,64607],"disallowed_STD3_mapped",[32,1613,1617]],[[64608,64608],"disallowed_STD3_mapped",[32,1614,1617]],[[64609,64609],"disallowed_STD3_mapped",[32,1615,1617]],[[64610,64610],"disallowed_STD3_mapped",[32,1616,1617]],[[64611,64611],"disallowed_STD3_mapped",[32,1617,1648]],[[64612,64612],"mapped",[1574,1585]],[[64613,64613],"mapped",[1574,1586]],[[64614,64614],"mapped",[1574,1605]],[[64615,64615],"mapped",[1574,1606]],[[64616,64616],"mapped",[1574,1609]],[[64617,64617],"mapped",[1574,1610]],[[64618,64618],"mapped",[1576,1585]],[[64619,64619],"mapped",[1576,1586]],[[64620,64620],"mapped",[1576,1605]],[[64621,64621],"mapped",[1576,1606]],[[64622,64622],"mapped",[1576,1609]],[[64623,64623],"mapped",[1576,1610]],[[64624,64624],"mapped",[1578,1585]],[[64625,64625],"mapped",[1578,1586]],[[64626,64626],"mapped",[1578,1605]],[[64627,64627],"mapped",[1578,1606]],[[64628,64628],"mapped",[1578,1609]],[[64629,64629],"mapped",[1578,1610]],[[64630,64630],"mapped",[1579,1585]],[[64631,64631],"mapped",[1579,1586]],[[64632,64632],"mapped",[1579,1605]],[[64633,64633],"mapped",[1579,1606]],[[64634,64634],"mapped",[1579,1609]],[[64635,64635],"mapped",[1579,1610]],[[64636,64636],"mapped",[1601,1609]],[[64637,64637],"mapped",[1601,1610]],[[64638,64638],"mapped",[1602,1609]],[[64639,64639],"mapped",[1602,1610]],[[64640,64640],"mapped",[1603,1575]],[[64641,64641],"mapped",[1603,1604]],[[64642,64642],"mapped",[1603,1605]],[[64643,64643],"mapped",[1603,1609]],[[64644,64644],"mapped",[1603,1610]],[[64645,64645],"mapped",[1604,1605]],[[64646,64646],"mapped",[1604,1609]],[[64647,64647],"mapped",[1604,1610]],[[64648,64648],"mapped",[1605,1575]],[[64649,64649],"mapped",[1605,1605]],[[64650,64650],"mapped",[1606,1585]],[[64651,64651],"mapped",[1606,1586]],[[64652,64652],"mapped",[1606,1605]],[[64653,64653],"mapped",[1606,1606]],[[64654,64654],"mapped",[1606,1609]],[[64655,64655],"mapped",[1606,1610]],[[64656,64656],"mapped",[1609,1648]],[[64657,64657],"mapped",[1610,1585]],[[64658,64658],"mapped",[1610,1586]],[[64659,64659],"mapped",[1610,1605]],[[64660,64660],"mapped",[1610,1606]],[[64661,64661],"mapped",[1610,1609]],[[64662,64662],"mapped",[1610,1610]],[[64663,64663],"mapped",[1574,1580]],[[64664,64664],"mapped",[1574,1581]],[[64665,64665],"mapped",[1574,1582]],[[64666,64666],"mapped",[1574,1605]],[[64667,64667],"mapped",[1574,1607]],[[64668,64668],"mapped",[1576,1580]],[[64669,64669],"mapped",[1576,1581]],[[64670,64670],"mapped",[1576,1582]],[[64671,64671],"mapped",[1576,1605]],[[64672,64672],"mapped",[1576,1607]],[[64673,64673],"mapped",[1578,1580]],[[64674,64674],"mapped",[1578,1581]],[[64675,64675],"mapped",[1578,1582]],[[64676,64676],"mapped",[1578,1605]],[[64677,64677],"mapped",[1578,1607]],[[64678,64678],"mapped",[1579,1605]],[[64679,64679],"mapped",[1580,1581]],[[64680,64680],"mapped",[1580,1605]],[[64681,64681],"mapped",[1581,1580]],[[64682,64682],"mapped",[1581,1605]],[[64683,64683],"mapped",[1582,1580]],[[64684,64684],"mapped",[1582,1605]],[[64685,64685],"mapped",[1587,1580]],[[64686,64686],"mapped",[1587,1581]],[[64687,64687],"mapped",[1587,1582]],[[64688,64688],"mapped",[1587,1605]],[[64689,64689],"mapped",[1589,1581]],[[64690,64690],"mapped",[1589,1582]],[[64691,64691],"mapped",[1589,1605]],[[64692,64692],"mapped",[1590,1580]],[[64693,64693],"mapped",[1590,1581]],[[64694,64694],"mapped",[1590,1582]],[[64695,64695],"mapped",[1590,1605]],[[64696,64696],"mapped",[1591,1581]],[[64697,64697],"mapped",[1592,1605]],[[64698,64698],"mapped",[1593,1580]],[[64699,64699],"mapped",[1593,1605]],[[64700,64700],"mapped",[1594,1580]],[[64701,64701],"mapped",[1594,1605]],[[64702,64702],"mapped",[1601,1580]],[[64703,64703],"mapped",[1601,1581]],[[64704,64704],"mapped",[1601,1582]],[[64705,64705],"mapped",[1601,1605]],[[64706,64706],"mapped",[1602,1581]],[[64707,64707],"mapped",[1602,1605]],[[64708,64708],"mapped",[1603,1580]],[[64709,64709],"mapped",[1603,1581]],[[64710,64710],"mapped",[1603,1582]],[[64711,64711],"mapped",[1603,1604]],[[64712,64712],"mapped",[1603,1605]],[[64713,64713],"mapped",[1604,1580]],[[64714,64714],"mapped",[1604,1581]],[[64715,64715],"mapped",[1604,1582]],[[64716,64716],"mapped",[1604,1605]],[[64717,64717],"mapped",[1604,1607]],[[64718,64718],"mapped",[1605,1580]],[[64719,64719],"mapped",[1605,1581]],[[64720,64720],"mapped",[1605,1582]],[[64721,64721],"mapped",[1605,1605]],[[64722,64722],"mapped",[1606,1580]],[[64723,64723],"mapped",[1606,1581]],[[64724,64724],"mapped",[1606,1582]],[[64725,64725],"mapped",[1606,1605]],[[64726,64726],"mapped",[1606,1607]],[[64727,64727],"mapped",[1607,1580]],[[64728,64728],"mapped",[1607,1605]],[[64729,64729],"mapped",[1607,1648]],[[64730,64730],"mapped",[1610,1580]],[[64731,64731],"mapped",[1610,1581]],[[64732,64732],"mapped",[1610,1582]],[[64733,64733],"mapped",[1610,1605]],[[64734,64734],"mapped",[1610,1607]],[[64735,64735],"mapped",[1574,1605]],[[64736,64736],"mapped",[1574,1607]],[[64737,64737],"mapped",[1576,1605]],[[64738,64738],"mapped",[1576,1607]],[[64739,64739],"mapped",[1578,1605]],[[64740,64740],"mapped",[1578,1607]],[[64741,64741],"mapped",[1579,1605]],[[64742,64742],"mapped",[1579,1607]],[[64743,64743],"mapped",[1587,1605]],[[64744,64744],"mapped",[1587,1607]],[[64745,64745],"mapped",[1588,1605]],[[64746,64746],"mapped",[1588,1607]],[[64747,64747],"mapped",[1603,1604]],[[64748,64748],"mapped",[1603,1605]],[[64749,64749],"mapped",[1604,1605]],[[64750,64750],"mapped",[1606,1605]],[[64751,64751],"mapped",[1606,1607]],[[64752,64752],"mapped",[1610,1605]],[[64753,64753],"mapped",[1610,1607]],[[64754,64754],"mapped",[1600,1614,1617]],[[64755,64755],"mapped",[1600,1615,1617]],[[64756,64756],"mapped",[1600,1616,1617]],[[64757,64757],"mapped",[1591,1609]],[[64758,64758],"mapped",[1591,1610]],[[64759,64759],"mapped",[1593,1609]],[[64760,64760],"mapped",[1593,1610]],[[64761,64761],"mapped",[1594,1609]],[[64762,64762],"mapped",[1594,1610]],[[64763,64763],"mapped",[1587,1609]],[[64764,64764],"mapped",[1587,1610]],[[64765,64765],"mapped",[1588,1609]],[[64766,64766],"mapped",[1588,1610]],[[64767,64767],"mapped",[1581,1609]],[[64768,64768],"mapped",[1581,1610]],[[64769,64769],"mapped",[1580,1609]],[[64770,64770],"mapped",[1580,1610]],[[64771,64771],"mapped",[1582,1609]],[[64772,64772],"mapped",[1582,1610]],[[64773,64773],"mapped",[1589,1609]],[[64774,64774],"mapped",[1589,1610]],[[64775,64775],"mapped",[1590,1609]],[[64776,64776],"mapped",[1590,1610]],[[64777,64777],"mapped",[1588,1580]],[[64778,64778],"mapped",[1588,1581]],[[64779,64779],"mapped",[1588,1582]],[[64780,64780],"mapped",[1588,1605]],[[64781,64781],"mapped",[1588,1585]],[[64782,64782],"mapped",[1587,1585]],[[64783,64783],"mapped",[1589,1585]],[[64784,64784],"mapped",[1590,1585]],[[64785,64785],"mapped",[1591,1609]],[[64786,64786],"mapped",[1591,1610]],[[64787,64787],"mapped",[1593,1609]],[[64788,64788],"mapped",[1593,1610]],[[64789,64789],"mapped",[1594,1609]],[[64790,64790],"mapped",[1594,1610]],[[64791,64791],"mapped",[1587,1609]],[[64792,64792],"mapped",[1587,1610]],[[64793,64793],"mapped",[1588,1609]],[[64794,64794],"mapped",[1588,1610]],[[64795,64795],"mapped",[1581,1609]],[[64796,64796],"mapped",[1581,1610]],[[64797,64797],"mapped",[1580,1609]],[[64798,64798],"mapped",[1580,1610]],[[64799,64799],"mapped",[1582,1609]],[[64800,64800],"mapped",[1582,1610]],[[64801,64801],"mapped",[1589,1609]],[[64802,64802],"mapped",[1589,1610]],[[64803,64803],"mapped",[1590,1609]],[[64804,64804],"mapped",[1590,1610]],[[64805,64805],"mapped",[1588,1580]],[[64806,64806],"mapped",[1588,1581]],[[64807,64807],"mapped",[1588,1582]],[[64808,64808],"mapped",[1588,1605]],[[64809,64809],"mapped",[1588,1585]],[[64810,64810],"mapped",[1587,1585]],[[64811,64811],"mapped",[1589,1585]],[[64812,64812],"mapped",[1590,1585]],[[64813,64813],"mapped",[1588,1580]],[[64814,64814],"mapped",[1588,1581]],[[64815,64815],"mapped",[1588,1582]],[[64816,64816],"mapped",[1588,1605]],[[64817,64817],"mapped",[1587,1607]],[[64818,64818],"mapped",[1588,1607]],[[64819,64819],"mapped",[1591,1605]],[[64820,64820],"mapped",[1587,1580]],[[64821,64821],"mapped",[1587,1581]],[[64822,64822],"mapped",[1587,1582]],[[64823,64823],"mapped",[1588,1580]],[[64824,64824],"mapped",[1588,1581]],[[64825,64825],"mapped",[1588,1582]],[[64826,64826],"mapped",[1591,1605]],[[64827,64827],"mapped",[1592,1605]],[[64828,64829],"mapped",[1575,1611]],[[64830,64831],"valid",[],"NV8"],[[64832,64847],"disallowed"],[[64848,64848],"mapped",[1578,1580,1605]],[[64849,64850],"mapped",[1578,1581,1580]],[[64851,64851],"mapped",[1578,1581,1605]],[[64852,64852],"mapped",[1578,1582,1605]],[[64853,64853],"mapped",[1578,1605,1580]],[[64854,64854],"mapped",[1578,1605,1581]],[[64855,64855],"mapped",[1578,1605,1582]],[[64856,64857],"mapped",[1580,1605,1581]],[[64858,64858],"mapped",[1581,1605,1610]],[[64859,64859],"mapped",[1581,1605,1609]],[[64860,64860],"mapped",[1587,1581,1580]],[[64861,64861],"mapped",[1587,1580,1581]],[[64862,64862],"mapped",[1587,1580,1609]],[[64863,64864],"mapped",[1587,1605,1581]],[[64865,64865],"mapped",[1587,1605,1580]],[[64866,64867],"mapped",[1587,1605,1605]],[[64868,64869],"mapped",[1589,1581,1581]],[[64870,64870],"mapped",[1589,1605,1605]],[[64871,64872],"mapped",[1588,1581,1605]],[[64873,64873],"mapped",[1588,1580,1610]],[[64874,64875],"mapped",[1588,1605,1582]],[[64876,64877],"mapped",[1588,1605,1605]],[[64878,64878],"mapped",[1590,1581,1609]],[[64879,64880],"mapped",[1590,1582,1605]],[[64881,64882],"mapped",[1591,1605,1581]],[[64883,64883],"mapped",[1591,1605,1605]],[[64884,64884],"mapped",[1591,1605,1610]],[[64885,64885],"mapped",[1593,1580,1605]],[[64886,64887],"mapped",[1593,1605,1605]],[[64888,64888],"mapped",[1593,1605,1609]],[[64889,64889],"mapped",[1594,1605,1605]],[[64890,64890],"mapped",[1594,1605,1610]],[[64891,64891],"mapped",[1594,1605,1609]],[[64892,64893],"mapped",[1601,1582,1605]],[[64894,64894],"mapped",[1602,1605,1581]],[[64895,64895],"mapped",[1602,1605,1605]],[[64896,64896],"mapped",[1604,1581,1605]],[[64897,64897],"mapped",[1604,1581,1610]],[[64898,64898],"mapped",[1604,1581,1609]],[[64899,64900],"mapped",[1604,1580,1580]],[[64901,64902],"mapped",[1604,1582,1605]],[[64903,64904],"mapped",[1604,1605,1581]],[[64905,64905],"mapped",[1605,1581,1580]],[[64906,64906],"mapped",[1605,1581,1605]],[[64907,64907],"mapped",[1605,1581,1610]],[[64908,64908],"mapped",[1605,1580,1581]],[[64909,64909],"mapped",[1605,1580,1605]],[[64910,64910],"mapped",[1605,1582,1580]],[[64911,64911],"mapped",[1605,1582,1605]],[[64912,64913],"disallowed"],[[64914,64914],"mapped",[1605,1580,1582]],[[64915,64915],"mapped",[1607,1605,1580]],[[64916,64916],"mapped",[1607,1605,1605]],[[64917,64917],"mapped",[1606,1581,1605]],[[64918,64918],"mapped",[1606,1581,1609]],[[64919,64920],"mapped",[1606,1580,1605]],[[64921,64921],"mapped",[1606,1580,1609]],[[64922,64922],"mapped",[1606,1605,1610]],[[64923,64923],"mapped",[1606,1605,1609]],[[64924,64925],"mapped",[1610,1605,1605]],[[64926,64926],"mapped",[1576,1582,1610]],[[64927,64927],"mapped",[1578,1580,1610]],[[64928,64928],"mapped",[1578,1580,1609]],[[64929,64929],"mapped",[1578,1582,1610]],[[64930,64930],"mapped",[1578,1582,1609]],[[64931,64931],"mapped",[1578,1605,1610]],[[64932,64932],"mapped",[1578,1605,1609]],[[64933,64933],"mapped",[1580,1605,1610]],[[64934,64934],"mapped",[1580,1581,1609]],[[64935,64935],"mapped",[1580,1605,1609]],[[64936,64936],"mapped",[1587,1582,1609]],[[64937,64937],"mapped",[1589,1581,1610]],[[64938,64938],"mapped",[1588,1581,1610]],[[64939,64939],"mapped",[1590,1581,1610]],[[64940,64940],"mapped",[1604,1580,1610]],[[64941,64941],"mapped",[1604,1605,1610]],[[64942,64942],"mapped",[1610,1581,1610]],[[64943,64943],"mapped",[1610,1580,1610]],[[64944,64944],"mapped",[1610,1605,1610]],[[64945,64945],"mapped",[1605,1605,1610]],[[64946,64946],"mapped",[1602,1605,1610]],[[64947,64947],"mapped",[1606,1581,1610]],[[64948,64948],"mapped",[1602,1605,1581]],[[64949,64949],"mapped",[1604,1581,1605]],[[64950,64950],"mapped",[1593,1605,1610]],[[64951,64951],"mapped",[1603,1605,1610]],[[64952,64952],"mapped",[1606,1580,1581]],[[64953,64953],"mapped",[1605,1582,1610]],[[64954,64954],"mapped",[1604,1580,1605]],[[64955,64955],"mapped",[1603,1605,1605]],[[64956,64956],"mapped",[1604,1580,1605]],[[64957,64957],"mapped",[1606,1580,1581]],[[64958,64958],"mapped",[1580,1581,1610]],[[64959,64959],"mapped",[1581,1580,1610]],[[64960,64960],"mapped",[1605,1580,1610]],[[64961,64961],"mapped",[1601,1605,1610]],[[64962,64962],"mapped",[1576,1581,1610]],[[64963,64963],"mapped",[1603,1605,1605]],[[64964,64964],"mapped",[1593,1580,1605]],[[64965,64965],"mapped",[1589,1605,1605]],[[64966,64966],"mapped",[1587,1582,1610]],[[64967,64967],"mapped",[1606,1580,1610]],[[64968,64975],"disallowed"],[[64976,65007],"disallowed"],[[65008,65008],"mapped",[1589,1604,1746]],[[65009,65009],"mapped",[1602,1604,1746]],[[65010,65010],"mapped",[1575,1604,1604,1607]],[[65011,65011],"mapped",[1575,1603,1576,1585]],[[65012,65012],"mapped",[1605,1581,1605,1583]],[[65013,65013],"mapped",[1589,1604,1593,1605]],[[65014,65014],"mapped",[1585,1587,1608,1604]],[[65015,65015],"mapped",[1593,1604,1610,1607]],[[65016,65016],"mapped",[1608,1587,1604,1605]],[[65017,65017],"mapped",[1589,1604,1609]],[[65018,65018],"disallowed_STD3_mapped",[1589,1604,1609,32,1575,1604,1604,1607,32,1593,1604,1610,1607,32,1608,1587,1604,1605]],[[65019,65019],"disallowed_STD3_mapped",[1580,1604,32,1580,1604,1575,1604,1607]],[[65020,65020],"mapped",[1585,1740,1575,1604]],[[65021,65021],"valid",[],"NV8"],[[65022,65023],"disallowed"],[[65024,65039],"ignored"],[[65040,65040],"disallowed_STD3_mapped",[44]],[[65041,65041],"mapped",[12289]],[[65042,65042],"disallowed"],[[65043,65043],"disallowed_STD3_mapped",[58]],[[65044,65044],"disallowed_STD3_mapped",[59]],[[65045,65045],"disallowed_STD3_mapped",[33]],[[65046,65046],"disallowed_STD3_mapped",[63]],[[65047,65047],"mapped",[12310]],[[65048,65048],"mapped",[12311]],[[65049,65049],"disallowed"],[[65050,65055],"disallowed"],[[65056,65059],"valid"],[[65060,65062],"valid"],[[65063,65069],"valid"],[[65070,65071],"valid"],[[65072,65072],"disallowed"],[[65073,65073],"mapped",[8212]],[[65074,65074],"mapped",[8211]],[[65075,65076],"disallowed_STD3_mapped",[95]],[[65077,65077],"disallowed_STD3_mapped",[40]],[[65078,65078],"disallowed_STD3_mapped",[41]],[[65079,65079],"disallowed_STD3_mapped",[123]],[[65080,65080],"disallowed_STD3_mapped",[125]],[[65081,65081],"mapped",[12308]],[[65082,65082],"mapped",[12309]],[[65083,65083],"mapped",[12304]],[[65084,65084],"mapped",[12305]],[[65085,65085],"mapped",[12298]],[[65086,65086],"mapped",[12299]],[[65087,65087],"mapped",[12296]],[[65088,65088],"mapped",[12297]],[[65089,65089],"mapped",[12300]],[[65090,65090],"mapped",[12301]],[[65091,65091],"mapped",[12302]],[[65092,65092],"mapped",[12303]],[[65093,65094],"valid",[],"NV8"],[[65095,65095],"disallowed_STD3_mapped",[91]],[[65096,65096],"disallowed_STD3_mapped",[93]],[[65097,65100],"disallowed_STD3_mapped",[32,773]],[[65101,65103],"disallowed_STD3_mapped",[95]],[[65104,65104],"disallowed_STD3_mapped",[44]],[[65105,65105],"mapped",[12289]],[[65106,65106],"disallowed"],[[65107,65107],"disallowed"],[[65108,65108],"disallowed_STD3_mapped",[59]],[[65109,65109],"disallowed_STD3_mapped",[58]],[[65110,65110],"disallowed_STD3_mapped",[63]],[[65111,65111],"disallowed_STD3_mapped",[33]],[[65112,65112],"mapped",[8212]],[[65113,65113],"disallowed_STD3_mapped",[40]],[[65114,65114],"disallowed_STD3_mapped",[41]],[[65115,65115],"disallowed_STD3_mapped",[123]],[[65116,65116],"disallowed_STD3_mapped",[125]],[[65117,65117],"mapped",[12308]],[[65118,65118],"mapped",[12309]],[[65119,65119],"disallowed_STD3_mapped",[35]],[[65120,65120],"disallowed_STD3_mapped",[38]],[[65121,65121],"disallowed_STD3_mapped",[42]],[[65122,65122],"disallowed_STD3_mapped",[43]],[[65123,65123],"mapped",[45]],[[65124,65124],"disallowed_STD3_mapped",[60]],[[65125,65125],"disallowed_STD3_mapped",[62]],[[65126,65126],"disallowed_STD3_mapped",[61]],[[65127,65127],"disallowed"],[[65128,65128],"disallowed_STD3_mapped",[92]],[[65129,65129],"disallowed_STD3_mapped",[36]],[[65130,65130],"disallowed_STD3_mapped",[37]],[[65131,65131],"disallowed_STD3_mapped",[64]],[[65132,65135],"disallowed"],[[65136,65136],"disallowed_STD3_mapped",[32,1611]],[[65137,65137],"mapped",[1600,1611]],[[65138,65138],"disallowed_STD3_mapped",[32,1612]],[[65139,65139],"valid"],[[65140,65140],"disallowed_STD3_mapped",[32,1613]],[[65141,65141],"disallowed"],[[65142,65142],"disallowed_STD3_mapped",[32,1614]],[[65143,65143],"mapped",[1600,1614]],[[65144,65144],"disallowed_STD3_mapped",[32,1615]],[[65145,65145],"mapped",[1600,1615]],[[65146,65146],"disallowed_STD3_mapped",[32,1616]],[[65147,65147],"mapped",[1600,1616]],[[65148,65148],"disallowed_STD3_mapped",[32,1617]],[[65149,65149],"mapped",[1600,1617]],[[65150,65150],"disallowed_STD3_mapped",[32,1618]],[[65151,65151],"mapped",[1600,1618]],[[65152,65152],"mapped",[1569]],[[65153,65154],"mapped",[1570]],[[65155,65156],"mapped",[1571]],[[65157,65158],"mapped",[1572]],[[65159,65160],"mapped",[1573]],[[65161,65164],"mapped",[1574]],[[65165,65166],"mapped",[1575]],[[65167,65170],"mapped",[1576]],[[65171,65172],"mapped",[1577]],[[65173,65176],"mapped",[1578]],[[65177,65180],"mapped",[1579]],[[65181,65184],"mapped",[1580]],[[65185,65188],"mapped",[1581]],[[65189,65192],"mapped",[1582]],[[65193,65194],"mapped",[1583]],[[65195,65196],"mapped",[1584]],[[65197,65198],"mapped",[1585]],[[65199,65200],"mapped",[1586]],[[65201,65204],"mapped",[1587]],[[65205,65208],"mapped",[1588]],[[65209,65212],"mapped",[1589]],[[65213,65216],"mapped",[1590]],[[65217,65220],"mapped",[1591]],[[65221,65224],"mapped",[1592]],[[65225,65228],"mapped",[1593]],[[65229,65232],"mapped",[1594]],[[65233,65236],"mapped",[1601]],[[65237,65240],"mapped",[1602]],[[65241,65244],"mapped",[1603]],[[65245,65248],"mapped",[1604]],[[65249,65252],"mapped",[1605]],[[65253,65256],"mapped",[1606]],[[65257,65260],"mapped",[1607]],[[65261,65262],"mapped",[1608]],[[65263,65264],"mapped",[1609]],[[65265,65268],"mapped",[1610]],[[65269,65270],"mapped",[1604,1570]],[[65271,65272],"mapped",[1604,1571]],[[65273,65274],"mapped",[1604,1573]],[[65275,65276],"mapped",[1604,1575]],[[65277,65278],"disallowed"],[[65279,65279],"ignored"],[[65280,65280],"disallowed"],[[65281,65281],"disallowed_STD3_mapped",[33]],[[65282,65282],"disallowed_STD3_mapped",[34]],[[65283,65283],"disallowed_STD3_mapped",[35]],[[65284,65284],"disallowed_STD3_mapped",[36]],[[65285,65285],"disallowed_STD3_mapped",[37]],[[65286,65286],"disallowed_STD3_mapped",[38]],[[65287,65287],"disallowed_STD3_mapped",[39]],[[65288,65288],"disallowed_STD3_mapped",[40]],[[65289,65289],"disallowed_STD3_mapped",[41]],[[65290,65290],"disallowed_STD3_mapped",[42]],[[65291,65291],"disallowed_STD3_mapped",[43]],[[65292,65292],"disallowed_STD3_mapped",[44]],[[65293,65293],"mapped",[45]],[[65294,65294],"mapped",[46]],[[65295,65295],"disallowed_STD3_mapped",[47]],[[65296,65296],"mapped",[48]],[[65297,65297],"mapped",[49]],[[65298,65298],"mapped",[50]],[[65299,65299],"mapped",[51]],[[65300,65300],"mapped",[52]],[[65301,65301],"mapped",[53]],[[65302,65302],"mapped",[54]],[[65303,65303],"mapped",[55]],[[65304,65304],"mapped",[56]],[[65305,65305],"mapped",[57]],[[65306,65306],"disallowed_STD3_mapped",[58]],[[65307,65307],"disallowed_STD3_mapped",[59]],[[65308,65308],"disallowed_STD3_mapped",[60]],[[65309,65309],"disallowed_STD3_mapped",[61]],[[65310,65310],"disallowed_STD3_mapped",[62]],[[65311,65311],"disallowed_STD3_mapped",[63]],[[65312,65312],"disallowed_STD3_mapped",[64]],[[65313,65313],"mapped",[97]],[[65314,65314],"mapped",[98]],[[65315,65315],"mapped",[99]],[[65316,65316],"mapped",[100]],[[65317,65317],"mapped",[101]],[[65318,65318],"mapped",[102]],[[65319,65319],"mapped",[103]],[[65320,65320],"mapped",[104]],[[65321,65321],"mapped",[105]],[[65322,65322],"mapped",[106]],[[65323,65323],"mapped",[107]],[[65324,65324],"mapped",[108]],[[65325,65325],"mapped",[109]],[[65326,65326],"mapped",[110]],[[65327,65327],"mapped",[111]],[[65328,65328],"mapped",[112]],[[65329,65329],"mapped",[113]],[[65330,65330],"mapped",[114]],[[65331,65331],"mapped",[115]],[[65332,65332],"mapped",[116]],[[65333,65333],"mapped",[117]],[[65334,65334],"mapped",[118]],[[65335,65335],"mapped",[119]],[[65336,65336],"mapped",[120]],[[65337,65337],"mapped",[121]],[[65338,65338],"mapped",[122]],[[65339,65339],"disallowed_STD3_mapped",[91]],[[65340,65340],"disallowed_STD3_mapped",[92]],[[65341,65341],"disallowed_STD3_mapped",[93]],[[65342,65342],"disallowed_STD3_mapped",[94]],[[65343,65343],"disallowed_STD3_mapped",[95]],[[65344,65344],"disallowed_STD3_mapped",[96]],[[65345,65345],"mapped",[97]],[[65346,65346],"mapped",[98]],[[65347,65347],"mapped",[99]],[[65348,65348],"mapped",[100]],[[65349,65349],"mapped",[101]],[[65350,65350],"mapped",[102]],[[65351,65351],"mapped",[103]],[[65352,65352],"mapped",[104]],[[65353,65353],"mapped",[105]],[[65354,65354],"mapped",[106]],[[65355,65355],"mapped",[107]],[[65356,65356],"mapped",[108]],[[65357,65357],"mapped",[109]],[[65358,65358],"mapped",[110]],[[65359,65359],"mapped",[111]],[[65360,65360],"mapped",[112]],[[65361,65361],"mapped",[113]],[[65362,65362],"mapped",[114]],[[65363,65363],"mapped",[115]],[[65364,65364],"mapped",[116]],[[65365,65365],"mapped",[117]],[[65366,65366],"mapped",[118]],[[65367,65367],"mapped",[119]],[[65368,65368],"mapped",[120]],[[65369,65369],"mapped",[121]],[[65370,65370],"mapped",[122]],[[65371,65371],"disallowed_STD3_mapped",[123]],[[65372,65372],"disallowed_STD3_mapped",[124]],[[65373,65373],"disallowed_STD3_mapped",[125]],[[65374,65374],"disallowed_STD3_mapped",[126]],[[65375,65375],"mapped",[10629]],[[65376,65376],"mapped",[10630]],[[65377,65377],"mapped",[46]],[[65378,65378],"mapped",[12300]],[[65379,65379],"mapped",[12301]],[[65380,65380],"mapped",[12289]],[[65381,65381],"mapped",[12539]],[[65382,65382],"mapped",[12530]],[[65383,65383],"mapped",[12449]],[[65384,65384],"mapped",[12451]],[[65385,65385],"mapped",[12453]],[[65386,65386],"mapped",[12455]],[[65387,65387],"mapped",[12457]],[[65388,65388],"mapped",[12515]],[[65389,65389],"mapped",[12517]],[[65390,65390],"mapped",[12519]],[[65391,65391],"mapped",[12483]],[[65392,65392],"mapped",[12540]],[[65393,65393],"mapped",[12450]],[[65394,65394],"mapped",[12452]],[[65395,65395],"mapped",[12454]],[[65396,65396],"mapped",[12456]],[[65397,65397],"mapped",[12458]],[[65398,65398],"mapped",[12459]],[[65399,65399],"mapped",[12461]],[[65400,65400],"mapped",[12463]],[[65401,65401],"mapped",[12465]],[[65402,65402],"mapped",[12467]],[[65403,65403],"mapped",[12469]],[[65404,65404],"mapped",[12471]],[[65405,65405],"mapped",[12473]],[[65406,65406],"mapped",[12475]],[[65407,65407],"mapped",[12477]],[[65408,65408],"mapped",[12479]],[[65409,65409],"mapped",[12481]],[[65410,65410],"mapped",[12484]],[[65411,65411],"mapped",[12486]],[[65412,65412],"mapped",[12488]],[[65413,65413],"mapped",[12490]],[[65414,65414],"mapped",[12491]],[[65415,65415],"mapped",[12492]],[[65416,65416],"mapped",[12493]],[[65417,65417],"mapped",[12494]],[[65418,65418],"mapped",[12495]],[[65419,65419],"mapped",[12498]],[[65420,65420],"mapped",[12501]],[[65421,65421],"mapped",[12504]],[[65422,65422],"mapped",[12507]],[[65423,65423],"mapped",[12510]],[[65424,65424],"mapped",[12511]],[[65425,65425],"mapped",[12512]],[[65426,65426],"mapped",[12513]],[[65427,65427],"mapped",[12514]],[[65428,65428],"mapped",[12516]],[[65429,65429],"mapped",[12518]],[[65430,65430],"mapped",[12520]],[[65431,65431],"mapped",[12521]],[[65432,65432],"mapped",[12522]],[[65433,65433],"mapped",[12523]],[[65434,65434],"mapped",[12524]],[[65435,65435],"mapped",[12525]],[[65436,65436],"mapped",[12527]],[[65437,65437],"mapped",[12531]],[[65438,65438],"mapped",[12441]],[[65439,65439],"mapped",[12442]],[[65440,65440],"disallowed"],[[65441,65441],"mapped",[4352]],[[65442,65442],"mapped",[4353]],[[65443,65443],"mapped",[4522]],[[65444,65444],"mapped",[4354]],[[65445,65445],"mapped",[4524]],[[65446,65446],"mapped",[4525]],[[65447,65447],"mapped",[4355]],[[65448,65448],"mapped",[4356]],[[65449,65449],"mapped",[4357]],[[65450,65450],"mapped",[4528]],[[65451,65451],"mapped",[4529]],[[65452,65452],"mapped",[4530]],[[65453,65453],"mapped",[4531]],[[65454,65454],"mapped",[4532]],[[65455,65455],"mapped",[4533]],[[65456,65456],"mapped",[4378]],[[65457,65457],"mapped",[4358]],[[65458,65458],"mapped",[4359]],[[65459,65459],"mapped",[4360]],[[65460,65460],"mapped",[4385]],[[65461,65461],"mapped",[4361]],[[65462,65462],"mapped",[4362]],[[65463,65463],"mapped",[4363]],[[65464,65464],"mapped",[4364]],[[65465,65465],"mapped",[4365]],[[65466,65466],"mapped",[4366]],[[65467,65467],"mapped",[4367]],[[65468,65468],"mapped",[4368]],[[65469,65469],"mapped",[4369]],[[65470,65470],"mapped",[4370]],[[65471,65473],"disallowed"],[[65474,65474],"mapped",[4449]],[[65475,65475],"mapped",[4450]],[[65476,65476],"mapped",[4451]],[[65477,65477],"mapped",[4452]],[[65478,65478],"mapped",[4453]],[[65479,65479],"mapped",[4454]],[[65480,65481],"disallowed"],[[65482,65482],"mapped",[4455]],[[65483,65483],"mapped",[4456]],[[65484,65484],"mapped",[4457]],[[65485,65485],"mapped",[4458]],[[65486,65486],"mapped",[4459]],[[65487,65487],"mapped",[4460]],[[65488,65489],"disallowed"],[[65490,65490],"mapped",[4461]],[[65491,65491],"mapped",[4462]],[[65492,65492],"mapped",[4463]],[[65493,65493],"mapped",[4464]],[[65494,65494],"mapped",[4465]],[[65495,65495],"mapped",[4466]],[[65496,65497],"disallowed"],[[65498,65498],"mapped",[4467]],[[65499,65499],"mapped",[4468]],[[65500,65500],"mapped",[4469]],[[65501,65503],"disallowed"],[[65504,65504],"mapped",[162]],[[65505,65505],"mapped",[163]],[[65506,65506],"mapped",[172]],[[65507,65507],"disallowed_STD3_mapped",[32,772]],[[65508,65508],"mapped",[166]],[[65509,65509],"mapped",[165]],[[65510,65510],"mapped",[8361]],[[65511,65511],"disallowed"],[[65512,65512],"mapped",[9474]],[[65513,65513],"mapped",[8592]],[[65514,65514],"mapped",[8593]],[[65515,65515],"mapped",[8594]],[[65516,65516],"mapped",[8595]],[[65517,65517],"mapped",[9632]],[[65518,65518],"mapped",[9675]],[[65519,65528],"disallowed"],[[65529,65531],"disallowed"],[[65532,65532],"disallowed"],[[65533,65533],"disallowed"],[[65534,65535],"disallowed"],[[65536,65547],"valid"],[[65548,65548],"disallowed"],[[65549,65574],"valid"],[[65575,65575],"disallowed"],[[65576,65594],"valid"],[[65595,65595],"disallowed"],[[65596,65597],"valid"],[[65598,65598],"disallowed"],[[65599,65613],"valid"],[[65614,65615],"disallowed"],[[65616,65629],"valid"],[[65630,65663],"disallowed"],[[65664,65786],"valid"],[[65787,65791],"disallowed"],[[65792,65794],"valid",[],"NV8"],[[65795,65798],"disallowed"],[[65799,65843],"valid",[],"NV8"],[[65844,65846],"disallowed"],[[65847,65855],"valid",[],"NV8"],[[65856,65930],"valid",[],"NV8"],[[65931,65932],"valid",[],"NV8"],[[65933,65935],"disallowed"],[[65936,65947],"valid",[],"NV8"],[[65948,65951],"disallowed"],[[65952,65952],"valid",[],"NV8"],[[65953,65999],"disallowed"],[[66000,66044],"valid",[],"NV8"],[[66045,66045],"valid"],[[66046,66175],"disallowed"],[[66176,66204],"valid"],[[66205,66207],"disallowed"],[[66208,66256],"valid"],[[66257,66271],"disallowed"],[[66272,66272],"valid"],[[66273,66299],"valid",[],"NV8"],[[66300,66303],"disallowed"],[[66304,66334],"valid"],[[66335,66335],"valid"],[[66336,66339],"valid",[],"NV8"],[[66340,66351],"disallowed"],[[66352,66368],"valid"],[[66369,66369],"valid",[],"NV8"],[[66370,66377],"valid"],[[66378,66378],"valid",[],"NV8"],[[66379,66383],"disallowed"],[[66384,66426],"valid"],[[66427,66431],"disallowed"],[[66432,66461],"valid"],[[66462,66462],"disallowed"],[[66463,66463],"valid",[],"NV8"],[[66464,66499],"valid"],[[66500,66503],"disallowed"],[[66504,66511],"valid"],[[66512,66517],"valid",[],"NV8"],[[66518,66559],"disallowed"],[[66560,66560],"mapped",[66600]],[[66561,66561],"mapped",[66601]],[[66562,66562],"mapped",[66602]],[[66563,66563],"mapped",[66603]],[[66564,66564],"mapped",[66604]],[[66565,66565],"mapped",[66605]],[[66566,66566],"mapped",[66606]],[[66567,66567],"mapped",[66607]],[[66568,66568],"mapped",[66608]],[[66569,66569],"mapped",[66609]],[[66570,66570],"mapped",[66610]],[[66571,66571],"mapped",[66611]],[[66572,66572],"mapped",[66612]],[[66573,66573],"mapped",[66613]],[[66574,66574],"mapped",[66614]],[[66575,66575],"mapped",[66615]],[[66576,66576],"mapped",[66616]],[[66577,66577],"mapped",[66617]],[[66578,66578],"mapped",[66618]],[[66579,66579],"mapped",[66619]],[[66580,66580],"mapped",[66620]],[[66581,66581],"mapped",[66621]],[[66582,66582],"mapped",[66622]],[[66583,66583],"mapped",[66623]],[[66584,66584],"mapped",[66624]],[[66585,66585],"mapped",[66625]],[[66586,66586],"mapped",[66626]],[[66587,66587],"mapped",[66627]],[[66588,66588],"mapped",[66628]],[[66589,66589],"mapped",[66629]],[[66590,66590],"mapped",[66630]],[[66591,66591],"mapped",[66631]],[[66592,66592],"mapped",[66632]],[[66593,66593],"mapped",[66633]],[[66594,66594],"mapped",[66634]],[[66595,66595],"mapped",[66635]],[[66596,66596],"mapped",[66636]],[[66597,66597],"mapped",[66637]],[[66598,66598],"mapped",[66638]],[[66599,66599],"mapped",[66639]],[[66600,66637],"valid"],[[66638,66717],"valid"],[[66718,66719],"disallowed"],[[66720,66729],"valid"],[[66730,66815],"disallowed"],[[66816,66855],"valid"],[[66856,66863],"disallowed"],[[66864,66915],"valid"],[[66916,66926],"disallowed"],[[66927,66927],"valid",[],"NV8"],[[66928,67071],"disallowed"],[[67072,67382],"valid"],[[67383,67391],"disallowed"],[[67392,67413],"valid"],[[67414,67423],"disallowed"],[[67424,67431],"valid"],[[67432,67583],"disallowed"],[[67584,67589],"valid"],[[67590,67591],"disallowed"],[[67592,67592],"valid"],[[67593,67593],"disallowed"],[[67594,67637],"valid"],[[67638,67638],"disallowed"],[[67639,67640],"valid"],[[67641,67643],"disallowed"],[[67644,67644],"valid"],[[67645,67646],"disallowed"],[[67647,67647],"valid"],[[67648,67669],"valid"],[[67670,67670],"disallowed"],[[67671,67679],"valid",[],"NV8"],[[67680,67702],"valid"],[[67703,67711],"valid",[],"NV8"],[[67712,67742],"valid"],[[67743,67750],"disallowed"],[[67751,67759],"valid",[],"NV8"],[[67760,67807],"disallowed"],[[67808,67826],"valid"],[[67827,67827],"disallowed"],[[67828,67829],"valid"],[[67830,67834],"disallowed"],[[67835,67839],"valid",[],"NV8"],[[67840,67861],"valid"],[[67862,67865],"valid",[],"NV8"],[[67866,67867],"valid",[],"NV8"],[[67868,67870],"disallowed"],[[67871,67871],"valid",[],"NV8"],[[67872,67897],"valid"],[[67898,67902],"disallowed"],[[67903,67903],"valid",[],"NV8"],[[67904,67967],"disallowed"],[[67968,68023],"valid"],[[68024,68027],"disallowed"],[[68028,68029],"valid",[],"NV8"],[[68030,68031],"valid"],[[68032,68047],"valid",[],"NV8"],[[68048,68049],"disallowed"],[[68050,68095],"valid",[],"NV8"],[[68096,68099],"valid"],[[68100,68100],"disallowed"],[[68101,68102],"valid"],[[68103,68107],"disallowed"],[[68108,68115],"valid"],[[68116,68116],"disallowed"],[[68117,68119],"valid"],[[68120,68120],"disallowed"],[[68121,68147],"valid"],[[68148,68151],"disallowed"],[[68152,68154],"valid"],[[68155,68158],"disallowed"],[[68159,68159],"valid"],[[68160,68167],"valid",[],"NV8"],[[68168,68175],"disallowed"],[[68176,68184],"valid",[],"NV8"],[[68185,68191],"disallowed"],[[68192,68220],"valid"],[[68221,68223],"valid",[],"NV8"],[[68224,68252],"valid"],[[68253,68255],"valid",[],"NV8"],[[68256,68287],"disallowed"],[[68288,68295],"valid"],[[68296,68296],"valid",[],"NV8"],[[68297,68326],"valid"],[[68327,68330],"disallowed"],[[68331,68342],"valid",[],"NV8"],[[68343,68351],"disallowed"],[[68352,68405],"valid"],[[68406,68408],"disallowed"],[[68409,68415],"valid",[],"NV8"],[[68416,68437],"valid"],[[68438,68439],"disallowed"],[[68440,68447],"valid",[],"NV8"],[[68448,68466],"valid"],[[68467,68471],"disallowed"],[[68472,68479],"valid",[],"NV8"],[[68480,68497],"valid"],[[68498,68504],"disallowed"],[[68505,68508],"valid",[],"NV8"],[[68509,68520],"disallowed"],[[68521,68527],"valid",[],"NV8"],[[68528,68607],"disallowed"],[[68608,68680],"valid"],[[68681,68735],"disallowed"],[[68736,68736],"mapped",[68800]],[[68737,68737],"mapped",[68801]],[[68738,68738],"mapped",[68802]],[[68739,68739],"mapped",[68803]],[[68740,68740],"mapped",[68804]],[[68741,68741],"mapped",[68805]],[[68742,68742],"mapped",[68806]],[[68743,68743],"mapped",[68807]],[[68744,68744],"mapped",[68808]],[[68745,68745],"mapped",[68809]],[[68746,68746],"mapped",[68810]],[[68747,68747],"mapped",[68811]],[[68748,68748],"mapped",[68812]],[[68749,68749],"mapped",[68813]],[[68750,68750],"mapped",[68814]],[[68751,68751],"mapped",[68815]],[[68752,68752],"mapped",[68816]],[[68753,68753],"mapped",[68817]],[[68754,68754],"mapped",[68818]],[[68755,68755],"mapped",[68819]],[[68756,68756],"mapped",[68820]],[[68757,68757],"mapped",[68821]],[[68758,68758],"mapped",[68822]],[[68759,68759],"mapped",[68823]],[[68760,68760],"mapped",[68824]],[[68761,68761],"mapped",[68825]],[[68762,68762],"mapped",[68826]],[[68763,68763],"mapped",[68827]],[[68764,68764],"mapped",[68828]],[[68765,68765],"mapped",[68829]],[[68766,68766],"mapped",[68830]],[[68767,68767],"mapped",[68831]],[[68768,68768],"mapped",[68832]],[[68769,68769],"mapped",[68833]],[[68770,68770],"mapped",[68834]],[[68771,68771],"mapped",[68835]],[[68772,68772],"mapped",[68836]],[[68773,68773],"mapped",[68837]],[[68774,68774],"mapped",[68838]],[[68775,68775],"mapped",[68839]],[[68776,68776],"mapped",[68840]],[[68777,68777],"mapped",[68841]],[[68778,68778],"mapped",[68842]],[[68779,68779],"mapped",[68843]],[[68780,68780],"mapped",[68844]],[[68781,68781],"mapped",[68845]],[[68782,68782],"mapped",[68846]],[[68783,68783],"mapped",[68847]],[[68784,68784],"mapped",[68848]],[[68785,68785],"mapped",[68849]],[[68786,68786],"mapped",[68850]],[[68787,68799],"disallowed"],[[68800,68850],"valid"],[[68851,68857],"disallowed"],[[68858,68863],"valid",[],"NV8"],[[68864,69215],"disallowed"],[[69216,69246],"valid",[],"NV8"],[[69247,69631],"disallowed"],[[69632,69702],"valid"],[[69703,69709],"valid",[],"NV8"],[[69710,69713],"disallowed"],[[69714,69733],"valid",[],"NV8"],[[69734,69743],"valid"],[[69744,69758],"disallowed"],[[69759,69759],"valid"],[[69760,69818],"valid"],[[69819,69820],"valid",[],"NV8"],[[69821,69821],"disallowed"],[[69822,69825],"valid",[],"NV8"],[[69826,69839],"disallowed"],[[69840,69864],"valid"],[[69865,69871],"disallowed"],[[69872,69881],"valid"],[[69882,69887],"disallowed"],[[69888,69940],"valid"],[[69941,69941],"disallowed"],[[69942,69951],"valid"],[[69952,69955],"valid",[],"NV8"],[[69956,69967],"disallowed"],[[69968,70003],"valid"],[[70004,70005],"valid",[],"NV8"],[[70006,70006],"valid"],[[70007,70015],"disallowed"],[[70016,70084],"valid"],[[70085,70088],"valid",[],"NV8"],[[70089,70089],"valid",[],"NV8"],[[70090,70092],"valid"],[[70093,70093],"valid",[],"NV8"],[[70094,70095],"disallowed"],[[70096,70105],"valid"],[[70106,70106],"valid"],[[70107,70107],"valid",[],"NV8"],[[70108,70108],"valid"],[[70109,70111],"valid",[],"NV8"],[[70112,70112],"disallowed"],[[70113,70132],"valid",[],"NV8"],[[70133,70143],"disallowed"],[[70144,70161],"valid"],[[70162,70162],"disallowed"],[[70163,70199],"valid"],[[70200,70205],"valid",[],"NV8"],[[70206,70271],"disallowed"],[[70272,70278],"valid"],[[70279,70279],"disallowed"],[[70280,70280],"valid"],[[70281,70281],"disallowed"],[[70282,70285],"valid"],[[70286,70286],"disallowed"],[[70287,70301],"valid"],[[70302,70302],"disallowed"],[[70303,70312],"valid"],[[70313,70313],"valid",[],"NV8"],[[70314,70319],"disallowed"],[[70320,70378],"valid"],[[70379,70383],"disallowed"],[[70384,70393],"valid"],[[70394,70399],"disallowed"],[[70400,70400],"valid"],[[70401,70403],"valid"],[[70404,70404],"disallowed"],[[70405,70412],"valid"],[[70413,70414],"disallowed"],[[70415,70416],"valid"],[[70417,70418],"disallowed"],[[70419,70440],"valid"],[[70441,70441],"disallowed"],[[70442,70448],"valid"],[[70449,70449],"disallowed"],[[70450,70451],"valid"],[[70452,70452],"disallowed"],[[70453,70457],"valid"],[[70458,70459],"disallowed"],[[70460,70468],"valid"],[[70469,70470],"disallowed"],[[70471,70472],"valid"],[[70473,70474],"disallowed"],[[70475,70477],"valid"],[[70478,70479],"disallowed"],[[70480,70480],"valid"],[[70481,70486],"disallowed"],[[70487,70487],"valid"],[[70488,70492],"disallowed"],[[70493,70499],"valid"],[[70500,70501],"disallowed"],[[70502,70508],"valid"],[[70509,70511],"disallowed"],[[70512,70516],"valid"],[[70517,70783],"disallowed"],[[70784,70853],"valid"],[[70854,70854],"valid",[],"NV8"],[[70855,70855],"valid"],[[70856,70863],"disallowed"],[[70864,70873],"valid"],[[70874,71039],"disallowed"],[[71040,71093],"valid"],[[71094,71095],"disallowed"],[[71096,71104],"valid"],[[71105,71113],"valid",[],"NV8"],[[71114,71127],"valid",[],"NV8"],[[71128,71133],"valid"],[[71134,71167],"disallowed"],[[71168,71232],"valid"],[[71233,71235],"valid",[],"NV8"],[[71236,71236],"valid"],[[71237,71247],"disallowed"],[[71248,71257],"valid"],[[71258,71295],"disallowed"],[[71296,71351],"valid"],[[71352,71359],"disallowed"],[[71360,71369],"valid"],[[71370,71423],"disallowed"],[[71424,71449],"valid"],[[71450,71452],"disallowed"],[[71453,71467],"valid"],[[71468,71471],"disallowed"],[[71472,71481],"valid"],[[71482,71487],"valid",[],"NV8"],[[71488,71839],"disallowed"],[[71840,71840],"mapped",[71872]],[[71841,71841],"mapped",[71873]],[[71842,71842],"mapped",[71874]],[[71843,71843],"mapped",[71875]],[[71844,71844],"mapped",[71876]],[[71845,71845],"mapped",[71877]],[[71846,71846],"mapped",[71878]],[[71847,71847],"mapped",[71879]],[[71848,71848],"mapped",[71880]],[[71849,71849],"mapped",[71881]],[[71850,71850],"mapped",[71882]],[[71851,71851],"mapped",[71883]],[[71852,71852],"mapped",[71884]],[[71853,71853],"mapped",[71885]],[[71854,71854],"mapped",[71886]],[[71855,71855],"mapped",[71887]],[[71856,71856],"mapped",[71888]],[[71857,71857],"mapped",[71889]],[[71858,71858],"mapped",[71890]],[[71859,71859],"mapped",[71891]],[[71860,71860],"mapped",[71892]],[[71861,71861],"mapped",[71893]],[[71862,71862],"mapped",[71894]],[[71863,71863],"mapped",[71895]],[[71864,71864],"mapped",[71896]],[[71865,71865],"mapped",[71897]],[[71866,71866],"mapped",[71898]],[[71867,71867],"mapped",[71899]],[[71868,71868],"mapped",[71900]],[[71869,71869],"mapped",[71901]],[[71870,71870],"mapped",[71902]],[[71871,71871],"mapped",[71903]],[[71872,71913],"valid"],[[71914,71922],"valid",[],"NV8"],[[71923,71934],"disallowed"],[[71935,71935],"valid"],[[71936,72383],"disallowed"],[[72384,72440],"valid"],[[72441,73727],"disallowed"],[[73728,74606],"valid"],[[74607,74648],"valid"],[[74649,74649],"valid"],[[74650,74751],"disallowed"],[[74752,74850],"valid",[],"NV8"],[[74851,74862],"valid",[],"NV8"],[[74863,74863],"disallowed"],[[74864,74867],"valid",[],"NV8"],[[74868,74868],"valid",[],"NV8"],[[74869,74879],"disallowed"],[[74880,75075],"valid"],[[75076,77823],"disallowed"],[[77824,78894],"valid"],[[78895,82943],"disallowed"],[[82944,83526],"valid"],[[83527,92159],"disallowed"],[[92160,92728],"valid"],[[92729,92735],"disallowed"],[[92736,92766],"valid"],[[92767,92767],"disallowed"],[[92768,92777],"valid"],[[92778,92781],"disallowed"],[[92782,92783],"valid",[],"NV8"],[[92784,92879],"disallowed"],[[92880,92909],"valid"],[[92910,92911],"disallowed"],[[92912,92916],"valid"],[[92917,92917],"valid",[],"NV8"],[[92918,92927],"disallowed"],[[92928,92982],"valid"],[[92983,92991],"valid",[],"NV8"],[[92992,92995],"valid"],[[92996,92997],"valid",[],"NV8"],[[92998,93007],"disallowed"],[[93008,93017],"valid"],[[93018,93018],"disallowed"],[[93019,93025],"valid",[],"NV8"],[[93026,93026],"disallowed"],[[93027,93047],"valid"],[[93048,93052],"disallowed"],[[93053,93071],"valid"],[[93072,93951],"disallowed"],[[93952,94020],"valid"],[[94021,94031],"disallowed"],[[94032,94078],"valid"],[[94079,94094],"disallowed"],[[94095,94111],"valid"],[[94112,110591],"disallowed"],[[110592,110593],"valid"],[[110594,113663],"disallowed"],[[113664,113770],"valid"],[[113771,113775],"disallowed"],[[113776,113788],"valid"],[[113789,113791],"disallowed"],[[113792,113800],"valid"],[[113801,113807],"disallowed"],[[113808,113817],"valid"],[[113818,113819],"disallowed"],[[113820,113820],"valid",[],"NV8"],[[113821,113822],"valid"],[[113823,113823],"valid",[],"NV8"],[[113824,113827],"ignored"],[[113828,118783],"disallowed"],[[118784,119029],"valid",[],"NV8"],[[119030,119039],"disallowed"],[[119040,119078],"valid",[],"NV8"],[[119079,119080],"disallowed"],[[119081,119081],"valid",[],"NV8"],[[119082,119133],"valid",[],"NV8"],[[119134,119134],"mapped",[119127,119141]],[[119135,119135],"mapped",[119128,119141]],[[119136,119136],"mapped",[119128,119141,119150]],[[119137,119137],"mapped",[119128,119141,119151]],[[119138,119138],"mapped",[119128,119141,119152]],[[119139,119139],"mapped",[119128,119141,119153]],[[119140,119140],"mapped",[119128,119141,119154]],[[119141,119154],"valid",[],"NV8"],[[119155,119162],"disallowed"],[[119163,119226],"valid",[],"NV8"],[[119227,119227],"mapped",[119225,119141]],[[119228,119228],"mapped",[119226,119141]],[[119229,119229],"mapped",[119225,119141,119150]],[[119230,119230],"mapped",[119226,119141,119150]],[[119231,119231],"mapped",[119225,119141,119151]],[[119232,119232],"mapped",[119226,119141,119151]],[[119233,119261],"valid",[],"NV8"],[[119262,119272],"valid",[],"NV8"],[[119273,119295],"disallowed"],[[119296,119365],"valid",[],"NV8"],[[119366,119551],"disallowed"],[[119552,119638],"valid",[],"NV8"],[[119639,119647],"disallowed"],[[119648,119665],"valid",[],"NV8"],[[119666,119807],"disallowed"],[[119808,119808],"mapped",[97]],[[119809,119809],"mapped",[98]],[[119810,119810],"mapped",[99]],[[119811,119811],"mapped",[100]],[[119812,119812],"mapped",[101]],[[119813,119813],"mapped",[102]],[[119814,119814],"mapped",[103]],[[119815,119815],"mapped",[104]],[[119816,119816],"mapped",[105]],[[119817,119817],"mapped",[106]],[[119818,119818],"mapped",[107]],[[119819,119819],"mapped",[108]],[[119820,119820],"mapped",[109]],[[119821,119821],"mapped",[110]],[[119822,119822],"mapped",[111]],[[119823,119823],"mapped",[112]],[[119824,119824],"mapped",[113]],[[119825,119825],"mapped",[114]],[[119826,119826],"mapped",[115]],[[119827,119827],"mapped",[116]],[[119828,119828],"mapped",[117]],[[119829,119829],"mapped",[118]],[[119830,119830],"mapped",[119]],[[119831,119831],"mapped",[120]],[[119832,119832],"mapped",[121]],[[119833,119833],"mapped",[122]],[[119834,119834],"mapped",[97]],[[119835,119835],"mapped",[98]],[[119836,119836],"mapped",[99]],[[119837,119837],"mapped",[100]],[[119838,119838],"mapped",[101]],[[119839,119839],"mapped",[102]],[[119840,119840],"mapped",[103]],[[119841,119841],"mapped",[104]],[[119842,119842],"mapped",[105]],[[119843,119843],"mapped",[106]],[[119844,119844],"mapped",[107]],[[119845,119845],"mapped",[108]],[[119846,119846],"mapped",[109]],[[119847,119847],"mapped",[110]],[[119848,119848],"mapped",[111]],[[119849,119849],"mapped",[112]],[[119850,119850],"mapped",[113]],[[119851,119851],"mapped",[114]],[[119852,119852],"mapped",[115]],[[119853,119853],"mapped",[116]],[[119854,119854],"mapped",[117]],[[119855,119855],"mapped",[118]],[[119856,119856],"mapped",[119]],[[119857,119857],"mapped",[120]],[[119858,119858],"mapped",[121]],[[119859,119859],"mapped",[122]],[[119860,119860],"mapped",[97]],[[119861,119861],"mapped",[98]],[[119862,119862],"mapped",[99]],[[119863,119863],"mapped",[100]],[[119864,119864],"mapped",[101]],[[119865,119865],"mapped",[102]],[[119866,119866],"mapped",[103]],[[119867,119867],"mapped",[104]],[[119868,119868],"mapped",[105]],[[119869,119869],"mapped",[106]],[[119870,119870],"mapped",[107]],[[119871,119871],"mapped",[108]],[[119872,119872],"mapped",[109]],[[119873,119873],"mapped",[110]],[[119874,119874],"mapped",[111]],[[119875,119875],"mapped",[112]],[[119876,119876],"mapped",[113]],[[119877,119877],"mapped",[114]],[[119878,119878],"mapped",[115]],[[119879,119879],"mapped",[116]],[[119880,119880],"mapped",[117]],[[119881,119881],"mapped",[118]],[[119882,119882],"mapped",[119]],[[119883,119883],"mapped",[120]],[[119884,119884],"mapped",[121]],[[119885,119885],"mapped",[122]],[[119886,119886],"mapped",[97]],[[119887,119887],"mapped",[98]],[[119888,119888],"mapped",[99]],[[119889,119889],"mapped",[100]],[[119890,119890],"mapped",[101]],[[119891,119891],"mapped",[102]],[[119892,119892],"mapped",[103]],[[119893,119893],"disallowed"],[[119894,119894],"mapped",[105]],[[119895,119895],"mapped",[106]],[[119896,119896],"mapped",[107]],[[119897,119897],"mapped",[108]],[[119898,119898],"mapped",[109]],[[119899,119899],"mapped",[110]],[[119900,119900],"mapped",[111]],[[119901,119901],"mapped",[112]],[[119902,119902],"mapped",[113]],[[119903,119903],"mapped",[114]],[[119904,119904],"mapped",[115]],[[119905,119905],"mapped",[116]],[[119906,119906],"mapped",[117]],[[119907,119907],"mapped",[118]],[[119908,119908],"mapped",[119]],[[119909,119909],"mapped",[120]],[[119910,119910],"mapped",[121]],[[119911,119911],"mapped",[122]],[[119912,119912],"mapped",[97]],[[119913,119913],"mapped",[98]],[[119914,119914],"mapped",[99]],[[119915,119915],"mapped",[100]],[[119916,119916],"mapped",[101]],[[119917,119917],"mapped",[102]],[[119918,119918],"mapped",[103]],[[119919,119919],"mapped",[104]],[[119920,119920],"mapped",[105]],[[119921,119921],"mapped",[106]],[[119922,119922],"mapped",[107]],[[119923,119923],"mapped",[108]],[[119924,119924],"mapped",[109]],[[119925,119925],"mapped",[110]],[[119926,119926],"mapped",[111]],[[119927,119927],"mapped",[112]],[[119928,119928],"mapped",[113]],[[119929,119929],"mapped",[114]],[[119930,119930],"mapped",[115]],[[119931,119931],"mapped",[116]],[[119932,119932],"mapped",[117]],[[119933,119933],"mapped",[118]],[[119934,119934],"mapped",[119]],[[119935,119935],"mapped",[120]],[[119936,119936],"mapped",[121]],[[119937,119937],"mapped",[122]],[[119938,119938],"mapped",[97]],[[119939,119939],"mapped",[98]],[[119940,119940],"mapped",[99]],[[119941,119941],"mapped",[100]],[[119942,119942],"mapped",[101]],[[119943,119943],"mapped",[102]],[[119944,119944],"mapped",[103]],[[119945,119945],"mapped",[104]],[[119946,119946],"mapped",[105]],[[119947,119947],"mapped",[106]],[[119948,119948],"mapped",[107]],[[119949,119949],"mapped",[108]],[[119950,119950],"mapped",[109]],[[119951,119951],"mapped",[110]],[[119952,119952],"mapped",[111]],[[119953,119953],"mapped",[112]],[[119954,119954],"mapped",[113]],[[119955,119955],"mapped",[114]],[[119956,119956],"mapped",[115]],[[119957,119957],"mapped",[116]],[[119958,119958],"mapped",[117]],[[119959,119959],"mapped",[118]],[[119960,119960],"mapped",[119]],[[119961,119961],"mapped",[120]],[[119962,119962],"mapped",[121]],[[119963,119963],"mapped",[122]],[[119964,119964],"mapped",[97]],[[119965,119965],"disallowed"],[[119966,119966],"mapped",[99]],[[119967,119967],"mapped",[100]],[[119968,119969],"disallowed"],[[119970,119970],"mapped",[103]],[[119971,119972],"disallowed"],[[119973,119973],"mapped",[106]],[[119974,119974],"mapped",[107]],[[119975,119976],"disallowed"],[[119977,119977],"mapped",[110]],[[119978,119978],"mapped",[111]],[[119979,119979],"mapped",[112]],[[119980,119980],"mapped",[113]],[[119981,119981],"disallowed"],[[119982,119982],"mapped",[115]],[[119983,119983],"mapped",[116]],[[119984,119984],"mapped",[117]],[[119985,119985],"mapped",[118]],[[119986,119986],"mapped",[119]],[[119987,119987],"mapped",[120]],[[119988,119988],"mapped",[121]],[[119989,119989],"mapped",[122]],[[119990,119990],"mapped",[97]],[[119991,119991],"mapped",[98]],[[119992,119992],"mapped",[99]],[[119993,119993],"mapped",[100]],[[119994,119994],"disallowed"],[[119995,119995],"mapped",[102]],[[119996,119996],"disallowed"],[[119997,119997],"mapped",[104]],[[119998,119998],"mapped",[105]],[[119999,119999],"mapped",[106]],[[120000,120000],"mapped",[107]],[[120001,120001],"mapped",[108]],[[120002,120002],"mapped",[109]],[[120003,120003],"mapped",[110]],[[120004,120004],"disallowed"],[[120005,120005],"mapped",[112]],[[120006,120006],"mapped",[113]],[[120007,120007],"mapped",[114]],[[120008,120008],"mapped",[115]],[[120009,120009],"mapped",[116]],[[120010,120010],"mapped",[117]],[[120011,120011],"mapped",[118]],[[120012,120012],"mapped",[119]],[[120013,120013],"mapped",[120]],[[120014,120014],"mapped",[121]],[[120015,120015],"mapped",[122]],[[120016,120016],"mapped",[97]],[[120017,120017],"mapped",[98]],[[120018,120018],"mapped",[99]],[[120019,120019],"mapped",[100]],[[120020,120020],"mapped",[101]],[[120021,120021],"mapped",[102]],[[120022,120022],"mapped",[103]],[[120023,120023],"mapped",[104]],[[120024,120024],"mapped",[105]],[[120025,120025],"mapped",[106]],[[120026,120026],"mapped",[107]],[[120027,120027],"mapped",[108]],[[120028,120028],"mapped",[109]],[[120029,120029],"mapped",[110]],[[120030,120030],"mapped",[111]],[[120031,120031],"mapped",[112]],[[120032,120032],"mapped",[113]],[[120033,120033],"mapped",[114]],[[120034,120034],"mapped",[115]],[[120035,120035],"mapped",[116]],[[120036,120036],"mapped",[117]],[[120037,120037],"mapped",[118]],[[120038,120038],"mapped",[119]],[[120039,120039],"mapped",[120]],[[120040,120040],"mapped",[121]],[[120041,120041],"mapped",[122]],[[120042,120042],"mapped",[97]],[[120043,120043],"mapped",[98]],[[120044,120044],"mapped",[99]],[[120045,120045],"mapped",[100]],[[120046,120046],"mapped",[101]],[[120047,120047],"mapped",[102]],[[120048,120048],"mapped",[103]],[[120049,120049],"mapped",[104]],[[120050,120050],"mapped",[105]],[[120051,120051],"mapped",[106]],[[120052,120052],"mapped",[107]],[[120053,120053],"mapped",[108]],[[120054,120054],"mapped",[109]],[[120055,120055],"mapped",[110]],[[120056,120056],"mapped",[111]],[[120057,120057],"mapped",[112]],[[120058,120058],"mapped",[113]],[[120059,120059],"mapped",[114]],[[120060,120060],"mapped",[115]],[[120061,120061],"mapped",[116]],[[120062,120062],"mapped",[117]],[[120063,120063],"mapped",[118]],[[120064,120064],"mapped",[119]],[[120065,120065],"mapped",[120]],[[120066,120066],"mapped",[121]],[[120067,120067],"mapped",[122]],[[120068,120068],"mapped",[97]],[[120069,120069],"mapped",[98]],[[120070,120070],"disallowed"],[[120071,120071],"mapped",[100]],[[120072,120072],"mapped",[101]],[[120073,120073],"mapped",[102]],[[120074,120074],"mapped",[103]],[[120075,120076],"disallowed"],[[120077,120077],"mapped",[106]],[[120078,120078],"mapped",[107]],[[120079,120079],"mapped",[108]],[[120080,120080],"mapped",[109]],[[120081,120081],"mapped",[110]],[[120082,120082],"mapped",[111]],[[120083,120083],"mapped",[112]],[[120084,120084],"mapped",[113]],[[120085,120085],"disallowed"],[[120086,120086],"mapped",[115]],[[120087,120087],"mapped",[116]],[[120088,120088],"mapped",[117]],[[120089,120089],"mapped",[118]],[[120090,120090],"mapped",[119]],[[120091,120091],"mapped",[120]],[[120092,120092],"mapped",[121]],[[120093,120093],"disallowed"],[[120094,120094],"mapped",[97]],[[120095,120095],"mapped",[98]],[[120096,120096],"mapped",[99]],[[120097,120097],"mapped",[100]],[[120098,120098],"mapped",[101]],[[120099,120099],"mapped",[102]],[[120100,120100],"mapped",[103]],[[120101,120101],"mapped",[104]],[[120102,120102],"mapped",[105]],[[120103,120103],"mapped",[106]],[[120104,120104],"mapped",[107]],[[120105,120105],"mapped",[108]],[[120106,120106],"mapped",[109]],[[120107,120107],"mapped",[110]],[[120108,120108],"mapped",[111]],[[120109,120109],"mapped",[112]],[[120110,120110],"mapped",[113]],[[120111,120111],"mapped",[114]],[[120112,120112],"mapped",[115]],[[120113,120113],"mapped",[116]],[[120114,120114],"mapped",[117]],[[120115,120115],"mapped",[118]],[[120116,120116],"mapped",[119]],[[120117,120117],"mapped",[120]],[[120118,120118],"mapped",[121]],[[120119,120119],"mapped",[122]],[[120120,120120],"mapped",[97]],[[120121,120121],"mapped",[98]],[[120122,120122],"disallowed"],[[120123,120123],"mapped",[100]],[[120124,120124],"mapped",[101]],[[120125,120125],"mapped",[102]],[[120126,120126],"mapped",[103]],[[120127,120127],"disallowed"],[[120128,120128],"mapped",[105]],[[120129,120129],"mapped",[106]],[[120130,120130],"mapped",[107]],[[120131,120131],"mapped",[108]],[[120132,120132],"mapped",[109]],[[120133,120133],"disallowed"],[[120134,120134],"mapped",[111]],[[120135,120137],"disallowed"],[[120138,120138],"mapped",[115]],[[120139,120139],"mapped",[116]],[[120140,120140],"mapped",[117]],[[120141,120141],"mapped",[118]],[[120142,120142],"mapped",[119]],[[120143,120143],"mapped",[120]],[[120144,120144],"mapped",[121]],[[120145,120145],"disallowed"],[[120146,120146],"mapped",[97]],[[120147,120147],"mapped",[98]],[[120148,120148],"mapped",[99]],[[120149,120149],"mapped",[100]],[[120150,120150],"mapped",[101]],[[120151,120151],"mapped",[102]],[[120152,120152],"mapped",[103]],[[120153,120153],"mapped",[104]],[[120154,120154],"mapped",[105]],[[120155,120155],"mapped",[106]],[[120156,120156],"mapped",[107]],[[120157,120157],"mapped",[108]],[[120158,120158],"mapped",[109]],[[120159,120159],"mapped",[110]],[[120160,120160],"mapped",[111]],[[120161,120161],"mapped",[112]],[[120162,120162],"mapped",[113]],[[120163,120163],"mapped",[114]],[[120164,120164],"mapped",[115]],[[120165,120165],"mapped",[116]],[[120166,120166],"mapped",[117]],[[120167,120167],"mapped",[118]],[[120168,120168],"mapped",[119]],[[120169,120169],"mapped",[120]],[[120170,120170],"mapped",[121]],[[120171,120171],"mapped",[122]],[[120172,120172],"mapped",[97]],[[120173,120173],"mapped",[98]],[[120174,120174],"mapped",[99]],[[120175,120175],"mapped",[100]],[[120176,120176],"mapped",[101]],[[120177,120177],"mapped",[102]],[[120178,120178],"mapped",[103]],[[120179,120179],"mapped",[104]],[[120180,120180],"mapped",[105]],[[120181,120181],"mapped",[106]],[[120182,120182],"mapped",[107]],[[120183,120183],"mapped",[108]],[[120184,120184],"mapped",[109]],[[120185,120185],"mapped",[110]],[[120186,120186],"mapped",[111]],[[120187,120187],"mapped",[112]],[[120188,120188],"mapped",[113]],[[120189,120189],"mapped",[114]],[[120190,120190],"mapped",[115]],[[120191,120191],"mapped",[116]],[[120192,120192],"mapped",[117]],[[120193,120193],"mapped",[118]],[[120194,120194],"mapped",[119]],[[120195,120195],"mapped",[120]],[[120196,120196],"mapped",[121]],[[120197,120197],"mapped",[122]],[[120198,120198],"mapped",[97]],[[120199,120199],"mapped",[98]],[[120200,120200],"mapped",[99]],[[120201,120201],"mapped",[100]],[[120202,120202],"mapped",[101]],[[120203,120203],"mapped",[102]],[[120204,120204],"mapped",[103]],[[120205,120205],"mapped",[104]],[[120206,120206],"mapped",[105]],[[120207,120207],"mapped",[106]],[[120208,120208],"mapped",[107]],[[120209,120209],"mapped",[108]],[[120210,120210],"mapped",[109]],[[120211,120211],"mapped",[110]],[[120212,120212],"mapped",[111]],[[120213,120213],"mapped",[112]],[[120214,120214],"mapped",[113]],[[120215,120215],"mapped",[114]],[[120216,120216],"mapped",[115]],[[120217,120217],"mapped",[116]],[[120218,120218],"mapped",[117]],[[120219,120219],"mapped",[118]],[[120220,120220],"mapped",[119]],[[120221,120221],"mapped",[120]],[[120222,120222],"mapped",[121]],[[120223,120223],"mapped",[122]],[[120224,120224],"mapped",[97]],[[120225,120225],"mapped",[98]],[[120226,120226],"mapped",[99]],[[120227,120227],"mapped",[100]],[[120228,120228],"mapped",[101]],[[120229,120229],"mapped",[102]],[[120230,120230],"mapped",[103]],[[120231,120231],"mapped",[104]],[[120232,120232],"mapped",[105]],[[120233,120233],"mapped",[106]],[[120234,120234],"mapped",[107]],[[120235,120235],"mapped",[108]],[[120236,120236],"mapped",[109]],[[120237,120237],"mapped",[110]],[[120238,120238],"mapped",[111]],[[120239,120239],"mapped",[112]],[[120240,120240],"mapped",[113]],[[120241,120241],"mapped",[114]],[[120242,120242],"mapped",[115]],[[120243,120243],"mapped",[116]],[[120244,120244],"mapped",[117]],[[120245,120245],"mapped",[118]],[[120246,120246],"mapped",[119]],[[120247,120247],"mapped",[120]],[[120248,120248],"mapped",[121]],[[120249,120249],"mapped",[122]],[[120250,120250],"mapped",[97]],[[120251,120251],"mapped",[98]],[[120252,120252],"mapped",[99]],[[120253,120253],"mapped",[100]],[[120254,120254],"mapped",[101]],[[120255,120255],"mapped",[102]],[[120256,120256],"mapped",[103]],[[120257,120257],"mapped",[104]],[[120258,120258],"mapped",[105]],[[120259,120259],"mapped",[106]],[[120260,120260],"mapped",[107]],[[120261,120261],"mapped",[108]],[[120262,120262],"mapped",[109]],[[120263,120263],"mapped",[110]],[[120264,120264],"mapped",[111]],[[120265,120265],"mapped",[112]],[[120266,120266],"mapped",[113]],[[120267,120267],"mapped",[114]],[[120268,120268],"mapped",[115]],[[120269,120269],"mapped",[116]],[[120270,120270],"mapped",[117]],[[120271,120271],"mapped",[118]],[[120272,120272],"mapped",[119]],[[120273,120273],"mapped",[120]],[[120274,120274],"mapped",[121]],[[120275,120275],"mapped",[122]],[[120276,120276],"mapped",[97]],[[120277,120277],"mapped",[98]],[[120278,120278],"mapped",[99]],[[120279,120279],"mapped",[100]],[[120280,120280],"mapped",[101]],[[120281,120281],"mapped",[102]],[[120282,120282],"mapped",[103]],[[120283,120283],"mapped",[104]],[[120284,120284],"mapped",[105]],[[120285,120285],"mapped",[106]],[[120286,120286],"mapped",[107]],[[120287,120287],"mapped",[108]],[[120288,120288],"mapped",[109]],[[120289,120289],"mapped",[110]],[[120290,120290],"mapped",[111]],[[120291,120291],"mapped",[112]],[[120292,120292],"mapped",[113]],[[120293,120293],"mapped",[114]],[[120294,120294],"mapped",[115]],[[120295,120295],"mapped",[116]],[[120296,120296],"mapped",[117]],[[120297,120297],"mapped",[118]],[[120298,120298],"mapped",[119]],[[120299,120299],"mapped",[120]],[[120300,120300],"mapped",[121]],[[120301,120301],"mapped",[122]],[[120302,120302],"mapped",[97]],[[120303,120303],"mapped",[98]],[[120304,120304],"mapped",[99]],[[120305,120305],"mapped",[100]],[[120306,120306],"mapped",[101]],[[120307,120307],"mapped",[102]],[[120308,120308],"mapped",[103]],[[120309,120309],"mapped",[104]],[[120310,120310],"mapped",[105]],[[120311,120311],"mapped",[106]],[[120312,120312],"mapped",[107]],[[120313,120313],"mapped",[108]],[[120314,120314],"mapped",[109]],[[120315,120315],"mapped",[110]],[[120316,120316],"mapped",[111]],[[120317,120317],"mapped",[112]],[[120318,120318],"mapped",[113]],[[120319,120319],"mapped",[114]],[[120320,120320],"mapped",[115]],[[120321,120321],"mapped",[116]],[[120322,120322],"mapped",[117]],[[120323,120323],"mapped",[118]],[[120324,120324],"mapped",[119]],[[120325,120325],"mapped",[120]],[[120326,120326],"mapped",[121]],[[120327,120327],"mapped",[122]],[[120328,120328],"mapped",[97]],[[120329,120329],"mapped",[98]],[[120330,120330],"mapped",[99]],[[120331,120331],"mapped",[100]],[[120332,120332],"mapped",[101]],[[120333,120333],"mapped",[102]],[[120334,120334],"mapped",[103]],[[120335,120335],"mapped",[104]],[[120336,120336],"mapped",[105]],[[120337,120337],"mapped",[106]],[[120338,120338],"mapped",[107]],[[120339,120339],"mapped",[108]],[[120340,120340],"mapped",[109]],[[120341,120341],"mapped",[110]],[[120342,120342],"mapped",[111]],[[120343,120343],"mapped",[112]],[[120344,120344],"mapped",[113]],[[120345,120345],"mapped",[114]],[[120346,120346],"mapped",[115]],[[120347,120347],"mapped",[116]],[[120348,120348],"mapped",[117]],[[120349,120349],"mapped",[118]],[[120350,120350],"mapped",[119]],[[120351,120351],"mapped",[120]],[[120352,120352],"mapped",[121]],[[120353,120353],"mapped",[122]],[[120354,120354],"mapped",[97]],[[120355,120355],"mapped",[98]],[[120356,120356],"mapped",[99]],[[120357,120357],"mapped",[100]],[[120358,120358],"mapped",[101]],[[120359,120359],"mapped",[102]],[[120360,120360],"mapped",[103]],[[120361,120361],"mapped",[104]],[[120362,120362],"mapped",[105]],[[120363,120363],"mapped",[106]],[[120364,120364],"mapped",[107]],[[120365,120365],"mapped",[108]],[[120366,120366],"mapped",[109]],[[120367,120367],"mapped",[110]],[[120368,120368],"mapped",[111]],[[120369,120369],"mapped",[112]],[[120370,120370],"mapped",[113]],[[120371,120371],"mapped",[114]],[[120372,120372],"mapped",[115]],[[120373,120373],"mapped",[116]],[[120374,120374],"mapped",[117]],[[120375,120375],"mapped",[118]],[[120376,120376],"mapped",[119]],[[120377,120377],"mapped",[120]],[[120378,120378],"mapped",[121]],[[120379,120379],"mapped",[122]],[[120380,120380],"mapped",[97]],[[120381,120381],"mapped",[98]],[[120382,120382],"mapped",[99]],[[120383,120383],"mapped",[100]],[[120384,120384],"mapped",[101]],[[120385,120385],"mapped",[102]],[[120386,120386],"mapped",[103]],[[120387,120387],"mapped",[104]],[[120388,120388],"mapped",[105]],[[120389,120389],"mapped",[106]],[[120390,120390],"mapped",[107]],[[120391,120391],"mapped",[108]],[[120392,120392],"mapped",[109]],[[120393,120393],"mapped",[110]],[[120394,120394],"mapped",[111]],[[120395,120395],"mapped",[112]],[[120396,120396],"mapped",[113]],[[120397,120397],"mapped",[114]],[[120398,120398],"mapped",[115]],[[120399,120399],"mapped",[116]],[[120400,120400],"mapped",[117]],[[120401,120401],"mapped",[118]],[[120402,120402],"mapped",[119]],[[120403,120403],"mapped",[120]],[[120404,120404],"mapped",[121]],[[120405,120405],"mapped",[122]],[[120406,120406],"mapped",[97]],[[120407,120407],"mapped",[98]],[[120408,120408],"mapped",[99]],[[120409,120409],"mapped",[100]],[[120410,120410],"mapped",[101]],[[120411,120411],"mapped",[102]],[[120412,120412],"mapped",[103]],[[120413,120413],"mapped",[104]],[[120414,120414],"mapped",[105]],[[120415,120415],"mapped",[106]],[[120416,120416],"mapped",[107]],[[120417,120417],"mapped",[108]],[[120418,120418],"mapped",[109]],[[120419,120419],"mapped",[110]],[[120420,120420],"mapped",[111]],[[120421,120421],"mapped",[112]],[[120422,120422],"mapped",[113]],[[120423,120423],"mapped",[114]],[[120424,120424],"mapped",[115]],[[120425,120425],"mapped",[116]],[[120426,120426],"mapped",[117]],[[120427,120427],"mapped",[118]],[[120428,120428],"mapped",[119]],[[120429,120429],"mapped",[120]],[[120430,120430],"mapped",[121]],[[120431,120431],"mapped",[122]],[[120432,120432],"mapped",[97]],[[120433,120433],"mapped",[98]],[[120434,120434],"mapped",[99]],[[120435,120435],"mapped",[100]],[[120436,120436],"mapped",[101]],[[120437,120437],"mapped",[102]],[[120438,120438],"mapped",[103]],[[120439,120439],"mapped",[104]],[[120440,120440],"mapped",[105]],[[120441,120441],"mapped",[106]],[[120442,120442],"mapped",[107]],[[120443,120443],"mapped",[108]],[[120444,120444],"mapped",[109]],[[120445,120445],"mapped",[110]],[[120446,120446],"mapped",[111]],[[120447,120447],"mapped",[112]],[[120448,120448],"mapped",[113]],[[120449,120449],"mapped",[114]],[[120450,120450],"mapped",[115]],[[120451,120451],"mapped",[116]],[[120452,120452],"mapped",[117]],[[120453,120453],"mapped",[118]],[[120454,120454],"mapped",[119]],[[120455,120455],"mapped",[120]],[[120456,120456],"mapped",[121]],[[120457,120457],"mapped",[122]],[[120458,120458],"mapped",[97]],[[120459,120459],"mapped",[98]],[[120460,120460],"mapped",[99]],[[120461,120461],"mapped",[100]],[[120462,120462],"mapped",[101]],[[120463,120463],"mapped",[102]],[[120464,120464],"mapped",[103]],[[120465,120465],"mapped",[104]],[[120466,120466],"mapped",[105]],[[120467,120467],"mapped",[106]],[[120468,120468],"mapped",[107]],[[120469,120469],"mapped",[108]],[[120470,120470],"mapped",[109]],[[120471,120471],"mapped",[110]],[[120472,120472],"mapped",[111]],[[120473,120473],"mapped",[112]],[[120474,120474],"mapped",[113]],[[120475,120475],"mapped",[114]],[[120476,120476],"mapped",[115]],[[120477,120477],"mapped",[116]],[[120478,120478],"mapped",[117]],[[120479,120479],"mapped",[118]],[[120480,120480],"mapped",[119]],[[120481,120481],"mapped",[120]],[[120482,120482],"mapped",[121]],[[120483,120483],"mapped",[122]],[[120484,120484],"mapped",[305]],[[120485,120485],"mapped",[567]],[[120486,120487],"disallowed"],[[120488,120488],"mapped",[945]],[[120489,120489],"mapped",[946]],[[120490,120490],"mapped",[947]],[[120491,120491],"mapped",[948]],[[120492,120492],"mapped",[949]],[[120493,120493],"mapped",[950]],[[120494,120494],"mapped",[951]],[[120495,120495],"mapped",[952]],[[120496,120496],"mapped",[953]],[[120497,120497],"mapped",[954]],[[120498,120498],"mapped",[955]],[[120499,120499],"mapped",[956]],[[120500,120500],"mapped",[957]],[[120501,120501],"mapped",[958]],[[120502,120502],"mapped",[959]],[[120503,120503],"mapped",[960]],[[120504,120504],"mapped",[961]],[[120505,120505],"mapped",[952]],[[120506,120506],"mapped",[963]],[[120507,120507],"mapped",[964]],[[120508,120508],"mapped",[965]],[[120509,120509],"mapped",[966]],[[120510,120510],"mapped",[967]],[[120511,120511],"mapped",[968]],[[120512,120512],"mapped",[969]],[[120513,120513],"mapped",[8711]],[[120514,120514],"mapped",[945]],[[120515,120515],"mapped",[946]],[[120516,120516],"mapped",[947]],[[120517,120517],"mapped",[948]],[[120518,120518],"mapped",[949]],[[120519,120519],"mapped",[950]],[[120520,120520],"mapped",[951]],[[120521,120521],"mapped",[952]],[[120522,120522],"mapped",[953]],[[120523,120523],"mapped",[954]],[[120524,120524],"mapped",[955]],[[120525,120525],"mapped",[956]],[[120526,120526],"mapped",[957]],[[120527,120527],"mapped",[958]],[[120528,120528],"mapped",[959]],[[120529,120529],"mapped",[960]],[[120530,120530],"mapped",[961]],[[120531,120532],"mapped",[963]],[[120533,120533],"mapped",[964]],[[120534,120534],"mapped",[965]],[[120535,120535],"mapped",[966]],[[120536,120536],"mapped",[967]],[[120537,120537],"mapped",[968]],[[120538,120538],"mapped",[969]],[[120539,120539],"mapped",[8706]],[[120540,120540],"mapped",[949]],[[120541,120541],"mapped",[952]],[[120542,120542],"mapped",[954]],[[120543,120543],"mapped",[966]],[[120544,120544],"mapped",[961]],[[120545,120545],"mapped",[960]],[[120546,120546],"mapped",[945]],[[120547,120547],"mapped",[946]],[[120548,120548],"mapped",[947]],[[120549,120549],"mapped",[948]],[[120550,120550],"mapped",[949]],[[120551,120551],"mapped",[950]],[[120552,120552],"mapped",[951]],[[120553,120553],"mapped",[952]],[[120554,120554],"mapped",[953]],[[120555,120555],"mapped",[954]],[[120556,120556],"mapped",[955]],[[120557,120557],"mapped",[956]],[[120558,120558],"mapped",[957]],[[120559,120559],"mapped",[958]],[[120560,120560],"mapped",[959]],[[120561,120561],"mapped",[960]],[[120562,120562],"mapped",[961]],[[120563,120563],"mapped",[952]],[[120564,120564],"mapped",[963]],[[120565,120565],"mapped",[964]],[[120566,120566],"mapped",[965]],[[120567,120567],"mapped",[966]],[[120568,120568],"mapped",[967]],[[120569,120569],"mapped",[968]],[[120570,120570],"mapped",[969]],[[120571,120571],"mapped",[8711]],[[120572,120572],"mapped",[945]],[[120573,120573],"mapped",[946]],[[120574,120574],"mapped",[947]],[[120575,120575],"mapped",[948]],[[120576,120576],"mapped",[949]],[[120577,120577],"mapped",[950]],[[120578,120578],"mapped",[951]],[[120579,120579],"mapped",[952]],[[120580,120580],"mapped",[953]],[[120581,120581],"mapped",[954]],[[120582,120582],"mapped",[955]],[[120583,120583],"mapped",[956]],[[120584,120584],"mapped",[957]],[[120585,120585],"mapped",[958]],[[120586,120586],"mapped",[959]],[[120587,120587],"mapped",[960]],[[120588,120588],"mapped",[961]],[[120589,120590],"mapped",[963]],[[120591,120591],"mapped",[964]],[[120592,120592],"mapped",[965]],[[120593,120593],"mapped",[966]],[[120594,120594],"mapped",[967]],[[120595,120595],"mapped",[968]],[[120596,120596],"mapped",[969]],[[120597,120597],"mapped",[8706]],[[120598,120598],"mapped",[949]],[[120599,120599],"mapped",[952]],[[120600,120600],"mapped",[954]],[[120601,120601],"mapped",[966]],[[120602,120602],"mapped",[961]],[[120603,120603],"mapped",[960]],[[120604,120604],"mapped",[945]],[[120605,120605],"mapped",[946]],[[120606,120606],"mapped",[947]],[[120607,120607],"mapped",[948]],[[120608,120608],"mapped",[949]],[[120609,120609],"mapped",[950]],[[120610,120610],"mapped",[951]],[[120611,120611],"mapped",[952]],[[120612,120612],"mapped",[953]],[[120613,120613],"mapped",[954]],[[120614,120614],"mapped",[955]],[[120615,120615],"mapped",[956]],[[120616,120616],"mapped",[957]],[[120617,120617],"mapped",[958]],[[120618,120618],"mapped",[959]],[[120619,120619],"mapped",[960]],[[120620,120620],"mapped",[961]],[[120621,120621],"mapped",[952]],[[120622,120622],"mapped",[963]],[[120623,120623],"mapped",[964]],[[120624,120624],"mapped",[965]],[[120625,120625],"mapped",[966]],[[120626,120626],"mapped",[967]],[[120627,120627],"mapped",[968]],[[120628,120628],"mapped",[969]],[[120629,120629],"mapped",[8711]],[[120630,120630],"mapped",[945]],[[120631,120631],"mapped",[946]],[[120632,120632],"mapped",[947]],[[120633,120633],"mapped",[948]],[[120634,120634],"mapped",[949]],[[120635,120635],"mapped",[950]],[[120636,120636],"mapped",[951]],[[120637,120637],"mapped",[952]],[[120638,120638],"mapped",[953]],[[120639,120639],"mapped",[954]],[[120640,120640],"mapped",[955]],[[120641,120641],"mapped",[956]],[[120642,120642],"mapped",[957]],[[120643,120643],"mapped",[958]],[[120644,120644],"mapped",[959]],[[120645,120645],"mapped",[960]],[[120646,120646],"mapped",[961]],[[120647,120648],"mapped",[963]],[[120649,120649],"mapped",[964]],[[120650,120650],"mapped",[965]],[[120651,120651],"mapped",[966]],[[120652,120652],"mapped",[967]],[[120653,120653],"mapped",[968]],[[120654,120654],"mapped",[969]],[[120655,120655],"mapped",[8706]],[[120656,120656],"mapped",[949]],[[120657,120657],"mapped",[952]],[[120658,120658],"mapped",[954]],[[120659,120659],"mapped",[966]],[[120660,120660],"mapped",[961]],[[120661,120661],"mapped",[960]],[[120662,120662],"mapped",[945]],[[120663,120663],"mapped",[946]],[[120664,120664],"mapped",[947]],[[120665,120665],"mapped",[948]],[[120666,120666],"mapped",[949]],[[120667,120667],"mapped",[950]],[[120668,120668],"mapped",[951]],[[120669,120669],"mapped",[952]],[[120670,120670],"mapped",[953]],[[120671,120671],"mapped",[954]],[[120672,120672],"mapped",[955]],[[120673,120673],"mapped",[956]],[[120674,120674],"mapped",[957]],[[120675,120675],"mapped",[958]],[[120676,120676],"mapped",[959]],[[120677,120677],"mapped",[960]],[[120678,120678],"mapped",[961]],[[120679,120679],"mapped",[952]],[[120680,120680],"mapped",[963]],[[120681,120681],"mapped",[964]],[[120682,120682],"mapped",[965]],[[120683,120683],"mapped",[966]],[[120684,120684],"mapped",[967]],[[120685,120685],"mapped",[968]],[[120686,120686],"mapped",[969]],[[120687,120687],"mapped",[8711]],[[120688,120688],"mapped",[945]],[[120689,120689],"mapped",[946]],[[120690,120690],"mapped",[947]],[[120691,120691],"mapped",[948]],[[120692,120692],"mapped",[949]],[[120693,120693],"mapped",[950]],[[120694,120694],"mapped",[951]],[[120695,120695],"mapped",[952]],[[120696,120696],"mapped",[953]],[[120697,120697],"mapped",[954]],[[120698,120698],"mapped",[955]],[[120699,120699],"mapped",[956]],[[120700,120700],"mapped",[957]],[[120701,120701],"mapped",[958]],[[120702,120702],"mapped",[959]],[[120703,120703],"mapped",[960]],[[120704,120704],"mapped",[961]],[[120705,120706],"mapped",[963]],[[120707,120707],"mapped",[964]],[[120708,120708],"mapped",[965]],[[120709,120709],"mapped",[966]],[[120710,120710],"mapped",[967]],[[120711,120711],"mapped",[968]],[[120712,120712],"mapped",[969]],[[120713,120713],"mapped",[8706]],[[120714,120714],"mapped",[949]],[[120715,120715],"mapped",[952]],[[120716,120716],"mapped",[954]],[[120717,120717],"mapped",[966]],[[120718,120718],"mapped",[961]],[[120719,120719],"mapped",[960]],[[120720,120720],"mapped",[945]],[[120721,120721],"mapped",[946]],[[120722,120722],"mapped",[947]],[[120723,120723],"mapped",[948]],[[120724,120724],"mapped",[949]],[[120725,120725],"mapped",[950]],[[120726,120726],"mapped",[951]],[[120727,120727],"mapped",[952]],[[120728,120728],"mapped",[953]],[[120729,120729],"mapped",[954]],[[120730,120730],"mapped",[955]],[[120731,120731],"mapped",[956]],[[120732,120732],"mapped",[957]],[[120733,120733],"mapped",[958]],[[120734,120734],"mapped",[959]],[[120735,120735],"mapped",[960]],[[120736,120736],"mapped",[961]],[[120737,120737],"mapped",[952]],[[120738,120738],"mapped",[963]],[[120739,120739],"mapped",[964]],[[120740,120740],"mapped",[965]],[[120741,120741],"mapped",[966]],[[120742,120742],"mapped",[967]],[[120743,120743],"mapped",[968]],[[120744,120744],"mapped",[969]],[[120745,120745],"mapped",[8711]],[[120746,120746],"mapped",[945]],[[120747,120747],"mapped",[946]],[[120748,120748],"mapped",[947]],[[120749,120749],"mapped",[948]],[[120750,120750],"mapped",[949]],[[120751,120751],"mapped",[950]],[[120752,120752],"mapped",[951]],[[120753,120753],"mapped",[952]],[[120754,120754],"mapped",[953]],[[120755,120755],"mapped",[954]],[[120756,120756],"mapped",[955]],[[120757,120757],"mapped",[956]],[[120758,120758],"mapped",[957]],[[120759,120759],"mapped",[958]],[[120760,120760],"mapped",[959]],[[120761,120761],"mapped",[960]],[[120762,120762],"mapped",[961]],[[120763,120764],"mapped",[963]],[[120765,120765],"mapped",[964]],[[120766,120766],"mapped",[965]],[[120767,120767],"mapped",[966]],[[120768,120768],"mapped",[967]],[[120769,120769],"mapped",[968]],[[120770,120770],"mapped",[969]],[[120771,120771],"mapped",[8706]],[[120772,120772],"mapped",[949]],[[120773,120773],"mapped",[952]],[[120774,120774],"mapped",[954]],[[120775,120775],"mapped",[966]],[[120776,120776],"mapped",[961]],[[120777,120777],"mapped",[960]],[[120778,120779],"mapped",[989]],[[120780,120781],"disallowed"],[[120782,120782],"mapped",[48]],[[120783,120783],"mapped",[49]],[[120784,120784],"mapped",[50]],[[120785,120785],"mapped",[51]],[[120786,120786],"mapped",[52]],[[120787,120787],"mapped",[53]],[[120788,120788],"mapped",[54]],[[120789,120789],"mapped",[55]],[[120790,120790],"mapped",[56]],[[120791,120791],"mapped",[57]],[[120792,120792],"mapped",[48]],[[120793,120793],"mapped",[49]],[[120794,120794],"mapped",[50]],[[120795,120795],"mapped",[51]],[[120796,120796],"mapped",[52]],[[120797,120797],"mapped",[53]],[[120798,120798],"mapped",[54]],[[120799,120799],"mapped",[55]],[[120800,120800],"mapped",[56]],[[120801,120801],"mapped",[57]],[[120802,120802],"mapped",[48]],[[120803,120803],"mapped",[49]],[[120804,120804],"mapped",[50]],[[120805,120805],"mapped",[51]],[[120806,120806],"mapped",[52]],[[120807,120807],"mapped",[53]],[[120808,120808],"mapped",[54]],[[120809,120809],"mapped",[55]],[[120810,120810],"mapped",[56]],[[120811,120811],"mapped",[57]],[[120812,120812],"mapped",[48]],[[120813,120813],"mapped",[49]],[[120814,120814],"mapped",[50]],[[120815,120815],"mapped",[51]],[[120816,120816],"mapped",[52]],[[120817,120817],"mapped",[53]],[[120818,120818],"mapped",[54]],[[120819,120819],"mapped",[55]],[[120820,120820],"mapped",[56]],[[120821,120821],"mapped",[57]],[[120822,120822],"mapped",[48]],[[120823,120823],"mapped",[49]],[[120824,120824],"mapped",[50]],[[120825,120825],"mapped",[51]],[[120826,120826],"mapped",[52]],[[120827,120827],"mapped",[53]],[[120828,120828],"mapped",[54]],[[120829,120829],"mapped",[55]],[[120830,120830],"mapped",[56]],[[120831,120831],"mapped",[57]],[[120832,121343],"valid",[],"NV8"],[[121344,121398],"valid"],[[121399,121402],"valid",[],"NV8"],[[121403,121452],"valid"],[[121453,121460],"valid",[],"NV8"],[[121461,121461],"valid"],[[121462,121475],"valid",[],"NV8"],[[121476,121476],"valid"],[[121477,121483],"valid",[],"NV8"],[[121484,121498],"disallowed"],[[121499,121503],"valid"],[[121504,121504],"disallowed"],[[121505,121519],"valid"],[[121520,124927],"disallowed"],[[124928,125124],"valid"],[[125125,125126],"disallowed"],[[125127,125135],"valid",[],"NV8"],[[125136,125142],"valid"],[[125143,126463],"disallowed"],[[126464,126464],"mapped",[1575]],[[126465,126465],"mapped",[1576]],[[126466,126466],"mapped",[1580]],[[126467,126467],"mapped",[1583]],[[126468,126468],"disallowed"],[[126469,126469],"mapped",[1608]],[[126470,126470],"mapped",[1586]],[[126471,126471],"mapped",[1581]],[[126472,126472],"mapped",[1591]],[[126473,126473],"mapped",[1610]],[[126474,126474],"mapped",[1603]],[[126475,126475],"mapped",[1604]],[[126476,126476],"mapped",[1605]],[[126477,126477],"mapped",[1606]],[[126478,126478],"mapped",[1587]],[[126479,126479],"mapped",[1593]],[[126480,126480],"mapped",[1601]],[[126481,126481],"mapped",[1589]],[[126482,126482],"mapped",[1602]],[[126483,126483],"mapped",[1585]],[[126484,126484],"mapped",[1588]],[[126485,126485],"mapped",[1578]],[[126486,126486],"mapped",[1579]],[[126487,126487],"mapped",[1582]],[[126488,126488],"mapped",[1584]],[[126489,126489],"mapped",[1590]],[[126490,126490],"mapped",[1592]],[[126491,126491],"mapped",[1594]],[[126492,126492],"mapped",[1646]],[[126493,126493],"mapped",[1722]],[[126494,126494],"mapped",[1697]],[[126495,126495],"mapped",[1647]],[[126496,126496],"disallowed"],[[126497,126497],"mapped",[1576]],[[126498,126498],"mapped",[1580]],[[126499,126499],"disallowed"],[[126500,126500],"mapped",[1607]],[[126501,126502],"disallowed"],[[126503,126503],"mapped",[1581]],[[126504,126504],"disallowed"],[[126505,126505],"mapped",[1610]],[[126506,126506],"mapped",[1603]],[[126507,126507],"mapped",[1604]],[[126508,126508],"mapped",[1605]],[[126509,126509],"mapped",[1606]],[[126510,126510],"mapped",[1587]],[[126511,126511],"mapped",[1593]],[[126512,126512],"mapped",[1601]],[[126513,126513],"mapped",[1589]],[[126514,126514],"mapped",[1602]],[[126515,126515],"disallowed"],[[126516,126516],"mapped",[1588]],[[126517,126517],"mapped",[1578]],[[126518,126518],"mapped",[1579]],[[126519,126519],"mapped",[1582]],[[126520,126520],"disallowed"],[[126521,126521],"mapped",[1590]],[[126522,126522],"disallowed"],[[126523,126523],"mapped",[1594]],[[126524,126529],"disallowed"],[[126530,126530],"mapped",[1580]],[[126531,126534],"disallowed"],[[126535,126535],"mapped",[1581]],[[126536,126536],"disallowed"],[[126537,126537],"mapped",[1610]],[[126538,126538],"disallowed"],[[126539,126539],"mapped",[1604]],[[126540,126540],"disallowed"],[[126541,126541],"mapped",[1606]],[[126542,126542],"mapped",[1587]],[[126543,126543],"mapped",[1593]],[[126544,126544],"disallowed"],[[126545,126545],"mapped",[1589]],[[126546,126546],"mapped",[1602]],[[126547,126547],"disallowed"],[[126548,126548],"mapped",[1588]],[[126549,126550],"disallowed"],[[126551,126551],"mapped",[1582]],[[126552,126552],"disallowed"],[[126553,126553],"mapped",[1590]],[[126554,126554],"disallowed"],[[126555,126555],"mapped",[1594]],[[126556,126556],"disallowed"],[[126557,126557],"mapped",[1722]],[[126558,126558],"disallowed"],[[126559,126559],"mapped",[1647]],[[126560,126560],"disallowed"],[[126561,126561],"mapped",[1576]],[[126562,126562],"mapped",[1580]],[[126563,126563],"disallowed"],[[126564,126564],"mapped",[1607]],[[126565,126566],"disallowed"],[[126567,126567],"mapped",[1581]],[[126568,126568],"mapped",[1591]],[[126569,126569],"mapped",[1610]],[[126570,126570],"mapped",[1603]],[[126571,126571],"disallowed"],[[126572,126572],"mapped",[1605]],[[126573,126573],"mapped",[1606]],[[126574,126574],"mapped",[1587]],[[126575,126575],"mapped",[1593]],[[126576,126576],"mapped",[1601]],[[126577,126577],"mapped",[1589]],[[126578,126578],"mapped",[1602]],[[126579,126579],"disallowed"],[[126580,126580],"mapped",[1588]],[[126581,126581],"mapped",[1578]],[[126582,126582],"mapped",[1579]],[[126583,126583],"mapped",[1582]],[[126584,126584],"disallowed"],[[126585,126585],"mapped",[1590]],[[126586,126586],"mapped",[1592]],[[126587,126587],"mapped",[1594]],[[126588,126588],"mapped",[1646]],[[126589,126589],"disallowed"],[[126590,126590],"mapped",[1697]],[[126591,126591],"disallowed"],[[126592,126592],"mapped",[1575]],[[126593,126593],"mapped",[1576]],[[126594,126594],"mapped",[1580]],[[126595,126595],"mapped",[1583]],[[126596,126596],"mapped",[1607]],[[126597,126597],"mapped",[1608]],[[126598,126598],"mapped",[1586]],[[126599,126599],"mapped",[1581]],[[126600,126600],"mapped",[1591]],[[126601,126601],"mapped",[1610]],[[126602,126602],"disallowed"],[[126603,126603],"mapped",[1604]],[[126604,126604],"mapped",[1605]],[[126605,126605],"mapped",[1606]],[[126606,126606],"mapped",[1587]],[[126607,126607],"mapped",[1593]],[[126608,126608],"mapped",[1601]],[[126609,126609],"mapped",[1589]],[[126610,126610],"mapped",[1602]],[[126611,126611],"mapped",[1585]],[[126612,126612],"mapped",[1588]],[[126613,126613],"mapped",[1578]],[[126614,126614],"mapped",[1579]],[[126615,126615],"mapped",[1582]],[[126616,126616],"mapped",[1584]],[[126617,126617],"mapped",[1590]],[[126618,126618],"mapped",[1592]],[[126619,126619],"mapped",[1594]],[[126620,126624],"disallowed"],[[126625,126625],"mapped",[1576]],[[126626,126626],"mapped",[1580]],[[126627,126627],"mapped",[1583]],[[126628,126628],"disallowed"],[[126629,126629],"mapped",[1608]],[[126630,126630],"mapped",[1586]],[[126631,126631],"mapped",[1581]],[[126632,126632],"mapped",[1591]],[[126633,126633],"mapped",[1610]],[[126634,126634],"disallowed"],[[126635,126635],"mapped",[1604]],[[126636,126636],"mapped",[1605]],[[126637,126637],"mapped",[1606]],[[126638,126638],"mapped",[1587]],[[126639,126639],"mapped",[1593]],[[126640,126640],"mapped",[1601]],[[126641,126641],"mapped",[1589]],[[126642,126642],"mapped",[1602]],[[126643,126643],"mapped",[1585]],[[126644,126644],"mapped",[1588]],[[126645,126645],"mapped",[1578]],[[126646,126646],"mapped",[1579]],[[126647,126647],"mapped",[1582]],[[126648,126648],"mapped",[1584]],[[126649,126649],"mapped",[1590]],[[126650,126650],"mapped",[1592]],[[126651,126651],"mapped",[1594]],[[126652,126703],"disallowed"],[[126704,126705],"valid",[],"NV8"],[[126706,126975],"disallowed"],[[126976,127019],"valid",[],"NV8"],[[127020,127023],"disallowed"],[[127024,127123],"valid",[],"NV8"],[[127124,127135],"disallowed"],[[127136,127150],"valid",[],"NV8"],[[127151,127152],"disallowed"],[[127153,127166],"valid",[],"NV8"],[[127167,127167],"valid",[],"NV8"],[[127168,127168],"disallowed"],[[127169,127183],"valid",[],"NV8"],[[127184,127184],"disallowed"],[[127185,127199],"valid",[],"NV8"],[[127200,127221],"valid",[],"NV8"],[[127222,127231],"disallowed"],[[127232,127232],"disallowed"],[[127233,127233],"disallowed_STD3_mapped",[48,44]],[[127234,127234],"disallowed_STD3_mapped",[49,44]],[[127235,127235],"disallowed_STD3_mapped",[50,44]],[[127236,127236],"disallowed_STD3_mapped",[51,44]],[[127237,127237],"disallowed_STD3_mapped",[52,44]],[[127238,127238],"disallowed_STD3_mapped",[53,44]],[[127239,127239],"disallowed_STD3_mapped",[54,44]],[[127240,127240],"disallowed_STD3_mapped",[55,44]],[[127241,127241],"disallowed_STD3_mapped",[56,44]],[[127242,127242],"disallowed_STD3_mapped",[57,44]],[[127243,127244],"valid",[],"NV8"],[[127245,127247],"disallowed"],[[127248,127248],"disallowed_STD3_mapped",[40,97,41]],[[127249,127249],"disallowed_STD3_mapped",[40,98,41]],[[127250,127250],"disallowed_STD3_mapped",[40,99,41]],[[127251,127251],"disallowed_STD3_mapped",[40,100,41]],[[127252,127252],"disallowed_STD3_mapped",[40,101,41]],[[127253,127253],"disallowed_STD3_mapped",[40,102,41]],[[127254,127254],"disallowed_STD3_mapped",[40,103,41]],[[127255,127255],"disallowed_STD3_mapped",[40,104,41]],[[127256,127256],"disallowed_STD3_mapped",[40,105,41]],[[127257,127257],"disallowed_STD3_mapped",[40,106,41]],[[127258,127258],"disallowed_STD3_mapped",[40,107,41]],[[127259,127259],"disallowed_STD3_mapped",[40,108,41]],[[127260,127260],"disallowed_STD3_mapped",[40,109,41]],[[127261,127261],"disallowed_STD3_mapped",[40,110,41]],[[127262,127262],"disallowed_STD3_mapped",[40,111,41]],[[127263,127263],"disallowed_STD3_mapped",[40,112,41]],[[127264,127264],"disallowed_STD3_mapped",[40,113,41]],[[127265,127265],"disallowed_STD3_mapped",[40,114,41]],[[127266,127266],"disallowed_STD3_mapped",[40,115,41]],[[127267,127267],"disallowed_STD3_mapped",[40,116,41]],[[127268,127268],"disallowed_STD3_mapped",[40,117,41]],[[127269,127269],"disallowed_STD3_mapped",[40,118,41]],[[127270,127270],"disallowed_STD3_mapped",[40,119,41]],[[127271,127271],"disallowed_STD3_mapped",[40,120,41]],[[127272,127272],"disallowed_STD3_mapped",[40,121,41]],[[127273,127273],"disallowed_STD3_mapped",[40,122,41]],[[127274,127274],"mapped",[12308,115,12309]],[[127275,127275],"mapped",[99]],[[127276,127276],"mapped",[114]],[[127277,127277],"mapped",[99,100]],[[127278,127278],"mapped",[119,122]],[[127279,127279],"disallowed"],[[127280,127280],"mapped",[97]],[[127281,127281],"mapped",[98]],[[127282,127282],"mapped",[99]],[[127283,127283],"mapped",[100]],[[127284,127284],"mapped",[101]],[[127285,127285],"mapped",[102]],[[127286,127286],"mapped",[103]],[[127287,127287],"mapped",[104]],[[127288,127288],"mapped",[105]],[[127289,127289],"mapped",[106]],[[127290,127290],"mapped",[107]],[[127291,127291],"mapped",[108]],[[127292,127292],"mapped",[109]],[[127293,127293],"mapped",[110]],[[127294,127294],"mapped",[111]],[[127295,127295],"mapped",[112]],[[127296,127296],"mapped",[113]],[[127297,127297],"mapped",[114]],[[127298,127298],"mapped",[115]],[[127299,127299],"mapped",[116]],[[127300,127300],"mapped",[117]],[[127301,127301],"mapped",[118]],[[127302,127302],"mapped",[119]],[[127303,127303],"mapped",[120]],[[127304,127304],"mapped",[121]],[[127305,127305],"mapped",[122]],[[127306,127306],"mapped",[104,118]],[[127307,127307],"mapped",[109,118]],[[127308,127308],"mapped",[115,100]],[[127309,127309],"mapped",[115,115]],[[127310,127310],"mapped",[112,112,118]],[[127311,127311],"mapped",[119,99]],[[127312,127318],"valid",[],"NV8"],[[127319,127319],"valid",[],"NV8"],[[127320,127326],"valid",[],"NV8"],[[127327,127327],"valid",[],"NV8"],[[127328,127337],"valid",[],"NV8"],[[127338,127338],"mapped",[109,99]],[[127339,127339],"mapped",[109,100]],[[127340,127343],"disallowed"],[[127344,127352],"valid",[],"NV8"],[[127353,127353],"valid",[],"NV8"],[[127354,127354],"valid",[],"NV8"],[[127355,127356],"valid",[],"NV8"],[[127357,127358],"valid",[],"NV8"],[[127359,127359],"valid",[],"NV8"],[[127360,127369],"valid",[],"NV8"],[[127370,127373],"valid",[],"NV8"],[[127374,127375],"valid",[],"NV8"],[[127376,127376],"mapped",[100,106]],[[127377,127386],"valid",[],"NV8"],[[127387,127461],"disallowed"],[[127462,127487],"valid",[],"NV8"],[[127488,127488],"mapped",[12411,12363]],[[127489,127489],"mapped",[12467,12467]],[[127490,127490],"mapped",[12469]],[[127491,127503],"disallowed"],[[127504,127504],"mapped",[25163]],[[127505,127505],"mapped",[23383]],[[127506,127506],"mapped",[21452]],[[127507,127507],"mapped",[12487]],[[127508,127508],"mapped",[20108]],[[127509,127509],"mapped",[22810]],[[127510,127510],"mapped",[35299]],[[127511,127511],"mapped",[22825]],[[127512,127512],"mapped",[20132]],[[127513,127513],"mapped",[26144]],[[127514,127514],"mapped",[28961]],[[127515,127515],"mapped",[26009]],[[127516,127516],"mapped",[21069]],[[127517,127517],"mapped",[24460]],[[127518,127518],"mapped",[20877]],[[127519,127519],"mapped",[26032]],[[127520,127520],"mapped",[21021]],[[127521,127521],"mapped",[32066]],[[127522,127522],"mapped",[29983]],[[127523,127523],"mapped",[36009]],[[127524,127524],"mapped",[22768]],[[127525,127525],"mapped",[21561]],[[127526,127526],"mapped",[28436]],[[127527,127527],"mapped",[25237]],[[127528,127528],"mapped",[25429]],[[127529,127529],"mapped",[19968]],[[127530,127530],"mapped",[19977]],[[127531,127531],"mapped",[36938]],[[127532,127532],"mapped",[24038]],[[127533,127533],"mapped",[20013]],[[127534,127534],"mapped",[21491]],[[127535,127535],"mapped",[25351]],[[127536,127536],"mapped",[36208]],[[127537,127537],"mapped",[25171]],[[127538,127538],"mapped",[31105]],[[127539,127539],"mapped",[31354]],[[127540,127540],"mapped",[21512]],[[127541,127541],"mapped",[28288]],[[127542,127542],"mapped",[26377]],[[127543,127543],"mapped",[26376]],[[127544,127544],"mapped",[30003]],[[127545,127545],"mapped",[21106]],[[127546,127546],"mapped",[21942]],[[127547,127551],"disallowed"],[[127552,127552],"mapped",[12308,26412,12309]],[[127553,127553],"mapped",[12308,19977,12309]],[[127554,127554],"mapped",[12308,20108,12309]],[[127555,127555],"mapped",[12308,23433,12309]],[[127556,127556],"mapped",[12308,28857,12309]],[[127557,127557],"mapped",[12308,25171,12309]],[[127558,127558],"mapped",[12308,30423,12309]],[[127559,127559],"mapped",[12308,21213,12309]],[[127560,127560],"mapped",[12308,25943,12309]],[[127561,127567],"disallowed"],[[127568,127568],"mapped",[24471]],[[127569,127569],"mapped",[21487]],[[127570,127743],"disallowed"],[[127744,127776],"valid",[],"NV8"],[[127777,127788],"valid",[],"NV8"],[[127789,127791],"valid",[],"NV8"],[[127792,127797],"valid",[],"NV8"],[[127798,127798],"valid",[],"NV8"],[[127799,127868],"valid",[],"NV8"],[[127869,127869],"valid",[],"NV8"],[[127870,127871],"valid",[],"NV8"],[[127872,127891],"valid",[],"NV8"],[[127892,127903],"valid",[],"NV8"],[[127904,127940],"valid",[],"NV8"],[[127941,127941],"valid",[],"NV8"],[[127942,127946],"valid",[],"NV8"],[[127947,127950],"valid",[],"NV8"],[[127951,127955],"valid",[],"NV8"],[[127956,127967],"valid",[],"NV8"],[[127968,127984],"valid",[],"NV8"],[[127985,127991],"valid",[],"NV8"],[[127992,127999],"valid",[],"NV8"],[[128000,128062],"valid",[],"NV8"],[[128063,128063],"valid",[],"NV8"],[[128064,128064],"valid",[],"NV8"],[[128065,128065],"valid",[],"NV8"],[[128066,128247],"valid",[],"NV8"],[[128248,128248],"valid",[],"NV8"],[[128249,128252],"valid",[],"NV8"],[[128253,128254],"valid",[],"NV8"],[[128255,128255],"valid",[],"NV8"],[[128256,128317],"valid",[],"NV8"],[[128318,128319],"valid",[],"NV8"],[[128320,128323],"valid",[],"NV8"],[[128324,128330],"valid",[],"NV8"],[[128331,128335],"valid",[],"NV8"],[[128336,128359],"valid",[],"NV8"],[[128360,128377],"valid",[],"NV8"],[[128378,128378],"disallowed"],[[128379,128419],"valid",[],"NV8"],[[128420,128420],"disallowed"],[[128421,128506],"valid",[],"NV8"],[[128507,128511],"valid",[],"NV8"],[[128512,128512],"valid",[],"NV8"],[[128513,128528],"valid",[],"NV8"],[[128529,128529],"valid",[],"NV8"],[[128530,128532],"valid",[],"NV8"],[[128533,128533],"valid",[],"NV8"],[[128534,128534],"valid",[],"NV8"],[[128535,128535],"valid",[],"NV8"],[[128536,128536],"valid",[],"NV8"],[[128537,128537],"valid",[],"NV8"],[[128538,128538],"valid",[],"NV8"],[[128539,128539],"valid",[],"NV8"],[[128540,128542],"valid",[],"NV8"],[[128543,128543],"valid",[],"NV8"],[[128544,128549],"valid",[],"NV8"],[[128550,128551],"valid",[],"NV8"],[[128552,128555],"valid",[],"NV8"],[[128556,128556],"valid",[],"NV8"],[[128557,128557],"valid",[],"NV8"],[[128558,128559],"valid",[],"NV8"],[[128560,128563],"valid",[],"NV8"],[[128564,128564],"valid",[],"NV8"],[[128565,128576],"valid",[],"NV8"],[[128577,128578],"valid",[],"NV8"],[[128579,128580],"valid",[],"NV8"],[[128581,128591],"valid",[],"NV8"],[[128592,128639],"valid",[],"NV8"],[[128640,128709],"valid",[],"NV8"],[[128710,128719],"valid",[],"NV8"],[[128720,128720],"valid",[],"NV8"],[[128721,128735],"disallowed"],[[128736,128748],"valid",[],"NV8"],[[128749,128751],"disallowed"],[[128752,128755],"valid",[],"NV8"],[[128756,128767],"disallowed"],[[128768,128883],"valid",[],"NV8"],[[128884,128895],"disallowed"],[[128896,128980],"valid",[],"NV8"],[[128981,129023],"disallowed"],[[129024,129035],"valid",[],"NV8"],[[129036,129039],"disallowed"],[[129040,129095],"valid",[],"NV8"],[[129096,129103],"disallowed"],[[129104,129113],"valid",[],"NV8"],[[129114,129119],"disallowed"],[[129120,129159],"valid",[],"NV8"],[[129160,129167],"disallowed"],[[129168,129197],"valid",[],"NV8"],[[129198,129295],"disallowed"],[[129296,129304],"valid",[],"NV8"],[[129305,129407],"disallowed"],[[129408,129412],"valid",[],"NV8"],[[129413,129471],"disallowed"],[[129472,129472],"valid",[],"NV8"],[[129473,131069],"disallowed"],[[131070,131071],"disallowed"],[[131072,173782],"valid"],[[173783,173823],"disallowed"],[[173824,177972],"valid"],[[177973,177983],"disallowed"],[[177984,178205],"valid"],[[178206,178207],"disallowed"],[[178208,183969],"valid"],[[183970,194559],"disallowed"],[[194560,194560],"mapped",[20029]],[[194561,194561],"mapped",[20024]],[[194562,194562],"mapped",[20033]],[[194563,194563],"mapped",[131362]],[[194564,194564],"mapped",[20320]],[[194565,194565],"mapped",[20398]],[[194566,194566],"mapped",[20411]],[[194567,194567],"mapped",[20482]],[[194568,194568],"mapped",[20602]],[[194569,194569],"mapped",[20633]],[[194570,194570],"mapped",[20711]],[[194571,194571],"mapped",[20687]],[[194572,194572],"mapped",[13470]],[[194573,194573],"mapped",[132666]],[[194574,194574],"mapped",[20813]],[[194575,194575],"mapped",[20820]],[[194576,194576],"mapped",[20836]],[[194577,194577],"mapped",[20855]],[[194578,194578],"mapped",[132380]],[[194579,194579],"mapped",[13497]],[[194580,194580],"mapped",[20839]],[[194581,194581],"mapped",[20877]],[[194582,194582],"mapped",[132427]],[[194583,194583],"mapped",[20887]],[[194584,194584],"mapped",[20900]],[[194585,194585],"mapped",[20172]],[[194586,194586],"mapped",[20908]],[[194587,194587],"mapped",[20917]],[[194588,194588],"mapped",[168415]],[[194589,194589],"mapped",[20981]],[[194590,194590],"mapped",[20995]],[[194591,194591],"mapped",[13535]],[[194592,194592],"mapped",[21051]],[[194593,194593],"mapped",[21062]],[[194594,194594],"mapped",[21106]],[[194595,194595],"mapped",[21111]],[[194596,194596],"mapped",[13589]],[[194597,194597],"mapped",[21191]],[[194598,194598],"mapped",[21193]],[[194599,194599],"mapped",[21220]],[[194600,194600],"mapped",[21242]],[[194601,194601],"mapped",[21253]],[[194602,194602],"mapped",[21254]],[[194603,194603],"mapped",[21271]],[[194604,194604],"mapped",[21321]],[[194605,194605],"mapped",[21329]],[[194606,194606],"mapped",[21338]],[[194607,194607],"mapped",[21363]],[[194608,194608],"mapped",[21373]],[[194609,194611],"mapped",[21375]],[[194612,194612],"mapped",[133676]],[[194613,194613],"mapped",[28784]],[[194614,194614],"mapped",[21450]],[[194615,194615],"mapped",[21471]],[[194616,194616],"mapped",[133987]],[[194617,194617],"mapped",[21483]],[[194618,194618],"mapped",[21489]],[[194619,194619],"mapped",[21510]],[[194620,194620],"mapped",[21662]],[[194621,194621],"mapped",[21560]],[[194622,194622],"mapped",[21576]],[[194623,194623],"mapped",[21608]],[[194624,194624],"mapped",[21666]],[[194625,194625],"mapped",[21750]],[[194626,194626],"mapped",[21776]],[[194627,194627],"mapped",[21843]],[[194628,194628],"mapped",[21859]],[[194629,194630],"mapped",[21892]],[[194631,194631],"mapped",[21913]],[[194632,194632],"mapped",[21931]],[[194633,194633],"mapped",[21939]],[[194634,194634],"mapped",[21954]],[[194635,194635],"mapped",[22294]],[[194636,194636],"mapped",[22022]],[[194637,194637],"mapped",[22295]],[[194638,194638],"mapped",[22097]],[[194639,194639],"mapped",[22132]],[[194640,194640],"mapped",[20999]],[[194641,194641],"mapped",[22766]],[[194642,194642],"mapped",[22478]],[[194643,194643],"mapped",[22516]],[[194644,194644],"mapped",[22541]],[[194645,194645],"mapped",[22411]],[[194646,194646],"mapped",[22578]],[[194647,194647],"mapped",[22577]],[[194648,194648],"mapped",[22700]],[[194649,194649],"mapped",[136420]],[[194650,194650],"mapped",[22770]],[[194651,194651],"mapped",[22775]],[[194652,194652],"mapped",[22790]],[[194653,194653],"mapped",[22810]],[[194654,194654],"mapped",[22818]],[[194655,194655],"mapped",[22882]],[[194656,194656],"mapped",[136872]],[[194657,194657],"mapped",[136938]],[[194658,194658],"mapped",[23020]],[[194659,194659],"mapped",[23067]],[[194660,194660],"mapped",[23079]],[[194661,194661],"mapped",[23000]],[[194662,194662],"mapped",[23142]],[[194663,194663],"mapped",[14062]],[[194664,194664],"disallowed"],[[194665,194665],"mapped",[23304]],[[194666,194667],"mapped",[23358]],[[194668,194668],"mapped",[137672]],[[194669,194669],"mapped",[23491]],[[194670,194670],"mapped",[23512]],[[194671,194671],"mapped",[23527]],[[194672,194672],"mapped",[23539]],[[194673,194673],"mapped",[138008]],[[194674,194674],"mapped",[23551]],[[194675,194675],"mapped",[23558]],[[194676,194676],"disallowed"],[[194677,194677],"mapped",[23586]],[[194678,194678],"mapped",[14209]],[[194679,194679],"mapped",[23648]],[[194680,194680],"mapped",[23662]],[[194681,194681],"mapped",[23744]],[[194682,194682],"mapped",[23693]],[[194683,194683],"mapped",[138724]],[[194684,194684],"mapped",[23875]],[[194685,194685],"mapped",[138726]],[[194686,194686],"mapped",[23918]],[[194687,194687],"mapped",[23915]],[[194688,194688],"mapped",[23932]],[[194689,194689],"mapped",[24033]],[[194690,194690],"mapped",[24034]],[[194691,194691],"mapped",[14383]],[[194692,194692],"mapped",[24061]],[[194693,194693],"mapped",[24104]],[[194694,194694],"mapped",[24125]],[[194695,194695],"mapped",[24169]],[[194696,194696],"mapped",[14434]],[[194697,194697],"mapped",[139651]],[[194698,194698],"mapped",[14460]],[[194699,194699],"mapped",[24240]],[[194700,194700],"mapped",[24243]],[[194701,194701],"mapped",[24246]],[[194702,194702],"mapped",[24266]],[[194703,194703],"mapped",[172946]],[[194704,194704],"mapped",[24318]],[[194705,194706],"mapped",[140081]],[[194707,194707],"mapped",[33281]],[[194708,194709],"mapped",[24354]],[[194710,194710],"mapped",[14535]],[[194711,194711],"mapped",[144056]],[[194712,194712],"mapped",[156122]],[[194713,194713],"mapped",[24418]],[[194714,194714],"mapped",[24427]],[[194715,194715],"mapped",[14563]],[[194716,194716],"mapped",[24474]],[[194717,194717],"mapped",[24525]],[[194718,194718],"mapped",[24535]],[[194719,194719],"mapped",[24569]],[[194720,194720],"mapped",[24705]],[[194721,194721],"mapped",[14650]],[[194722,194722],"mapped",[14620]],[[194723,194723],"mapped",[24724]],[[194724,194724],"mapped",[141012]],[[194725,194725],"mapped",[24775]],[[194726,194726],"mapped",[24904]],[[194727,194727],"mapped",[24908]],[[194728,194728],"mapped",[24910]],[[194729,194729],"mapped",[24908]],[[194730,194730],"mapped",[24954]],[[194731,194731],"mapped",[24974]],[[194732,194732],"mapped",[25010]],[[194733,194733],"mapped",[24996]],[[194734,194734],"mapped",[25007]],[[194735,194735],"mapped",[25054]],[[194736,194736],"mapped",[25074]],[[194737,194737],"mapped",[25078]],[[194738,194738],"mapped",[25104]],[[194739,194739],"mapped",[25115]],[[194740,194740],"mapped",[25181]],[[194741,194741],"mapped",[25265]],[[194742,194742],"mapped",[25300]],[[194743,194743],"mapped",[25424]],[[194744,194744],"mapped",[142092]],[[194745,194745],"mapped",[25405]],[[194746,194746],"mapped",[25340]],[[194747,194747],"mapped",[25448]],[[194748,194748],"mapped",[25475]],[[194749,194749],"mapped",[25572]],[[194750,194750],"mapped",[142321]],[[194751,194751],"mapped",[25634]],[[194752,194752],"mapped",[25541]],[[194753,194753],"mapped",[25513]],[[194754,194754],"mapped",[14894]],[[194755,194755],"mapped",[25705]],[[194756,194756],"mapped",[25726]],[[194757,194757],"mapped",[25757]],[[194758,194758],"mapped",[25719]],[[194759,194759],"mapped",[14956]],[[194760,194760],"mapped",[25935]],[[194761,194761],"mapped",[25964]],[[194762,194762],"mapped",[143370]],[[194763,194763],"mapped",[26083]],[[194764,194764],"mapped",[26360]],[[194765,194765],"mapped",[26185]],[[194766,194766],"mapped",[15129]],[[194767,194767],"mapped",[26257]],[[194768,194768],"mapped",[15112]],[[194769,194769],"mapped",[15076]],[[194770,194770],"mapped",[20882]],[[194771,194771],"mapped",[20885]],[[194772,194772],"mapped",[26368]],[[194773,194773],"mapped",[26268]],[[194774,194774],"mapped",[32941]],[[194775,194775],"mapped",[17369]],[[194776,194776],"mapped",[26391]],[[194777,194777],"mapped",[26395]],[[194778,194778],"mapped",[26401]],[[194779,194779],"mapped",[26462]],[[194780,194780],"mapped",[26451]],[[194781,194781],"mapped",[144323]],[[194782,194782],"mapped",[15177]],[[194783,194783],"mapped",[26618]],[[194784,194784],"mapped",[26501]],[[194785,194785],"mapped",[26706]],[[194786,194786],"mapped",[26757]],[[194787,194787],"mapped",[144493]],[[194788,194788],"mapped",[26766]],[[194789,194789],"mapped",[26655]],[[194790,194790],"mapped",[26900]],[[194791,194791],"mapped",[15261]],[[194792,194792],"mapped",[26946]],[[194793,194793],"mapped",[27043]],[[194794,194794],"mapped",[27114]],[[194795,194795],"mapped",[27304]],[[194796,194796],"mapped",[145059]],[[194797,194797],"mapped",[27355]],[[194798,194798],"mapped",[15384]],[[194799,194799],"mapped",[27425]],[[194800,194800],"mapped",[145575]],[[194801,194801],"mapped",[27476]],[[194802,194802],"mapped",[15438]],[[194803,194803],"mapped",[27506]],[[194804,194804],"mapped",[27551]],[[194805,194805],"mapped",[27578]],[[194806,194806],"mapped",[27579]],[[194807,194807],"mapped",[146061]],[[194808,194808],"mapped",[138507]],[[194809,194809],"mapped",[146170]],[[194810,194810],"mapped",[27726]],[[194811,194811],"mapped",[146620]],[[194812,194812],"mapped",[27839]],[[194813,194813],"mapped",[27853]],[[194814,194814],"mapped",[27751]],[[194815,194815],"mapped",[27926]],[[194816,194816],"mapped",[27966]],[[194817,194817],"mapped",[28023]],[[194818,194818],"mapped",[27969]],[[194819,194819],"mapped",[28009]],[[194820,194820],"mapped",[28024]],[[194821,194821],"mapped",[28037]],[[194822,194822],"mapped",[146718]],[[194823,194823],"mapped",[27956]],[[194824,194824],"mapped",[28207]],[[194825,194825],"mapped",[28270]],[[194826,194826],"mapped",[15667]],[[194827,194827],"mapped",[28363]],[[194828,194828],"mapped",[28359]],[[194829,194829],"mapped",[147153]],[[194830,194830],"mapped",[28153]],[[194831,194831],"mapped",[28526]],[[194832,194832],"mapped",[147294]],[[194833,194833],"mapped",[147342]],[[194834,194834],"mapped",[28614]],[[194835,194835],"mapped",[28729]],[[194836,194836],"mapped",[28702]],[[194837,194837],"mapped",[28699]],[[194838,194838],"mapped",[15766]],[[194839,194839],"mapped",[28746]],[[194840,194840],"mapped",[28797]],[[194841,194841],"mapped",[28791]],[[194842,194842],"mapped",[28845]],[[194843,194843],"mapped",[132389]],[[194844,194844],"mapped",[28997]],[[194845,194845],"mapped",[148067]],[[194846,194846],"mapped",[29084]],[[194847,194847],"disallowed"],[[194848,194848],"mapped",[29224]],[[194849,194849],"mapped",[29237]],[[194850,194850],"mapped",[29264]],[[194851,194851],"mapped",[149000]],[[194852,194852],"mapped",[29312]],[[194853,194853],"mapped",[29333]],[[194854,194854],"mapped",[149301]],[[194855,194855],"mapped",[149524]],[[194856,194856],"mapped",[29562]],[[194857,194857],"mapped",[29579]],[[194858,194858],"mapped",[16044]],[[194859,194859],"mapped",[29605]],[[194860,194861],"mapped",[16056]],[[194862,194862],"mapped",[29767]],[[194863,194863],"mapped",[29788]],[[194864,194864],"mapped",[29809]],[[194865,194865],"mapped",[29829]],[[194866,194866],"mapped",[29898]],[[194867,194867],"mapped",[16155]],[[194868,194868],"mapped",[29988]],[[194869,194869],"mapped",[150582]],[[194870,194870],"mapped",[30014]],[[194871,194871],"mapped",[150674]],[[194872,194872],"mapped",[30064]],[[194873,194873],"mapped",[139679]],[[194874,194874],"mapped",[30224]],[[194875,194875],"mapped",[151457]],[[194876,194876],"mapped",[151480]],[[194877,194877],"mapped",[151620]],[[194878,194878],"mapped",[16380]],[[194879,194879],"mapped",[16392]],[[194880,194880],"mapped",[30452]],[[194881,194881],"mapped",[151795]],[[194882,194882],"mapped",[151794]],[[194883,194883],"mapped",[151833]],[[194884,194884],"mapped",[151859]],[[194885,194885],"mapped",[30494]],[[194886,194887],"mapped",[30495]],[[194888,194888],"mapped",[30538]],[[194889,194889],"mapped",[16441]],[[194890,194890],"mapped",[30603]],[[194891,194891],"mapped",[16454]],[[194892,194892],"mapped",[16534]],[[194893,194893],"mapped",[152605]],[[194894,194894],"mapped",[30798]],[[194895,194895],"mapped",[30860]],[[194896,194896],"mapped",[30924]],[[194897,194897],"mapped",[16611]],[[194898,194898],"mapped",[153126]],[[194899,194899],"mapped",[31062]],[[194900,194900],"mapped",[153242]],[[194901,194901],"mapped",[153285]],[[194902,194902],"mapped",[31119]],[[194903,194903],"mapped",[31211]],[[194904,194904],"mapped",[16687]],[[194905,194905],"mapped",[31296]],[[194906,194906],"mapped",[31306]],[[194907,194907],"mapped",[31311]],[[194908,194908],"mapped",[153980]],[[194909,194910],"mapped",[154279]],[[194911,194911],"disallowed"],[[194912,194912],"mapped",[16898]],[[194913,194913],"mapped",[154539]],[[194914,194914],"mapped",[31686]],[[194915,194915],"mapped",[31689]],[[194916,194916],"mapped",[16935]],[[194917,194917],"mapped",[154752]],[[194918,194918],"mapped",[31954]],[[194919,194919],"mapped",[17056]],[[194920,194920],"mapped",[31976]],[[194921,194921],"mapped",[31971]],[[194922,194922],"mapped",[32000]],[[194923,194923],"mapped",[155526]],[[194924,194924],"mapped",[32099]],[[194925,194925],"mapped",[17153]],[[194926,194926],"mapped",[32199]],[[194927,194927],"mapped",[32258]],[[194928,194928],"mapped",[32325]],[[194929,194929],"mapped",[17204]],[[194930,194930],"mapped",[156200]],[[194931,194931],"mapped",[156231]],[[194932,194932],"mapped",[17241]],[[194933,194933],"mapped",[156377]],[[194934,194934],"mapped",[32634]],[[194935,194935],"mapped",[156478]],[[194936,194936],"mapped",[32661]],[[194937,194937],"mapped",[32762]],[[194938,194938],"mapped",[32773]],[[194939,194939],"mapped",[156890]],[[194940,194940],"mapped",[156963]],[[194941,194941],"mapped",[32864]],[[194942,194942],"mapped",[157096]],[[194943,194943],"mapped",[32880]],[[194944,194944],"mapped",[144223]],[[194945,194945],"mapped",[17365]],[[194946,194946],"mapped",[32946]],[[194947,194947],"mapped",[33027]],[[194948,194948],"mapped",[17419]],[[194949,194949],"mapped",[33086]],[[194950,194950],"mapped",[23221]],[[194951,194951],"mapped",[157607]],[[194952,194952],"mapped",[157621]],[[194953,194953],"mapped",[144275]],[[194954,194954],"mapped",[144284]],[[194955,194955],"mapped",[33281]],[[194956,194956],"mapped",[33284]],[[194957,194957],"mapped",[36766]],[[194958,194958],"mapped",[17515]],[[194959,194959],"mapped",[33425]],[[194960,194960],"mapped",[33419]],[[194961,194961],"mapped",[33437]],[[194962,194962],"mapped",[21171]],[[194963,194963],"mapped",[33457]],[[194964,194964],"mapped",[33459]],[[194965,194965],"mapped",[33469]],[[194966,194966],"mapped",[33510]],[[194967,194967],"mapped",[158524]],[[194968,194968],"mapped",[33509]],[[194969,194969],"mapped",[33565]],[[194970,194970],"mapped",[33635]],[[194971,194971],"mapped",[33709]],[[194972,194972],"mapped",[33571]],[[194973,194973],"mapped",[33725]],[[194974,194974],"mapped",[33767]],[[194975,194975],"mapped",[33879]],[[194976,194976],"mapped",[33619]],[[194977,194977],"mapped",[33738]],[[194978,194978],"mapped",[33740]],[[194979,194979],"mapped",[33756]],[[194980,194980],"mapped",[158774]],[[194981,194981],"mapped",[159083]],[[194982,194982],"mapped",[158933]],[[194983,194983],"mapped",[17707]],[[194984,194984],"mapped",[34033]],[[194985,194985],"mapped",[34035]],[[194986,194986],"mapped",[34070]],[[194987,194987],"mapped",[160714]],[[194988,194988],"mapped",[34148]],[[194989,194989],"mapped",[159532]],[[194990,194990],"mapped",[17757]],[[194991,194991],"mapped",[17761]],[[194992,194992],"mapped",[159665]],[[194993,194993],"mapped",[159954]],[[194994,194994],"mapped",[17771]],[[194995,194995],"mapped",[34384]],[[194996,194996],"mapped",[34396]],[[194997,194997],"mapped",[34407]],[[194998,194998],"mapped",[34409]],[[194999,194999],"mapped",[34473]],[[195000,195000],"mapped",[34440]],[[195001,195001],"mapped",[34574]],[[195002,195002],"mapped",[34530]],[[195003,195003],"mapped",[34681]],[[195004,195004],"mapped",[34600]],[[195005,195005],"mapped",[34667]],[[195006,195006],"mapped",[34694]],[[195007,195007],"disallowed"],[[195008,195008],"mapped",[34785]],[[195009,195009],"mapped",[34817]],[[195010,195010],"mapped",[17913]],[[195011,195011],"mapped",[34912]],[[195012,195012],"mapped",[34915]],[[195013,195013],"mapped",[161383]],[[195014,195014],"mapped",[35031]],[[195015,195015],"mapped",[35038]],[[195016,195016],"mapped",[17973]],[[195017,195017],"mapped",[35066]],[[195018,195018],"mapped",[13499]],[[195019,195019],"mapped",[161966]],[[195020,195020],"mapped",[162150]],[[195021,195021],"mapped",[18110]],[[195022,195022],"mapped",[18119]],[[195023,195023],"mapped",[35488]],[[195024,195024],"mapped",[35565]],[[195025,195025],"mapped",[35722]],[[195026,195026],"mapped",[35925]],[[195027,195027],"mapped",[162984]],[[195028,195028],"mapped",[36011]],[[195029,195029],"mapped",[36033]],[[195030,195030],"mapped",[36123]],[[195031,195031],"mapped",[36215]],[[195032,195032],"mapped",[163631]],[[195033,195033],"mapped",[133124]],[[195034,195034],"mapped",[36299]],[[195035,195035],"mapped",[36284]],[[195036,195036],"mapped",[36336]],[[195037,195037],"mapped",[133342]],[[195038,195038],"mapped",[36564]],[[195039,195039],"mapped",[36664]],[[195040,195040],"mapped",[165330]],[[195041,195041],"mapped",[165357]],[[195042,195042],"mapped",[37012]],[[195043,195043],"mapped",[37105]],[[195044,195044],"mapped",[37137]],[[195045,195045],"mapped",[165678]],[[195046,195046],"mapped",[37147]],[[195047,195047],"mapped",[37432]],[[195048,195048],"mapped",[37591]],[[195049,195049],"mapped",[37592]],[[195050,195050],"mapped",[37500]],[[195051,195051],"mapped",[37881]],[[195052,195052],"mapped",[37909]],[[195053,195053],"mapped",[166906]],[[195054,195054],"mapped",[38283]],[[195055,195055],"mapped",[18837]],[[195056,195056],"mapped",[38327]],[[195057,195057],"mapped",[167287]],[[195058,195058],"mapped",[18918]],[[195059,195059],"mapped",[38595]],[[195060,195060],"mapped",[23986]],[[195061,195061],"mapped",[38691]],[[195062,195062],"mapped",[168261]],[[195063,195063],"mapped",[168474]],[[195064,195064],"mapped",[19054]],[[195065,195065],"mapped",[19062]],[[195066,195066],"mapped",[38880]],[[195067,195067],"mapped",[168970]],[[195068,195068],"mapped",[19122]],[[195069,195069],"mapped",[169110]],[[195070,195071],"mapped",[38923]],[[195072,195072],"mapped",[38953]],[[195073,195073],"mapped",[169398]],[[195074,195074],"mapped",[39138]],[[195075,195075],"mapped",[19251]],[[195076,195076],"mapped",[39209]],[[195077,195077],"mapped",[39335]],[[195078,195078],"mapped",[39362]],[[195079,195079],"mapped",[39422]],[[195080,195080],"mapped",[19406]],[[195081,195081],"mapped",[170800]],[[195082,195082],"mapped",[39698]],[[195083,195083],"mapped",[40000]],[[195084,195084],"mapped",[40189]],[[195085,195085],"mapped",[19662]],[[195086,195086],"mapped",[19693]],[[195087,195087],"mapped",[40295]],[[195088,195088],"mapped",[172238]],[[195089,195089],"mapped",[19704]],[[195090,195090],"mapped",[172293]],[[195091,195091],"mapped",[172558]],[[195092,195092],"mapped",[172689]],[[195093,195093],"mapped",[40635]],[[195094,195094],"mapped",[19798]],[[195095,195095],"mapped",[40697]],[[195096,195096],"mapped",[40702]],[[195097,195097],"mapped",[40709]],[[195098,195098],"mapped",[40719]],[[195099,195099],"mapped",[40726]],[[195100,195100],"mapped",[40763]],[[195101,195101],"mapped",[173568]],[[195102,196605],"disallowed"],[[196606,196607],"disallowed"],[[196608,262141],"disallowed"],[[262142,262143],"disallowed"],[[262144,327677],"disallowed"],[[327678,327679],"disallowed"],[[327680,393213],"disallowed"],[[393214,393215],"disallowed"],[[393216,458749],"disallowed"],[[458750,458751],"disallowed"],[[458752,524285],"disallowed"],[[524286,524287],"disallowed"],[[524288,589821],"disallowed"],[[589822,589823],"disallowed"],[[589824,655357],"disallowed"],[[655358,655359],"disallowed"],[[655360,720893],"disallowed"],[[720894,720895],"disallowed"],[[720896,786429],"disallowed"],[[786430,786431],"disallowed"],[[786432,851965],"disallowed"],[[851966,851967],"disallowed"],[[851968,917501],"disallowed"],[[917502,917503],"disallowed"],[[917504,917504],"disallowed"],[[917505,917505],"disallowed"],[[917506,917535],"disallowed"],[[917536,917631],"disallowed"],[[917632,917759],"disallowed"],[[917760,917999],"ignored"],[[918000,983037],"disallowed"],[[983038,983039],"disallowed"],[[983040,1048573],"disallowed"],[[1048574,1048575],"disallowed"],[[1048576,1114109],"disallowed"],[[1114110,1114111],"disallowed"]]'); + +/***/ }) + +/******/ }); +/************************************************************************/ +/******/ // The module cache +/******/ var __webpack_module_cache__ = {}; +/******/ +/******/ // The require function +/******/ function __nccwpck_require__(moduleId) { +/******/ // Check if module is in cache +/******/ var cachedModule = __webpack_module_cache__[moduleId]; +/******/ if (cachedModule !== undefined) { +/******/ return cachedModule.exports; +/******/ } +/******/ // Create a new module (and put it into the cache) +/******/ var module = __webpack_module_cache__[moduleId] = { +/******/ // no module.id needed +/******/ // no module.loaded needed +/******/ exports: {} +/******/ }; +/******/ +/******/ // Execute the module function +/******/ var threw = true; +/******/ try { +/******/ __webpack_modules__[moduleId].call(module.exports, module, module.exports, __nccwpck_require__); +/******/ threw = false; +/******/ } finally { +/******/ if(threw) delete __webpack_module_cache__[moduleId]; +/******/ } +/******/ +/******/ // Return the exports of the module +/******/ return module.exports; +/******/ } +/******/ +/************************************************************************/ +/******/ /* webpack/runtime/compat */ +/******/ +/******/ if (typeof __nccwpck_require__ !== 'undefined') __nccwpck_require__.ab = __dirname + "/"; +/******/ +/************************************************************************/ +var __webpack_exports__ = {}; +// This entry need to be wrapped in an IIFE because it need to be isolated against other modules in the chunk. +(() => { +const core = __nccwpck_require__(2186); +const action = __nccwpck_require__(4582); + +(async () => { + try { + await action(); + } catch (error) { + core.setFailed(error.message); + } +})(); + +})(); + +module.exports = __webpack_exports__; +/******/ })() +; \ No newline at end of file diff --git a/action-surefire-report/go/go.mod b/action-surefire-report/go/go.mod new file mode 100644 index 0000000..0d8b79b --- /dev/null +++ b/action-surefire-report/go/go.mod @@ -0,0 +1,11 @@ +module github.com/ScaCap/action-surefire-report + +go 1.18 + +require github.com/stretchr/testify v1.8.1 + +require ( + github.com/davecgh/go-spew v1.1.1 // indirect + github.com/pmezard/go-difflib v1.0.0 // indirect + gopkg.in/yaml.v3 v3.0.1 // indirect +) diff --git a/action-surefire-report/go/go.sum b/action-surefire-report/go/go.sum new file mode 100644 index 0000000..2ec90f7 --- /dev/null +++ b/action-surefire-report/go/go.sum @@ -0,0 +1,17 @@ +github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c= +github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= +github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= +github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= +github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw= +github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo= +github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= +github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU= +github.com/stretchr/testify v1.8.1 h1:w7B6lhMri9wdJUVmEZPGGhZzrYTPvgJArz7wNPgYKsk= +github.com/stretchr/testify v1.8.1/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4= +gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM= +gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= +gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= +gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= +gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= diff --git a/action-surefire-report/go/main_test.go b/action-surefire-report/go/main_test.go new file mode 100644 index 0000000..10ccfb9 --- /dev/null +++ b/action-surefire-report/go/main_test.go @@ -0,0 +1,13 @@ +package main + +import ( + "testing" +) + +func TestPassing(t *testing.T) { + t.Log("passing test") +} + +func TestFailing(t *testing.T) { + t.Error("failing test") +} diff --git a/action-surefire-report/go/utils/string_test.go b/action-surefire-report/go/utils/string_test.go new file mode 100644 index 0000000..0e4d143 --- /dev/null +++ b/action-surefire-report/go/utils/string_test.go @@ -0,0 +1,8 @@ +package utils + +import "testing" +import "github.com/stretchr/testify/assert" + +func TestFailing(t *testing.T) { + assert.Equal(t, "1", "2") +} diff --git a/action-surefire-report/index.js b/action-surefire-report/index.js new file mode 100644 index 0000000..4107b53 --- /dev/null +++ b/action-surefire-report/index.js @@ -0,0 +1,10 @@ +const core = require('@actions/core'); +const action = require('./action'); + +(async () => { + try { + await action(); + } catch (error) { + core.setFailed(error.message); + } +})(); diff --git a/action-surefire-report/package-lock.json b/action-surefire-report/package-lock.json new file mode 100644 index 0000000..047c274 --- /dev/null +++ b/action-surefire-report/package-lock.json @@ -0,0 +1,11031 @@ +{ + "name": "action-surefire-report", + "version": "1.0.0", + "lockfileVersion": 2, + "requires": true, + "packages": { + "": { + "name": "action-surefire-report", + "version": "1.0.0", + "license": "Apache-2.0", + "dependencies": { + "@actions/core": "1.10.0", + "@actions/github": "5.1.1", + "@actions/glob": "0.4.0", + "@octokit/plugin-retry": "4.1.1", + "@octokit/rest": "19.0.7", + "libxmljs": "0.19.10" + }, + "devDependencies": { + "@octokit/fixtures": "22.0.6", + "@vercel/ncc": "0.36.1", + "enzyme": "3.11.0", + "eslint": "8.33.0", + "jest": "29.4.2", + "jest-junit": "15.0.0", + "nock": "13.3.0" + } + }, + "node_modules/@actions/core": { + "version": "1.10.0", + "resolved": "https://registry.npmjs.org/@actions/core/-/core-1.10.0.tgz", + "integrity": "sha512-2aZDDa3zrrZbP5ZYg159sNoLRb61nQ7awl5pSvIq5Qpj81vwDzdMRKzkWJGJuwVvWpvZKx7vspJALyvaaIQyug==", + "dependencies": { + "@actions/http-client": "^2.0.1", + "uuid": "^8.3.2" + } + }, + "node_modules/@actions/github": { + "version": "5.1.1", + "resolved": "https://registry.npmjs.org/@actions/github/-/github-5.1.1.tgz", + "integrity": "sha512-Nk59rMDoJaV+mHCOJPXuvB1zIbomlKS0dmSIqPGxd0enAXBnOfn4VWF+CGtRCwXZG9Epa54tZA7VIRlJDS8A6g==", + "dependencies": { + "@actions/http-client": "^2.0.1", + "@octokit/core": "^3.6.0", + "@octokit/plugin-paginate-rest": "^2.17.0", + "@octokit/plugin-rest-endpoint-methods": "^5.13.0" + } + }, + "node_modules/@actions/github/node_modules/@octokit/auth-token": { + "version": "2.5.0", + "resolved": "https://registry.npmjs.org/@octokit/auth-token/-/auth-token-2.5.0.tgz", + "integrity": "sha512-r5FVUJCOLl19AxiuZD2VRZ/ORjp/4IN98Of6YJoJOkY75CIBuYfmiNHGrDwXr+aLGG55igl9QrxX3hbiXlLb+g==", + "dependencies": { + "@octokit/types": "^6.0.3" + } + }, + "node_modules/@actions/github/node_modules/@octokit/core": { + "version": "3.6.0", + "resolved": "https://registry.npmjs.org/@octokit/core/-/core-3.6.0.tgz", + "integrity": "sha512-7RKRKuA4xTjMhY+eG3jthb3hlZCsOwg3rztWh75Xc+ShDWOfDDATWbeZpAHBNRpm4Tv9WgBMOy1zEJYXG6NJ7Q==", + "dependencies": { + "@octokit/auth-token": "^2.4.4", + "@octokit/graphql": "^4.5.8", + "@octokit/request": "^5.6.3", + "@octokit/request-error": "^2.0.5", + "@octokit/types": "^6.0.3", + "before-after-hook": "^2.2.0", + "universal-user-agent": "^6.0.0" + } + }, + "node_modules/@actions/github/node_modules/@octokit/endpoint": { + "version": "6.0.12", + "resolved": "https://registry.npmjs.org/@octokit/endpoint/-/endpoint-6.0.12.tgz", + "integrity": "sha512-lF3puPwkQWGfkMClXb4k/eUT/nZKQfxinRWJrdZaJO85Dqwo/G0yOC434Jr2ojwafWJMYqFGFa5ms4jJUgujdA==", + "dependencies": { + "@octokit/types": "^6.0.3", + "is-plain-object": "^5.0.0", + "universal-user-agent": "^6.0.0" + } + }, + "node_modules/@actions/github/node_modules/@octokit/graphql": { + "version": "4.8.0", + "resolved": "https://registry.npmjs.org/@octokit/graphql/-/graphql-4.8.0.tgz", + "integrity": "sha512-0gv+qLSBLKF0z8TKaSKTsS39scVKF9dbMxJpj3U0vC7wjNWFuIpL/z76Qe2fiuCbDRcJSavkXsVtMS6/dtQQsg==", + "dependencies": { + "@octokit/request": "^5.6.0", + "@octokit/types": "^6.0.3", + "universal-user-agent": "^6.0.0" + } + }, + "node_modules/@actions/github/node_modules/@octokit/openapi-types": { + "version": "12.11.0", + "resolved": "https://registry.npmjs.org/@octokit/openapi-types/-/openapi-types-12.11.0.tgz", + "integrity": "sha512-VsXyi8peyRq9PqIz/tpqiL2w3w80OgVMwBHltTml3LmVvXiphgeqmY9mvBw9Wu7e0QWk/fqD37ux8yP5uVekyQ==" + }, + "node_modules/@actions/github/node_modules/@octokit/request": { + "version": "5.6.3", + "resolved": "https://registry.npmjs.org/@octokit/request/-/request-5.6.3.tgz", + "integrity": "sha512-bFJl0I1KVc9jYTe9tdGGpAMPy32dLBXXo1dS/YwSCTL/2nd9XeHsY616RE3HPXDVk+a+dBuzyz5YdlXwcDTr2A==", + "dependencies": { + "@octokit/endpoint": "^6.0.1", + "@octokit/request-error": "^2.1.0", + "@octokit/types": "^6.16.1", + "is-plain-object": "^5.0.0", + "node-fetch": "^2.6.7", + "universal-user-agent": "^6.0.0" + } + }, + "node_modules/@actions/github/node_modules/@octokit/request-error": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/@octokit/request-error/-/request-error-2.1.0.tgz", + "integrity": "sha512-1VIvgXxs9WHSjicsRwq8PlR2LR2x6DwsJAaFgzdi0JfJoGSO8mYI/cHJQ+9FbN21aa+DrgNLnwObmyeSC8Rmpg==", + "dependencies": { + "@octokit/types": "^6.0.3", + "deprecation": "^2.0.0", + "once": "^1.4.0" + } + }, + "node_modules/@actions/github/node_modules/@octokit/types": { + "version": "6.41.0", + "resolved": "https://registry.npmjs.org/@octokit/types/-/types-6.41.0.tgz", + "integrity": "sha512-eJ2jbzjdijiL3B4PrSQaSjuF2sPEQPVCPzBvTHJD9Nz+9dw2SGH4K4xeQJ77YfTq5bRQ+bD8wT11JbeDPmxmGg==", + "dependencies": { + "@octokit/openapi-types": "^12.11.0" + } + }, + "node_modules/@actions/glob": { + "version": "0.4.0", + "resolved": "https://registry.npmjs.org/@actions/glob/-/glob-0.4.0.tgz", + "integrity": "sha512-+eKIGFhsFa4EBwaf/GMyzCdWrXWymGXfFmZU3FHQvYS8mPcHtTtZONbkcqqUMzw9mJ/pImEBFET1JNifhqGsAQ==", + "dependencies": { + "@actions/core": "^1.9.1", + "minimatch": "^3.0.4" + } + }, + "node_modules/@actions/http-client": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/@actions/http-client/-/http-client-2.1.0.tgz", + "integrity": "sha512-BonhODnXr3amchh4qkmjPMUO8mFi/zLaaCeCAJZqch8iQqyDnVIkySjB38VHAC8IJ+bnlgfOqlhpyCUZHlQsqw==", + "dependencies": { + "tunnel": "^0.0.6" + } + }, + "node_modules/@ampproject/remapping": { + "version": "2.2.0", + "resolved": "https://registry.npmjs.org/@ampproject/remapping/-/remapping-2.2.0.tgz", + "integrity": "sha512-qRmjj8nj9qmLTQXXmaR1cck3UXSRMPrbsLJAasZpF+t3riI71BXed5ebIOYwQntykeZuhjsdweEc9BxH5Jc26w==", + "dev": true, + "dependencies": { + "@jridgewell/gen-mapping": "^0.1.0", + "@jridgewell/trace-mapping": "^0.3.9" + }, + "engines": { + "node": ">=6.0.0" + } + }, + "node_modules/@babel/code-frame": { + "version": "7.18.6", + "resolved": "https://registry.npmjs.org/@babel/code-frame/-/code-frame-7.18.6.tgz", + "integrity": "sha512-TDCmlK5eOvH+eH7cdAFlNXeVJqWIQ7gW9tY1GJIpUtFb6CmjVyq2VM3u71bOyR8CRihcCgMUYoDNyLXao3+70Q==", + "dev": true, + "dependencies": { + "@babel/highlight": "^7.18.6" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/compat-data": { + "version": "7.21.0", + "resolved": "https://registry.npmjs.org/@babel/compat-data/-/compat-data-7.21.0.tgz", + "integrity": "sha512-gMuZsmsgxk/ENC3O/fRw5QY8A9/uxQbbCEypnLIiYYc/qVJtEV7ouxC3EllIIwNzMqAQee5tanFabWsUOutS7g==", + "dev": true, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/core": { + "version": "7.21.0", + "resolved": "https://registry.npmjs.org/@babel/core/-/core-7.21.0.tgz", + "integrity": "sha512-PuxUbxcW6ZYe656yL3EAhpy7qXKq0DmYsrJLpbB8XrsCP9Nm+XCg9XFMb5vIDliPD7+U/+M+QJlH17XOcB7eXA==", + "dev": true, + "dependencies": { + "@ampproject/remapping": "^2.2.0", + "@babel/code-frame": "^7.18.6", + "@babel/generator": "^7.21.0", + "@babel/helper-compilation-targets": "^7.20.7", + "@babel/helper-module-transforms": "^7.21.0", + "@babel/helpers": "^7.21.0", + "@babel/parser": "^7.21.0", + "@babel/template": "^7.20.7", + "@babel/traverse": "^7.21.0", + "@babel/types": "^7.21.0", + "convert-source-map": "^1.7.0", + "debug": "^4.1.0", + "gensync": "^1.0.0-beta.2", + "json5": "^2.2.2", + "semver": "^6.3.0" + }, + "engines": { + "node": ">=6.9.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/babel" + } + }, + "node_modules/@babel/core/node_modules/convert-source-map": { + "version": "1.9.0", + "resolved": "https://registry.npmjs.org/convert-source-map/-/convert-source-map-1.9.0.tgz", + "integrity": "sha512-ASFBup0Mz1uyiIjANan1jzLQami9z1PoYSZCiiYW2FczPbenXc45FZdBZLzOT+r6+iciuEModtmCti+hjaAk0A==", + "dev": true + }, + "node_modules/@babel/generator": { + "version": "7.21.1", + "resolved": "https://registry.npmjs.org/@babel/generator/-/generator-7.21.1.tgz", + "integrity": "sha512-1lT45bAYlQhFn/BHivJs43AiW2rg3/UbLyShGfF3C0KmHvO5fSghWd5kBJy30kpRRucGzXStvnnCFniCR2kXAA==", + "dev": true, + "dependencies": { + "@babel/types": "^7.21.0", + "@jridgewell/gen-mapping": "^0.3.2", + "@jridgewell/trace-mapping": "^0.3.17", + "jsesc": "^2.5.1" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/generator/node_modules/@jridgewell/gen-mapping": { + "version": "0.3.2", + "resolved": "https://registry.npmjs.org/@jridgewell/gen-mapping/-/gen-mapping-0.3.2.tgz", + "integrity": "sha512-mh65xKQAzI6iBcFzwv28KVWSmCkdRBWoOh+bYQGW3+6OZvbbN3TqMGo5hqYxQniRcH9F2VZIoJCm4pa3BPDK/A==", + "dev": true, + "dependencies": { + "@jridgewell/set-array": "^1.0.1", + "@jridgewell/sourcemap-codec": "^1.4.10", + "@jridgewell/trace-mapping": "^0.3.9" + }, + "engines": { + "node": ">=6.0.0" + } + }, + "node_modules/@babel/helper-compilation-targets": { + "version": "7.20.7", + "resolved": "https://registry.npmjs.org/@babel/helper-compilation-targets/-/helper-compilation-targets-7.20.7.tgz", + "integrity": "sha512-4tGORmfQcrc+bvrjb5y3dG9Mx1IOZjsHqQVUz7XCNHO+iTmqxWnVg3KRygjGmpRLJGdQSKuvFinbIb0CnZwHAQ==", + "dev": true, + "dependencies": { + "@babel/compat-data": "^7.20.5", + "@babel/helper-validator-option": "^7.18.6", + "browserslist": "^4.21.3", + "lru-cache": "^5.1.1", + "semver": "^6.3.0" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0" + } + }, + "node_modules/@babel/helper-environment-visitor": { + "version": "7.18.9", + "resolved": "https://registry.npmjs.org/@babel/helper-environment-visitor/-/helper-environment-visitor-7.18.9.tgz", + "integrity": "sha512-3r/aACDJ3fhQ/EVgFy0hpj8oHyHpQc+LPtJoY9SzTThAsStm4Ptegq92vqKoE3vD706ZVFWITnMnxucw+S9Ipg==", + "dev": true, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-function-name": { + "version": "7.21.0", + "resolved": "https://registry.npmjs.org/@babel/helper-function-name/-/helper-function-name-7.21.0.tgz", + "integrity": "sha512-HfK1aMRanKHpxemaY2gqBmL04iAPOPRj7DxtNbiDOrJK+gdwkiNRVpCpUJYbUT+aZyemKN8brqTOxzCaG6ExRg==", + "dev": true, + "dependencies": { + "@babel/template": "^7.20.7", + "@babel/types": "^7.21.0" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-hoist-variables": { + "version": "7.18.6", + "resolved": "https://registry.npmjs.org/@babel/helper-hoist-variables/-/helper-hoist-variables-7.18.6.tgz", + "integrity": "sha512-UlJQPkFqFULIcyW5sbzgbkxn2FKRgwWiRexcuaR8RNJRy8+LLveqPjwZV/bwrLZCN0eUHD/x8D0heK1ozuoo6Q==", + "dev": true, + "dependencies": { + "@babel/types": "^7.18.6" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-module-imports": { + "version": "7.18.6", + "resolved": "https://registry.npmjs.org/@babel/helper-module-imports/-/helper-module-imports-7.18.6.tgz", + "integrity": "sha512-0NFvs3VkuSYbFi1x2Vd6tKrywq+z/cLeYC/RJNFrIX/30Bf5aiGYbtvGXolEktzJH8o5E5KJ3tT+nkxuuZFVlA==", + "dev": true, + "dependencies": { + "@babel/types": "^7.18.6" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-module-transforms": { + "version": "7.21.2", + "resolved": "https://registry.npmjs.org/@babel/helper-module-transforms/-/helper-module-transforms-7.21.2.tgz", + "integrity": "sha512-79yj2AR4U/Oqq/WOV7Lx6hUjau1Zfo4cI+JLAVYeMV5XIlbOhmjEk5ulbTc9fMpmlojzZHkUUxAiK+UKn+hNQQ==", + "dev": true, + "dependencies": { + "@babel/helper-environment-visitor": "^7.18.9", + "@babel/helper-module-imports": "^7.18.6", + "@babel/helper-simple-access": "^7.20.2", + "@babel/helper-split-export-declaration": "^7.18.6", + "@babel/helper-validator-identifier": "^7.19.1", + "@babel/template": "^7.20.7", + "@babel/traverse": "^7.21.2", + "@babel/types": "^7.21.2" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-plugin-utils": { + "version": "7.20.2", + "resolved": "https://registry.npmjs.org/@babel/helper-plugin-utils/-/helper-plugin-utils-7.20.2.tgz", + "integrity": "sha512-8RvlJG2mj4huQ4pZ+rU9lqKi9ZKiRmuvGuM2HlWmkmgOhbs6zEAw6IEiJ5cQqGbDzGZOhwuOQNtZMi/ENLjZoQ==", + "dev": true, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-simple-access": { + "version": "7.20.2", + "resolved": "https://registry.npmjs.org/@babel/helper-simple-access/-/helper-simple-access-7.20.2.tgz", + "integrity": "sha512-+0woI/WPq59IrqDYbVGfshjT5Dmk/nnbdpcF8SnMhhXObpTq2KNBdLFRFrkVdbDOyUmHBCxzm5FHV1rACIkIbA==", + "dev": true, + "dependencies": { + "@babel/types": "^7.20.2" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-split-export-declaration": { + "version": "7.18.6", + "resolved": "https://registry.npmjs.org/@babel/helper-split-export-declaration/-/helper-split-export-declaration-7.18.6.tgz", + "integrity": "sha512-bde1etTx6ZyTmobl9LLMMQsaizFVZrquTEHOqKeQESMKo4PlObf+8+JA25ZsIpZhT/WEd39+vOdLXAFG/nELpA==", + "dev": true, + "dependencies": { + "@babel/types": "^7.18.6" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-string-parser": { + "version": "7.19.4", + "resolved": "https://registry.npmjs.org/@babel/helper-string-parser/-/helper-string-parser-7.19.4.tgz", + "integrity": "sha512-nHtDoQcuqFmwYNYPz3Rah5ph2p8PFeFCsZk9A/48dPc/rGocJ5J3hAAZ7pb76VWX3fZKu+uEr/FhH5jLx7umrw==", + "dev": true, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-validator-identifier": { + "version": "7.19.1", + "resolved": "https://registry.npmjs.org/@babel/helper-validator-identifier/-/helper-validator-identifier-7.19.1.tgz", + "integrity": "sha512-awrNfaMtnHUr653GgGEs++LlAvW6w+DcPrOliSMXWCKo597CwL5Acf/wWdNkf/tfEQE3mjkeD1YOVZOUV/od1w==", + "dev": true, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-validator-option": { + "version": "7.21.0", + "resolved": "https://registry.npmjs.org/@babel/helper-validator-option/-/helper-validator-option-7.21.0.tgz", + "integrity": "sha512-rmL/B8/f0mKS2baE9ZpyTcTavvEuWhTTW8amjzXNvYG4AwBsqTLikfXsEofsJEfKHf+HQVQbFOHy6o+4cnC/fQ==", + "dev": true, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helpers": { + "version": "7.21.0", + "resolved": "https://registry.npmjs.org/@babel/helpers/-/helpers-7.21.0.tgz", + "integrity": "sha512-XXve0CBtOW0pd7MRzzmoyuSj0e3SEzj8pgyFxnTT1NJZL38BD1MK7yYrm8yefRPIDvNNe14xR4FdbHwpInD4rA==", + "dev": true, + "dependencies": { + "@babel/template": "^7.20.7", + "@babel/traverse": "^7.21.0", + "@babel/types": "^7.21.0" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/highlight": { + "version": "7.18.6", + "resolved": "https://registry.npmjs.org/@babel/highlight/-/highlight-7.18.6.tgz", + "integrity": "sha512-u7stbOuYjaPezCuLj29hNW1v64M2Md2qupEKP1fHc7WdOA3DgLh37suiSrZYY7haUB7iBeQZ9P1uiRF359do3g==", + "dev": true, + "dependencies": { + "@babel/helper-validator-identifier": "^7.18.6", + "chalk": "^2.0.0", + "js-tokens": "^4.0.0" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/highlight/node_modules/ansi-styles": { + "version": "3.2.1", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-3.2.1.tgz", + "integrity": "sha512-VT0ZI6kZRdTh8YyJw3SMbYm/u+NqfsAxEpWO0Pf9sq8/e94WxxOpPKx9FR1FlyCtOVDNOQ+8ntlqFxiRc+r5qA==", + "dev": true, + "dependencies": { + "color-convert": "^1.9.0" + }, + "engines": { + "node": ">=4" + } + }, + "node_modules/@babel/highlight/node_modules/chalk": { + "version": "2.4.2", + "resolved": "https://registry.npmjs.org/chalk/-/chalk-2.4.2.tgz", + "integrity": "sha512-Mti+f9lpJNcwF4tWV8/OrTTtF1gZi+f8FqlyAdouralcFWFQWF2+NgCHShjkCb+IFBLq9buZwE1xckQU4peSuQ==", + "dev": true, + "dependencies": { + "ansi-styles": "^3.2.1", + "escape-string-regexp": "^1.0.5", + "supports-color": "^5.3.0" + }, + "engines": { + "node": ">=4" + } + }, + "node_modules/@babel/highlight/node_modules/color-convert": { + "version": "1.9.3", + "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-1.9.3.tgz", + "integrity": "sha512-QfAUtd+vFdAtFQcC8CCyYt1fYWxSqAiK2cSD6zDB8N3cpsEBAvRxp9zOGg6G/SHHJYAT88/az/IuDGALsNVbGg==", + "dev": true, + "dependencies": { + "color-name": "1.1.3" + } + }, + "node_modules/@babel/highlight/node_modules/color-name": { + "version": "1.1.3", + "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.3.tgz", + "integrity": "sha512-72fSenhMw2HZMTVHeCA9KCmpEIbzWiQsjN+BHcBbS9vr1mtt+vJjPdksIBNUmKAW8TFUDPJK5SUU3QhE9NEXDw==", + "dev": true + }, + "node_modules/@babel/highlight/node_modules/escape-string-regexp": { + "version": "1.0.5", + "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-1.0.5.tgz", + "integrity": "sha512-vbRorB5FUQWvla16U8R/qgaFIya2qGzwDrNmCZuYKrbdSUMG6I1ZCGQRefkRVhuOkIGVne7BQ35DSfo1qvJqFg==", + "dev": true, + "engines": { + "node": ">=0.8.0" + } + }, + "node_modules/@babel/highlight/node_modules/has-flag": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-3.0.0.tgz", + "integrity": "sha512-sKJf1+ceQBr4SMkvQnBDNDtf4TXpVhVGateu0t918bl30FnbE2m4vNLX+VWe/dpjlb+HugGYzW7uQXH98HPEYw==", + "dev": true, + "engines": { + "node": ">=4" + } + }, + "node_modules/@babel/highlight/node_modules/supports-color": { + "version": "5.5.0", + "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-5.5.0.tgz", + "integrity": "sha512-QjVjwdXIt408MIiAqCX4oUKsgU2EqAGzs2Ppkm4aQYbjm+ZEWEcW4SfFNTr4uMNZma0ey4f5lgLrkB0aX0QMow==", + "dev": true, + "dependencies": { + "has-flag": "^3.0.0" + }, + "engines": { + "node": ">=4" + } + }, + "node_modules/@babel/parser": { + "version": "7.21.2", + "resolved": "https://registry.npmjs.org/@babel/parser/-/parser-7.21.2.tgz", + "integrity": "sha512-URpaIJQwEkEC2T9Kn+Ai6Xe/02iNaVCuT/PtoRz3GPVJVDpPd7mLo+VddTbhCRU9TXqW5mSrQfXZyi8kDKOVpQ==", + "dev": true, + "bin": { + "parser": "bin/babel-parser.js" + }, + "engines": { + "node": ">=6.0.0" + } + }, + "node_modules/@babel/plugin-syntax-async-generators": { + "version": "7.8.4", + "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-async-generators/-/plugin-syntax-async-generators-7.8.4.tgz", + "integrity": "sha512-tycmZxkGfZaxhMRbXlPXuVFpdWlXpir2W4AMhSJgRKzk/eDlIXOhb2LHWoLpDF7TEHylV5zNhykX6KAgHJmTNw==", + "dev": true, + "dependencies": { + "@babel/helper-plugin-utils": "^7.8.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-syntax-bigint": { + "version": "7.8.3", + "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-bigint/-/plugin-syntax-bigint-7.8.3.tgz", + "integrity": "sha512-wnTnFlG+YxQm3vDxpGE57Pj0srRU4sHE/mDkt1qv2YJJSeUAec2ma4WLUnUPeKjyrfntVwe/N6dCXpU+zL3Npg==", + "dev": true, + "dependencies": { + "@babel/helper-plugin-utils": "^7.8.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-syntax-class-properties": { + "version": "7.12.13", + "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-class-properties/-/plugin-syntax-class-properties-7.12.13.tgz", + "integrity": "sha512-fm4idjKla0YahUNgFNLCB0qySdsoPiZP3iQE3rky0mBUtMZ23yDJ9SJdg6dXTSDnulOVqiF3Hgr9nbXvXTQZYA==", + "dev": true, + "dependencies": { + "@babel/helper-plugin-utils": "^7.12.13" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-syntax-import-meta": { + "version": "7.10.4", + "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-import-meta/-/plugin-syntax-import-meta-7.10.4.tgz", + "integrity": "sha512-Yqfm+XDx0+Prh3VSeEQCPU81yC+JWZ2pDPFSS4ZdpfZhp4MkFMaDC1UqseovEKwSUpnIL7+vK+Clp7bfh0iD7g==", + "dev": true, + "dependencies": { + "@babel/helper-plugin-utils": "^7.10.4" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-syntax-json-strings": { + "version": "7.8.3", + "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-json-strings/-/plugin-syntax-json-strings-7.8.3.tgz", + "integrity": "sha512-lY6kdGpWHvjoe2vk4WrAapEuBR69EMxZl+RoGRhrFGNYVK8mOPAW8VfbT/ZgrFbXlDNiiaxQnAtgVCZ6jv30EA==", + "dev": true, + "dependencies": { + "@babel/helper-plugin-utils": "^7.8.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-syntax-jsx": { + "version": "7.18.6", + "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-jsx/-/plugin-syntax-jsx-7.18.6.tgz", + "integrity": "sha512-6mmljtAedFGTWu2p/8WIORGwy+61PLgOMPOdazc7YoJ9ZCWUyFy3A6CpPkRKLKD1ToAesxX8KGEViAiLo9N+7Q==", + "dev": true, + "dependencies": { + "@babel/helper-plugin-utils": "^7.18.6" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-syntax-logical-assignment-operators": { + "version": "7.10.4", + "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-logical-assignment-operators/-/plugin-syntax-logical-assignment-operators-7.10.4.tgz", + "integrity": "sha512-d8waShlpFDinQ5MtvGU9xDAOzKH47+FFoney2baFIoMr952hKOLp1HR7VszoZvOsV/4+RRszNY7D17ba0te0ig==", + "dev": true, + "dependencies": { + "@babel/helper-plugin-utils": "^7.10.4" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-syntax-nullish-coalescing-operator": { + "version": "7.8.3", + "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-nullish-coalescing-operator/-/plugin-syntax-nullish-coalescing-operator-7.8.3.tgz", + "integrity": "sha512-aSff4zPII1u2QD7y+F8oDsz19ew4IGEJg9SVW+bqwpwtfFleiQDMdzA/R+UlWDzfnHFCxxleFT0PMIrR36XLNQ==", + "dev": true, + "dependencies": { + "@babel/helper-plugin-utils": "^7.8.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-syntax-numeric-separator": { + "version": "7.10.4", + "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-numeric-separator/-/plugin-syntax-numeric-separator-7.10.4.tgz", + "integrity": "sha512-9H6YdfkcK/uOnY/K7/aA2xpzaAgkQn37yzWUMRK7OaPOqOpGS1+n0H5hxT9AUw9EsSjPW8SVyMJwYRtWs3X3ug==", + "dev": true, + "dependencies": { + "@babel/helper-plugin-utils": "^7.10.4" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-syntax-object-rest-spread": { + "version": "7.8.3", + "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-object-rest-spread/-/plugin-syntax-object-rest-spread-7.8.3.tgz", + "integrity": "sha512-XoqMijGZb9y3y2XskN+P1wUGiVwWZ5JmoDRwx5+3GmEplNyVM2s2Dg8ILFQm8rWM48orGy5YpI5Bl8U1y7ydlA==", + "dev": true, + "dependencies": { + "@babel/helper-plugin-utils": "^7.8.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-syntax-optional-catch-binding": { + "version": "7.8.3", + "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-optional-catch-binding/-/plugin-syntax-optional-catch-binding-7.8.3.tgz", + "integrity": "sha512-6VPD0Pc1lpTqw0aKoeRTMiB+kWhAoT24PA+ksWSBrFtl5SIRVpZlwN3NNPQjehA2E/91FV3RjLWoVTglWcSV3Q==", + "dev": true, + "dependencies": { + "@babel/helper-plugin-utils": "^7.8.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-syntax-optional-chaining": { + "version": "7.8.3", + "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-optional-chaining/-/plugin-syntax-optional-chaining-7.8.3.tgz", + "integrity": "sha512-KoK9ErH1MBlCPxV0VANkXW2/dw4vlbGDrFgz8bmUsBGYkFRcbRwMh6cIJubdPrkxRwuGdtCk0v/wPTKbQgBjkg==", + "dev": true, + "dependencies": { + "@babel/helper-plugin-utils": "^7.8.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-syntax-top-level-await": { + "version": "7.14.5", + "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-top-level-await/-/plugin-syntax-top-level-await-7.14.5.tgz", + "integrity": "sha512-hx++upLv5U1rgYfwe1xBQUhRmU41NEvpUvrp8jkrSCdvGSnM5/qdRMtylJ6PG5OFkBaHkbTAKTnd3/YyESRHFw==", + "dev": true, + "dependencies": { + "@babel/helper-plugin-utils": "^7.14.5" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-syntax-typescript": { + "version": "7.20.0", + "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-typescript/-/plugin-syntax-typescript-7.20.0.tgz", + "integrity": "sha512-rd9TkG+u1CExzS4SM1BlMEhMXwFLKVjOAFFCDx9PbX5ycJWDoWMcwdJH9RhkPu1dOgn5TrxLot/Gx6lWFuAUNQ==", + "dev": true, + "dependencies": { + "@babel/helper-plugin-utils": "^7.19.0" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/template": { + "version": "7.20.7", + "resolved": "https://registry.npmjs.org/@babel/template/-/template-7.20.7.tgz", + "integrity": "sha512-8SegXApWe6VoNw0r9JHpSteLKTpTiLZ4rMlGIm9JQ18KiCtyQiAMEazujAHrUS5flrcqYZa75ukev3P6QmUwUw==", + "dev": true, + "dependencies": { + "@babel/code-frame": "^7.18.6", + "@babel/parser": "^7.20.7", + "@babel/types": "^7.20.7" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/traverse": { + "version": "7.21.2", + "resolved": "https://registry.npmjs.org/@babel/traverse/-/traverse-7.21.2.tgz", + "integrity": "sha512-ts5FFU/dSUPS13tv8XiEObDu9K+iagEKME9kAbaP7r0Y9KtZJZ+NGndDvWoRAYNpeWafbpFeki3q9QoMD6gxyw==", + "dev": true, + "dependencies": { + "@babel/code-frame": "^7.18.6", + "@babel/generator": "^7.21.1", + "@babel/helper-environment-visitor": "^7.18.9", + "@babel/helper-function-name": "^7.21.0", + "@babel/helper-hoist-variables": "^7.18.6", + "@babel/helper-split-export-declaration": "^7.18.6", + "@babel/parser": "^7.21.2", + "@babel/types": "^7.21.2", + "debug": "^4.1.0", + "globals": "^11.1.0" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/traverse/node_modules/globals": { + "version": "11.12.0", + "resolved": "https://registry.npmjs.org/globals/-/globals-11.12.0.tgz", + "integrity": "sha512-WOBp/EEGUiIsJSp7wcv/y6MO+lV9UoncWqxuFfm8eBwzWNgyfBd6Gz+IeKQ9jCmyhoH99g15M3T+QaVHFjizVA==", + "dev": true, + "engines": { + "node": ">=4" + } + }, + "node_modules/@babel/types": { + "version": "7.21.2", + "resolved": "https://registry.npmjs.org/@babel/types/-/types-7.21.2.tgz", + "integrity": "sha512-3wRZSs7jiFaB8AjxiiD+VqN5DTG2iRvJGQ+qYFrs/654lg6kGTQWIOFjlBo5RaXuAZjBmP3+OQH4dmhqiiyYxw==", + "dev": true, + "dependencies": { + "@babel/helper-string-parser": "^7.19.4", + "@babel/helper-validator-identifier": "^7.19.1", + "to-fast-properties": "^2.0.0" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@bcoe/v8-coverage": { + "version": "0.2.3", + "resolved": "https://registry.npmjs.org/@bcoe/v8-coverage/-/v8-coverage-0.2.3.tgz", + "integrity": "sha512-0hYQ8SB4Db5zvZB4axdMHGwEaQjkZzFjQiN9LVYvIFB2nSUHW9tYpxWriPrWDASIxiaXax83REcLxuSdnGPZtw==", + "dev": true + }, + "node_modules/@eslint/eslintrc": { + "version": "1.4.1", + "resolved": "https://registry.npmjs.org/@eslint/eslintrc/-/eslintrc-1.4.1.tgz", + "integrity": "sha512-XXrH9Uarn0stsyldqDYq8r++mROmWRI1xKMXa640Bb//SY1+ECYX6VzT6Lcx5frD0V30XieqJ0oX9I2Xj5aoMA==", + "dev": true, + "dependencies": { + "ajv": "^6.12.4", + "debug": "^4.3.2", + "espree": "^9.4.0", + "globals": "^13.19.0", + "ignore": "^5.2.0", + "import-fresh": "^3.2.1", + "js-yaml": "^4.1.0", + "minimatch": "^3.1.2", + "strip-json-comments": "^3.1.1" + }, + "engines": { + "node": "^12.22.0 || ^14.17.0 || >=16.0.0" + }, + "funding": { + "url": "https://opencollective.com/eslint" + } + }, + "node_modules/@ewoudenberg/difflib": { + "version": "0.1.0", + "resolved": "https://registry.npmjs.org/@ewoudenberg/difflib/-/difflib-0.1.0.tgz", + "integrity": "sha512-OU5P5mJyD3OoWYMWY+yIgwvgNS9cFAU10f+DDuvtogcWQOoJIsQ4Hy2McSfUfhKjq8L0FuWVb4Rt7kgA+XK86A==", + "dev": true, + "dependencies": { + "heap": ">= 0.2.0" + } + }, + "node_modules/@humanwhocodes/config-array": { + "version": "0.11.8", + "resolved": "https://registry.npmjs.org/@humanwhocodes/config-array/-/config-array-0.11.8.tgz", + "integrity": "sha512-UybHIJzJnR5Qc/MsD9Kr+RpO2h+/P1GhOwdiLPXK5TWk5sgTdu88bTD9UP+CKbPPh5Rni1u0GjAdYQLemG8g+g==", + "dev": true, + "dependencies": { + "@humanwhocodes/object-schema": "^1.2.1", + "debug": "^4.1.1", + "minimatch": "^3.0.5" + }, + "engines": { + "node": ">=10.10.0" + } + }, + "node_modules/@humanwhocodes/module-importer": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/@humanwhocodes/module-importer/-/module-importer-1.0.1.tgz", + "integrity": "sha512-bxveV4V8v5Yb4ncFTT3rPSgZBOpCkjfK0y4oVVVJwIuDVBRMDXrPyXRL988i5ap9m9bnyEEjWfm5WkBmtffLfA==", + "dev": true, + "engines": { + "node": ">=12.22" + }, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/nzakas" + } + }, + "node_modules/@humanwhocodes/object-schema": { + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/@humanwhocodes/object-schema/-/object-schema-1.2.1.tgz", + "integrity": "sha512-ZnQMnLV4e7hDlUvw8H+U8ASL02SS2Gn6+9Ac3wGGLIe7+je2AeAOxPY+izIPJDfFDb7eDjev0Us8MO1iFRN8hA==", + "dev": true + }, + "node_modules/@istanbuljs/load-nyc-config": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/@istanbuljs/load-nyc-config/-/load-nyc-config-1.1.0.tgz", + "integrity": "sha512-VjeHSlIzpv/NyD3N0YuHfXOPDIixcA1q2ZV98wsMqcYlPmv2n3Yb2lYP9XMElnaFVXg5A7YLTeLu6V84uQDjmQ==", + "dev": true, + "dependencies": { + "camelcase": "^5.3.1", + "find-up": "^4.1.0", + "get-package-type": "^0.1.0", + "js-yaml": "^3.13.1", + "resolve-from": "^5.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/@istanbuljs/load-nyc-config/node_modules/argparse": { + "version": "1.0.10", + "resolved": "https://registry.npmjs.org/argparse/-/argparse-1.0.10.tgz", + "integrity": "sha512-o5Roy6tNG4SL/FOkCAN6RzjiakZS25RLYFrcMttJqbdd8BWrnA+fGz57iN5Pb06pvBGvl5gQ0B48dJlslXvoTg==", + "dev": true, + "dependencies": { + "sprintf-js": "~1.0.2" + } + }, + "node_modules/@istanbuljs/load-nyc-config/node_modules/find-up": { + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/find-up/-/find-up-4.1.0.tgz", + "integrity": "sha512-PpOwAdQ/YlXQ2vj8a3h8IipDuYRi3wceVQQGYWxNINccq40Anw7BlsEXCMbt1Zt+OLA6Fq9suIpIWD0OsnISlw==", + "dev": true, + "dependencies": { + "locate-path": "^5.0.0", + "path-exists": "^4.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/@istanbuljs/load-nyc-config/node_modules/js-yaml": { + "version": "3.14.1", + "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-3.14.1.tgz", + "integrity": "sha512-okMH7OXXJ7YrN9Ok3/SXrnu4iX9yOk+25nqX4imS2npuvTYDmo/QEZoqwZkYaIDk3jVvBOTOIEgEhaLOynBS9g==", + "dev": true, + "dependencies": { + "argparse": "^1.0.7", + "esprima": "^4.0.0" + }, + "bin": { + "js-yaml": "bin/js-yaml.js" + } + }, + "node_modules/@istanbuljs/load-nyc-config/node_modules/locate-path": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/locate-path/-/locate-path-5.0.0.tgz", + "integrity": "sha512-t7hw9pI+WvuwNJXwk5zVHpyhIqzg2qTlklJOf0mVxGSbe3Fp2VieZcduNYjaLDoy6p9uGpQEGWG87WpMKlNq8g==", + "dev": true, + "dependencies": { + "p-locate": "^4.1.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/@istanbuljs/load-nyc-config/node_modules/p-limit": { + "version": "2.3.0", + "resolved": "https://registry.npmjs.org/p-limit/-/p-limit-2.3.0.tgz", + "integrity": "sha512-//88mFWSJx8lxCzwdAABTJL2MyWB12+eIY7MDL2SqLmAkeKU9qxRvWuSyTjm3FUmpBEMuFfckAIqEaVGUDxb6w==", + "dev": true, + "dependencies": { + "p-try": "^2.0.0" + }, + "engines": { + "node": ">=6" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/@istanbuljs/load-nyc-config/node_modules/p-locate": { + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/p-locate/-/p-locate-4.1.0.tgz", + "integrity": "sha512-R79ZZ/0wAxKGu3oYMlz8jy/kbhsNrS7SKZ7PxEHBgJ5+F2mtFW2fK2cOtBh1cHYkQsbzFV7I+EoRKe6Yt0oK7A==", + "dev": true, + "dependencies": { + "p-limit": "^2.2.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/@istanbuljs/load-nyc-config/node_modules/resolve-from": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/resolve-from/-/resolve-from-5.0.0.tgz", + "integrity": "sha512-qYg9KP24dD5qka9J47d0aVky0N+b4fTU89LN9iDnjB5waksiC49rvMB0PrUJQGoTmH50XPiqOvAjDfaijGxYZw==", + "dev": true, + "engines": { + "node": ">=8" + } + }, + "node_modules/@istanbuljs/schema": { + "version": "0.1.3", + "resolved": "https://registry.npmjs.org/@istanbuljs/schema/-/schema-0.1.3.tgz", + "integrity": "sha512-ZXRY4jNvVgSVQ8DL3LTcakaAtXwTVUxE81hslsyD2AtoXW/wVob10HkOJ1X/pAlcI7D+2YoZKg5do8G/w6RYgA==", + "dev": true, + "engines": { + "node": ">=8" + } + }, + "node_modules/@jest/console": { + "version": "29.5.0", + "resolved": "https://registry.npmjs.org/@jest/console/-/console-29.5.0.tgz", + "integrity": "sha512-NEpkObxPwyw/XxZVLPmAGKE89IQRp4puc6IQRPru6JKd1M3fW9v1xM1AnzIJE65hbCkzQAdnL8P47e9hzhiYLQ==", + "dev": true, + "dependencies": { + "@jest/types": "^29.5.0", + "@types/node": "*", + "chalk": "^4.0.0", + "jest-message-util": "^29.5.0", + "jest-util": "^29.5.0", + "slash": "^3.0.0" + }, + "engines": { + "node": "^14.15.0 || ^16.10.0 || >=18.0.0" + } + }, + "node_modules/@jest/core": { + "version": "29.5.0", + "resolved": "https://registry.npmjs.org/@jest/core/-/core-29.5.0.tgz", + "integrity": "sha512-28UzQc7ulUrOQw1IsN/kv1QES3q2kkbl/wGslyhAclqZ/8cMdB5M68BffkIdSJgKBUt50d3hbwJ92XESlE7LiQ==", + "dev": true, + "dependencies": { + "@jest/console": "^29.5.0", + "@jest/reporters": "^29.5.0", + "@jest/test-result": "^29.5.0", + "@jest/transform": "^29.5.0", + "@jest/types": "^29.5.0", + "@types/node": "*", + "ansi-escapes": "^4.2.1", + "chalk": "^4.0.0", + "ci-info": "^3.2.0", + "exit": "^0.1.2", + "graceful-fs": "^4.2.9", + "jest-changed-files": "^29.5.0", + "jest-config": "^29.5.0", + "jest-haste-map": "^29.5.0", + "jest-message-util": "^29.5.0", + "jest-regex-util": "^29.4.3", + "jest-resolve": "^29.5.0", + "jest-resolve-dependencies": "^29.5.0", + "jest-runner": "^29.5.0", + "jest-runtime": "^29.5.0", + "jest-snapshot": "^29.5.0", + "jest-util": "^29.5.0", + "jest-validate": "^29.5.0", + "jest-watcher": "^29.5.0", + "micromatch": "^4.0.4", + "pretty-format": "^29.5.0", + "slash": "^3.0.0", + "strip-ansi": "^6.0.0" + }, + "engines": { + "node": "^14.15.0 || ^16.10.0 || >=18.0.0" + }, + "peerDependencies": { + "node-notifier": "^8.0.1 || ^9.0.0 || ^10.0.0" + }, + "peerDependenciesMeta": { + "node-notifier": { + "optional": true + } + } + }, + "node_modules/@jest/environment": { + "version": "29.5.0", + "resolved": "https://registry.npmjs.org/@jest/environment/-/environment-29.5.0.tgz", + "integrity": "sha512-5FXw2+wD29YU1d4I2htpRX7jYnAyTRjP2CsXQdo9SAM8g3ifxWPSV0HnClSn71xwctr0U3oZIIH+dtbfmnbXVQ==", + "dev": true, + "dependencies": { + "@jest/fake-timers": "^29.5.0", + "@jest/types": "^29.5.0", + "@types/node": "*", + "jest-mock": "^29.5.0" + }, + "engines": { + "node": "^14.15.0 || ^16.10.0 || >=18.0.0" + } + }, + "node_modules/@jest/expect": { + "version": "29.5.0", + "resolved": "https://registry.npmjs.org/@jest/expect/-/expect-29.5.0.tgz", + "integrity": "sha512-PueDR2HGihN3ciUNGr4uelropW7rqUfTiOn+8u0leg/42UhblPxHkfoh0Ruu3I9Y1962P3u2DY4+h7GVTSVU6g==", + "dev": true, + "dependencies": { + "expect": "^29.5.0", + "jest-snapshot": "^29.5.0" + }, + "engines": { + "node": "^14.15.0 || ^16.10.0 || >=18.0.0" + } + }, + "node_modules/@jest/expect-utils": { + "version": "29.5.0", + "resolved": "https://registry.npmjs.org/@jest/expect-utils/-/expect-utils-29.5.0.tgz", + "integrity": "sha512-fmKzsidoXQT2KwnrwE0SQq3uj8Z763vzR8LnLBwC2qYWEFpjX8daRsk6rHUM1QvNlEW/UJXNXm59ztmJJWs2Mg==", + "dev": true, + "dependencies": { + "jest-get-type": "^29.4.3" + }, + "engines": { + "node": "^14.15.0 || ^16.10.0 || >=18.0.0" + } + }, + "node_modules/@jest/fake-timers": { + "version": "29.5.0", + "resolved": "https://registry.npmjs.org/@jest/fake-timers/-/fake-timers-29.5.0.tgz", + "integrity": "sha512-9ARvuAAQcBwDAqOnglWq2zwNIRUDtk/SCkp/ToGEhFv5r86K21l+VEs0qNTaXtyiY0lEePl3kylijSYJQqdbDg==", + "dev": true, + "dependencies": { + "@jest/types": "^29.5.0", + "@sinonjs/fake-timers": "^10.0.2", + "@types/node": "*", + "jest-message-util": "^29.5.0", + "jest-mock": "^29.5.0", + "jest-util": "^29.5.0" + }, + "engines": { + "node": "^14.15.0 || ^16.10.0 || >=18.0.0" + } + }, + "node_modules/@jest/globals": { + "version": "29.5.0", + "resolved": "https://registry.npmjs.org/@jest/globals/-/globals-29.5.0.tgz", + "integrity": "sha512-S02y0qMWGihdzNbUiqSAiKSpSozSuHX5UYc7QbnHP+D9Lyw8DgGGCinrN9uSuHPeKgSSzvPom2q1nAtBvUsvPQ==", + "dev": true, + "dependencies": { + "@jest/environment": "^29.5.0", + "@jest/expect": "^29.5.0", + "@jest/types": "^29.5.0", + "jest-mock": "^29.5.0" + }, + "engines": { + "node": "^14.15.0 || ^16.10.0 || >=18.0.0" + } + }, + "node_modules/@jest/reporters": { + "version": "29.5.0", + "resolved": "https://registry.npmjs.org/@jest/reporters/-/reporters-29.5.0.tgz", + "integrity": "sha512-D05STXqj/M8bP9hQNSICtPqz97u7ffGzZu+9XLucXhkOFBqKcXe04JLZOgIekOxdb73MAoBUFnqvf7MCpKk5OA==", + "dev": true, + "dependencies": { + "@bcoe/v8-coverage": "^0.2.3", + "@jest/console": "^29.5.0", + "@jest/test-result": "^29.5.0", + "@jest/transform": "^29.5.0", + "@jest/types": "^29.5.0", + "@jridgewell/trace-mapping": "^0.3.15", + "@types/node": "*", + "chalk": "^4.0.0", + "collect-v8-coverage": "^1.0.0", + "exit": "^0.1.2", + "glob": "^7.1.3", + "graceful-fs": "^4.2.9", + "istanbul-lib-coverage": "^3.0.0", + "istanbul-lib-instrument": "^5.1.0", + "istanbul-lib-report": "^3.0.0", + "istanbul-lib-source-maps": "^4.0.0", + "istanbul-reports": "^3.1.3", + "jest-message-util": "^29.5.0", + "jest-util": "^29.5.0", + "jest-worker": "^29.5.0", + "slash": "^3.0.0", + "string-length": "^4.0.1", + "strip-ansi": "^6.0.0", + "v8-to-istanbul": "^9.0.1" + }, + "engines": { + "node": "^14.15.0 || ^16.10.0 || >=18.0.0" + }, + "peerDependencies": { + "node-notifier": "^8.0.1 || ^9.0.0 || ^10.0.0" + }, + "peerDependenciesMeta": { + "node-notifier": { + "optional": true + } + } + }, + "node_modules/@jest/schemas": { + "version": "29.4.3", + "resolved": "https://registry.npmjs.org/@jest/schemas/-/schemas-29.4.3.tgz", + "integrity": "sha512-VLYKXQmtmuEz6IxJsrZwzG9NvtkQsWNnWMsKxqWNu3+CnfzJQhp0WDDKWLVV9hLKr0l3SLLFRqcYHjhtyuDVxg==", + "dev": true, + "dependencies": { + "@sinclair/typebox": "^0.25.16" + }, + "engines": { + "node": "^14.15.0 || ^16.10.0 || >=18.0.0" + } + }, + "node_modules/@jest/source-map": { + "version": "29.4.3", + "resolved": "https://registry.npmjs.org/@jest/source-map/-/source-map-29.4.3.tgz", + "integrity": "sha512-qyt/mb6rLyd9j1jUts4EQncvS6Yy3PM9HghnNv86QBlV+zdL2inCdK1tuVlL+J+lpiw2BI67qXOrX3UurBqQ1w==", + "dev": true, + "dependencies": { + "@jridgewell/trace-mapping": "^0.3.15", + "callsites": "^3.0.0", + "graceful-fs": "^4.2.9" + }, + "engines": { + "node": "^14.15.0 || ^16.10.0 || >=18.0.0" + } + }, + "node_modules/@jest/test-result": { + "version": "29.5.0", + "resolved": "https://registry.npmjs.org/@jest/test-result/-/test-result-29.5.0.tgz", + "integrity": "sha512-fGl4rfitnbfLsrfx1uUpDEESS7zM8JdgZgOCQuxQvL1Sn/I6ijeAVQWGfXI9zb1i9Mzo495cIpVZhA0yr60PkQ==", + "dev": true, + "dependencies": { + "@jest/console": "^29.5.0", + "@jest/types": "^29.5.0", + "@types/istanbul-lib-coverage": "^2.0.0", + "collect-v8-coverage": "^1.0.0" + }, + "engines": { + "node": "^14.15.0 || ^16.10.0 || >=18.0.0" + } + }, + "node_modules/@jest/test-sequencer": { + "version": "29.5.0", + "resolved": "https://registry.npmjs.org/@jest/test-sequencer/-/test-sequencer-29.5.0.tgz", + "integrity": "sha512-yPafQEcKjkSfDXyvtgiV4pevSeyuA6MQr6ZIdVkWJly9vkqjnFfcfhRQqpD5whjoU8EORki752xQmjaqoFjzMQ==", + "dev": true, + "dependencies": { + "@jest/test-result": "^29.5.0", + "graceful-fs": "^4.2.9", + "jest-haste-map": "^29.5.0", + "slash": "^3.0.0" + }, + "engines": { + "node": "^14.15.0 || ^16.10.0 || >=18.0.0" + } + }, + "node_modules/@jest/transform": { + "version": "29.5.0", + "resolved": "https://registry.npmjs.org/@jest/transform/-/transform-29.5.0.tgz", + "integrity": "sha512-8vbeZWqLJOvHaDfeMuoHITGKSz5qWc9u04lnWrQE3VyuSw604PzQM824ZeX9XSjUCeDiE3GuxZe5UKa8J61NQw==", + "dev": true, + "dependencies": { + "@babel/core": "^7.11.6", + "@jest/types": "^29.5.0", + "@jridgewell/trace-mapping": "^0.3.15", + "babel-plugin-istanbul": "^6.1.1", + "chalk": "^4.0.0", + "convert-source-map": "^2.0.0", + "fast-json-stable-stringify": "^2.1.0", + "graceful-fs": "^4.2.9", + "jest-haste-map": "^29.5.0", + "jest-regex-util": "^29.4.3", + "jest-util": "^29.5.0", + "micromatch": "^4.0.4", + "pirates": "^4.0.4", + "slash": "^3.0.0", + "write-file-atomic": "^4.0.2" + }, + "engines": { + "node": "^14.15.0 || ^16.10.0 || >=18.0.0" + } + }, + "node_modules/@jest/types": { + "version": "29.5.0", + "resolved": "https://registry.npmjs.org/@jest/types/-/types-29.5.0.tgz", + "integrity": "sha512-qbu7kN6czmVRc3xWFQcAN03RAUamgppVUdXrvl1Wr3jlNF93o9mJbGcDWrwGB6ht44u7efB1qCFgVQmca24Uog==", + "dev": true, + "dependencies": { + "@jest/schemas": "^29.4.3", + "@types/istanbul-lib-coverage": "^2.0.0", + "@types/istanbul-reports": "^3.0.0", + "@types/node": "*", + "@types/yargs": "^17.0.8", + "chalk": "^4.0.0" + }, + "engines": { + "node": "^14.15.0 || ^16.10.0 || >=18.0.0" + } + }, + "node_modules/@jridgewell/gen-mapping": { + "version": "0.1.1", + "resolved": "https://registry.npmjs.org/@jridgewell/gen-mapping/-/gen-mapping-0.1.1.tgz", + "integrity": "sha512-sQXCasFk+U8lWYEe66WxRDOE9PjVz4vSM51fTu3Hw+ClTpUSQb718772vH3pyS5pShp6lvQM7SxgIDXXXmOX7w==", + "dev": true, + "dependencies": { + "@jridgewell/set-array": "^1.0.0", + "@jridgewell/sourcemap-codec": "^1.4.10" + }, + "engines": { + "node": ">=6.0.0" + } + }, + "node_modules/@jridgewell/resolve-uri": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/@jridgewell/resolve-uri/-/resolve-uri-3.1.0.tgz", + "integrity": "sha512-F2msla3tad+Mfht5cJq7LSXcdudKTWCVYUgw6pLFOOHSTtZlj6SWNYAp+AhuqLmWdBO2X5hPrLcu8cVP8fy28w==", + "dev": true, + "engines": { + "node": ">=6.0.0" + } + }, + "node_modules/@jridgewell/set-array": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/@jridgewell/set-array/-/set-array-1.1.2.tgz", + "integrity": "sha512-xnkseuNADM0gt2bs+BvhO0p78Mk762YnZdsuzFV018NoG1Sj1SCQvpSqa7XUaTam5vAGasABV9qXASMKnFMwMw==", + "dev": true, + "engines": { + "node": ">=6.0.0" + } + }, + "node_modules/@jridgewell/sourcemap-codec": { + "version": "1.4.14", + "resolved": "https://registry.npmjs.org/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.4.14.tgz", + "integrity": "sha512-XPSJHWmi394fuUuzDnGz1wiKqWfo1yXecHQMRf2l6hztTO+nPru658AyDngaBe7isIxEkRsPR3FZh+s7iVa4Uw==", + "dev": true + }, + "node_modules/@jridgewell/trace-mapping": { + "version": "0.3.17", + "resolved": "https://registry.npmjs.org/@jridgewell/trace-mapping/-/trace-mapping-0.3.17.tgz", + "integrity": "sha512-MCNzAp77qzKca9+W/+I0+sEpaUnZoeasnghNeVc41VZCEKaCH73Vq3BZZ/SzWIgrqE4H4ceI+p+b6C0mHf9T4g==", + "dev": true, + "dependencies": { + "@jridgewell/resolve-uri": "3.1.0", + "@jridgewell/sourcemap-codec": "1.4.14" + } + }, + "node_modules/@mapbox/node-pre-gyp": { + "version": "1.0.10", + "resolved": "https://registry.npmjs.org/@mapbox/node-pre-gyp/-/node-pre-gyp-1.0.10.tgz", + "integrity": "sha512-4ySo4CjzStuprMwk35H5pPbkymjv1SF3jGLj6rAHp/xT/RF7TL7bd9CTm1xDY49K2qF7jmR/g7k+SkLETP6opA==", + "dependencies": { + "detect-libc": "^2.0.0", + "https-proxy-agent": "^5.0.0", + "make-dir": "^3.1.0", + "node-fetch": "^2.6.7", + "nopt": "^5.0.0", + "npmlog": "^5.0.1", + "rimraf": "^3.0.2", + "semver": "^7.3.5", + "tar": "^6.1.11" + }, + "bin": { + "node-pre-gyp": "bin/node-pre-gyp" + } + }, + "node_modules/@mapbox/node-pre-gyp/node_modules/lru-cache": { + "version": "6.0.0", + "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-6.0.0.tgz", + "integrity": "sha512-Jo6dJ04CmSjuznwJSS3pUeWmd/H0ffTlkXXgwZi+eq1UCmqQwCh+eLsYOYCwY991i2Fah4h1BEMCx4qThGbsiA==", + "dependencies": { + "yallist": "^4.0.0" + }, + "engines": { + "node": ">=10" + } + }, + "node_modules/@mapbox/node-pre-gyp/node_modules/semver": { + "version": "7.3.8", + "resolved": "https://registry.npmjs.org/semver/-/semver-7.3.8.tgz", + "integrity": "sha512-NB1ctGL5rlHrPJtFDVIVzTyQylMLu9N9VICA6HSFJo8MCGVTMW6gfpicwKmmK/dAjTOrqu5l63JJOpDSrAis3A==", + "dependencies": { + "lru-cache": "^6.0.0" + }, + "bin": { + "semver": "bin/semver.js" + }, + "engines": { + "node": ">=10" + } + }, + "node_modules/@mapbox/node-pre-gyp/node_modules/yallist": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/yallist/-/yallist-4.0.0.tgz", + "integrity": "sha512-3wdGidZyq5PB084XLES5TpOSRA3wjXAlIWMhum2kRcv/41Sn2emQ0dycQW4uZXLejwKvg6EsvbdlVL+FYEct7A==" + }, + "node_modules/@nodelib/fs.scandir": { + "version": "2.1.5", + "resolved": "https://registry.npmjs.org/@nodelib/fs.scandir/-/fs.scandir-2.1.5.tgz", + "integrity": "sha512-vq24Bq3ym5HEQm2NKCr3yXDwjc7vTsEThRDnkp2DK9p1uqLR+DHurm/NOTo0KG7HYHU7eppKZj3MyqYuMBf62g==", + "dev": true, + "dependencies": { + "@nodelib/fs.stat": "2.0.5", + "run-parallel": "^1.1.9" + }, + "engines": { + "node": ">= 8" + } + }, + "node_modules/@nodelib/fs.stat": { + "version": "2.0.5", + "resolved": "https://registry.npmjs.org/@nodelib/fs.stat/-/fs.stat-2.0.5.tgz", + "integrity": "sha512-RkhPPp2zrqDAQA/2jNhnztcPAlv64XdhIp7a7454A5ovI7Bukxgt7MX7udwAu3zg1DcpPU0rz3VV1SeaqvY4+A==", + "dev": true, + "engines": { + "node": ">= 8" + } + }, + "node_modules/@nodelib/fs.walk": { + "version": "1.2.8", + "resolved": "https://registry.npmjs.org/@nodelib/fs.walk/-/fs.walk-1.2.8.tgz", + "integrity": "sha512-oGB+UxlgWcgQkgwo8GcEGwemoTFt3FIO9ababBmaGwXIoBKZ+GTy0pP185beGg7Llih/NSHSV2XAs1lnznocSg==", + "dev": true, + "dependencies": { + "@nodelib/fs.scandir": "2.1.5", + "fastq": "^1.6.0" + }, + "engines": { + "node": ">= 8" + } + }, + "node_modules/@octokit/auth-token": { + "version": "3.0.3", + "resolved": "https://registry.npmjs.org/@octokit/auth-token/-/auth-token-3.0.3.tgz", + "integrity": "sha512-/aFM2M4HVDBT/jjDBa84sJniv1t9Gm/rLkalaz9htOm+L+8JMj1k9w0CkUdcxNyNxZPlTxKPVko+m1VlM58ZVA==", + "dependencies": { + "@octokit/types": "^9.0.0" + }, + "engines": { + "node": ">= 14" + } + }, + "node_modules/@octokit/core": { + "version": "4.2.0", + "resolved": "https://registry.npmjs.org/@octokit/core/-/core-4.2.0.tgz", + "integrity": "sha512-AgvDRUg3COpR82P7PBdGZF/NNqGmtMq2NiPqeSsDIeCfYFOZ9gddqWNQHnFdEUf+YwOj4aZYmJnlPp7OXmDIDg==", + "dependencies": { + "@octokit/auth-token": "^3.0.0", + "@octokit/graphql": "^5.0.0", + "@octokit/request": "^6.0.0", + "@octokit/request-error": "^3.0.0", + "@octokit/types": "^9.0.0", + "before-after-hook": "^2.2.0", + "universal-user-agent": "^6.0.0" + }, + "engines": { + "node": ">= 14" + } + }, + "node_modules/@octokit/endpoint": { + "version": "7.0.5", + "resolved": "https://registry.npmjs.org/@octokit/endpoint/-/endpoint-7.0.5.tgz", + "integrity": "sha512-LG4o4HMY1Xoaec87IqQ41TQ+glvIeTKqfjkCEmt5AIwDZJwQeVZFIEYXrYY6yLwK+pAScb9Gj4q+Nz2qSw1roA==", + "dependencies": { + "@octokit/types": "^9.0.0", + "is-plain-object": "^5.0.0", + "universal-user-agent": "^6.0.0" + }, + "engines": { + "node": ">= 14" + } + }, + "node_modules/@octokit/fixtures": { + "version": "22.0.6", + "resolved": "https://registry.npmjs.org/@octokit/fixtures/-/fixtures-22.0.6.tgz", + "integrity": "sha512-fSxpinPEC+6pIm47A3tC7Ur5gguJSIDHNVapUZMvIK5GqTauvdkr0Q5MbXmzXstlyJLWmXTK8jOlHVU1YJ0NcA==", + "dev": true, + "dependencies": { + "json-diff": "^1.0.0", + "lodash": "^4.17.11", + "nock": "^13.0.0", + "url-template": "^3.0.0" + } + }, + "node_modules/@octokit/graphql": { + "version": "5.0.5", + "resolved": "https://registry.npmjs.org/@octokit/graphql/-/graphql-5.0.5.tgz", + "integrity": "sha512-Qwfvh3xdqKtIznjX9lz2D458r7dJPP8l6r4GQkIdWQouZwHQK0mVT88uwiU2bdTU2OtT1uOlKpRciUWldpG0yQ==", + "dependencies": { + "@octokit/request": "^6.0.0", + "@octokit/types": "^9.0.0", + "universal-user-agent": "^6.0.0" + }, + "engines": { + "node": ">= 14" + } + }, + "node_modules/@octokit/openapi-types": { + "version": "16.0.0", + "resolved": "https://registry.npmjs.org/@octokit/openapi-types/-/openapi-types-16.0.0.tgz", + "integrity": "sha512-JbFWOqTJVLHZSUUoF4FzAZKYtqdxWu9Z5m2QQnOyEa04fOFljvyh7D3GYKbfuaSWisqehImiVIMG4eyJeP5VEA==" + }, + "node_modules/@octokit/plugin-paginate-rest": { + "version": "2.21.3", + "resolved": "https://registry.npmjs.org/@octokit/plugin-paginate-rest/-/plugin-paginate-rest-2.21.3.tgz", + "integrity": "sha512-aCZTEf0y2h3OLbrgKkrfFdjRL6eSOo8komneVQJnYecAxIej7Bafor2xhuDJOIFau4pk0i/P28/XgtbyPF0ZHw==", + "dependencies": { + "@octokit/types": "^6.40.0" + }, + "peerDependencies": { + "@octokit/core": ">=2" + } + }, + "node_modules/@octokit/plugin-paginate-rest/node_modules/@octokit/openapi-types": { + "version": "12.11.0", + "resolved": "https://registry.npmjs.org/@octokit/openapi-types/-/openapi-types-12.11.0.tgz", + "integrity": "sha512-VsXyi8peyRq9PqIz/tpqiL2w3w80OgVMwBHltTml3LmVvXiphgeqmY9mvBw9Wu7e0QWk/fqD37ux8yP5uVekyQ==" + }, + "node_modules/@octokit/plugin-paginate-rest/node_modules/@octokit/types": { + "version": "6.41.0", + "resolved": "https://registry.npmjs.org/@octokit/types/-/types-6.41.0.tgz", + "integrity": "sha512-eJ2jbzjdijiL3B4PrSQaSjuF2sPEQPVCPzBvTHJD9Nz+9dw2SGH4K4xeQJ77YfTq5bRQ+bD8wT11JbeDPmxmGg==", + "dependencies": { + "@octokit/openapi-types": "^12.11.0" + } + }, + "node_modules/@octokit/plugin-request-log": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/@octokit/plugin-request-log/-/plugin-request-log-1.0.4.tgz", + "integrity": "sha512-mLUsMkgP7K/cnFEw07kWqXGF5LKrOkD+lhCrKvPHXWDywAwuDUeDwWBpc69XK3pNX0uKiVt8g5z96PJ6z9xCFA==", + "peerDependencies": { + "@octokit/core": ">=3" + } + }, + "node_modules/@octokit/plugin-rest-endpoint-methods": { + "version": "5.16.2", + "resolved": "https://registry.npmjs.org/@octokit/plugin-rest-endpoint-methods/-/plugin-rest-endpoint-methods-5.16.2.tgz", + "integrity": "sha512-8QFz29Fg5jDuTPXVtey05BLm7OB+M8fnvE64RNegzX7U+5NUXcOcnpTIK0YfSHBg8gYd0oxIq3IZTe9SfPZiRw==", + "dependencies": { + "@octokit/types": "^6.39.0", + "deprecation": "^2.3.1" + }, + "peerDependencies": { + "@octokit/core": ">=3" + } + }, + "node_modules/@octokit/plugin-rest-endpoint-methods/node_modules/@octokit/openapi-types": { + "version": "12.11.0", + "resolved": "https://registry.npmjs.org/@octokit/openapi-types/-/openapi-types-12.11.0.tgz", + "integrity": "sha512-VsXyi8peyRq9PqIz/tpqiL2w3w80OgVMwBHltTml3LmVvXiphgeqmY9mvBw9Wu7e0QWk/fqD37ux8yP5uVekyQ==" + }, + "node_modules/@octokit/plugin-rest-endpoint-methods/node_modules/@octokit/types": { + "version": "6.41.0", + "resolved": "https://registry.npmjs.org/@octokit/types/-/types-6.41.0.tgz", + "integrity": "sha512-eJ2jbzjdijiL3B4PrSQaSjuF2sPEQPVCPzBvTHJD9Nz+9dw2SGH4K4xeQJ77YfTq5bRQ+bD8wT11JbeDPmxmGg==", + "dependencies": { + "@octokit/openapi-types": "^12.11.0" + } + }, + "node_modules/@octokit/plugin-retry": { + "version": "4.1.1", + "resolved": "https://registry.npmjs.org/@octokit/plugin-retry/-/plugin-retry-4.1.1.tgz", + "integrity": "sha512-iR7rg5KRSl6L6RELTQQ3CYeNgeBJyuAmP95odzcQ/zyefnRT/Peo8rWeky4z7V/+/oPWqOL4I5Z+V8KtjpHCJw==", + "dependencies": { + "@octokit/types": "^9.0.0", + "bottleneck": "^2.15.3" + }, + "engines": { + "node": ">= 14" + }, + "peerDependencies": { + "@octokit/core": ">=3" + } + }, + "node_modules/@octokit/request": { + "version": "6.2.3", + "resolved": "https://registry.npmjs.org/@octokit/request/-/request-6.2.3.tgz", + "integrity": "sha512-TNAodj5yNzrrZ/VxP+H5HiYaZep0H3GU0O7PaF+fhDrt8FPrnkei9Aal/txsN/1P7V3CPiThG0tIvpPDYUsyAA==", + "dependencies": { + "@octokit/endpoint": "^7.0.0", + "@octokit/request-error": "^3.0.0", + "@octokit/types": "^9.0.0", + "is-plain-object": "^5.0.0", + "node-fetch": "^2.6.7", + "universal-user-agent": "^6.0.0" + }, + "engines": { + "node": ">= 14" + } + }, + "node_modules/@octokit/request-error": { + "version": "3.0.3", + "resolved": "https://registry.npmjs.org/@octokit/request-error/-/request-error-3.0.3.tgz", + "integrity": "sha512-crqw3V5Iy2uOU5Np+8M/YexTlT8zxCfI+qu+LxUB7SZpje4Qmx3mub5DfEKSO8Ylyk0aogi6TYdf6kxzh2BguQ==", + "dependencies": { + "@octokit/types": "^9.0.0", + "deprecation": "^2.0.0", + "once": "^1.4.0" + }, + "engines": { + "node": ">= 14" + } + }, + "node_modules/@octokit/rest": { + "version": "19.0.7", + "resolved": "https://registry.npmjs.org/@octokit/rest/-/rest-19.0.7.tgz", + "integrity": "sha512-HRtSfjrWmWVNp2uAkEpQnuGMJsu/+dBr47dRc5QVgsCbnIc1+GFEaoKBWkYG+zjrsHpSqcAElMio+n10c0b5JA==", + "dependencies": { + "@octokit/core": "^4.1.0", + "@octokit/plugin-paginate-rest": "^6.0.0", + "@octokit/plugin-request-log": "^1.0.4", + "@octokit/plugin-rest-endpoint-methods": "^7.0.0" + }, + "engines": { + "node": ">= 14" + } + }, + "node_modules/@octokit/rest/node_modules/@octokit/plugin-paginate-rest": { + "version": "6.0.0", + "resolved": "https://registry.npmjs.org/@octokit/plugin-paginate-rest/-/plugin-paginate-rest-6.0.0.tgz", + "integrity": "sha512-Sq5VU1PfT6/JyuXPyt04KZNVsFOSBaYOAq2QRZUwzVlI10KFvcbUo8lR258AAQL1Et60b0WuVik+zOWKLuDZxw==", + "dependencies": { + "@octokit/types": "^9.0.0" + }, + "engines": { + "node": ">= 14" + }, + "peerDependencies": { + "@octokit/core": ">=4" + } + }, + "node_modules/@octokit/rest/node_modules/@octokit/plugin-rest-endpoint-methods": { + "version": "7.0.1", + "resolved": "https://registry.npmjs.org/@octokit/plugin-rest-endpoint-methods/-/plugin-rest-endpoint-methods-7.0.1.tgz", + "integrity": "sha512-pnCaLwZBudK5xCdrR823xHGNgqOzRnJ/mpC/76YPpNP7DybdsJtP7mdOwh+wYZxK5jqeQuhu59ogMI4NRlBUvA==", + "dependencies": { + "@octokit/types": "^9.0.0", + "deprecation": "^2.3.1" + }, + "engines": { + "node": ">= 14" + }, + "peerDependencies": { + "@octokit/core": ">=3" + } + }, + "node_modules/@octokit/types": { + "version": "9.0.0", + "resolved": "https://registry.npmjs.org/@octokit/types/-/types-9.0.0.tgz", + "integrity": "sha512-LUewfj94xCMH2rbD5YJ+6AQ4AVjFYTgpp6rboWM5T7N3IsIF65SBEOVcYMGAEzO/kKNiNaW4LoWtoThOhH06gw==", + "dependencies": { + "@octokit/openapi-types": "^16.0.0" + } + }, + "node_modules/@sinclair/typebox": { + "version": "0.25.24", + "resolved": "https://registry.npmjs.org/@sinclair/typebox/-/typebox-0.25.24.tgz", + "integrity": "sha512-XJfwUVUKDHF5ugKwIcxEgc9k8b7HbznCp6eUfWgu710hMPNIO4aw4/zB5RogDQz8nd6gyCDpU9O/m6qYEWY6yQ==", + "dev": true + }, + "node_modules/@sinonjs/commons": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/@sinonjs/commons/-/commons-2.0.0.tgz", + "integrity": "sha512-uLa0j859mMrg2slwQYdO/AkrOfmH+X6LTVmNTS9CqexuE2IvVORIkSpJLqePAbEnKJ77aMmCwr1NUZ57120Xcg==", + "dev": true, + "dependencies": { + "type-detect": "4.0.8" + } + }, + "node_modules/@sinonjs/fake-timers": { + "version": "10.0.2", + "resolved": "https://registry.npmjs.org/@sinonjs/fake-timers/-/fake-timers-10.0.2.tgz", + "integrity": "sha512-SwUDyjWnah1AaNl7kxsa7cfLhlTYoiyhDAIgyh+El30YvXs/o7OLXpYH88Zdhyx9JExKrmHDJ+10bwIcY80Jmw==", + "dev": true, + "dependencies": { + "@sinonjs/commons": "^2.0.0" + } + }, + "node_modules/@types/babel__core": { + "version": "7.20.0", + "resolved": "https://registry.npmjs.org/@types/babel__core/-/babel__core-7.20.0.tgz", + "integrity": "sha512-+n8dL/9GWblDO0iU6eZAwEIJVr5DWigtle+Q6HLOrh/pdbXOhOtqzq8VPPE2zvNJzSKY4vH/z3iT3tn0A3ypiQ==", + "dev": true, + "dependencies": { + "@babel/parser": "^7.20.7", + "@babel/types": "^7.20.7", + "@types/babel__generator": "*", + "@types/babel__template": "*", + "@types/babel__traverse": "*" + } + }, + "node_modules/@types/babel__generator": { + "version": "7.6.4", + "resolved": "https://registry.npmjs.org/@types/babel__generator/-/babel__generator-7.6.4.tgz", + "integrity": "sha512-tFkciB9j2K755yrTALxD44McOrk+gfpIpvC3sxHjRawj6PfnQxrse4Clq5y/Rq+G3mrBurMax/lG8Qn2t9mSsg==", + "dev": true, + "dependencies": { + "@babel/types": "^7.0.0" + } + }, + "node_modules/@types/babel__template": { + "version": "7.4.1", + "resolved": "https://registry.npmjs.org/@types/babel__template/-/babel__template-7.4.1.tgz", + "integrity": "sha512-azBFKemX6kMg5Io+/rdGT0dkGreboUVR0Cdm3fz9QJWpaQGJRQXl7C+6hOTCZcMll7KFyEQpgbYI2lHdsS4U7g==", + "dev": true, + "dependencies": { + "@babel/parser": "^7.1.0", + "@babel/types": "^7.0.0" + } + }, + "node_modules/@types/babel__traverse": { + "version": "7.18.3", + "resolved": "https://registry.npmjs.org/@types/babel__traverse/-/babel__traverse-7.18.3.tgz", + "integrity": "sha512-1kbcJ40lLB7MHsj39U4Sh1uTd2E7rLEa79kmDpI6cy+XiXsteB3POdQomoq4FxszMrO3ZYchkhYJw7A2862b3w==", + "dev": true, + "dependencies": { + "@babel/types": "^7.3.0" + } + }, + "node_modules/@types/graceful-fs": { + "version": "4.1.6", + "resolved": "https://registry.npmjs.org/@types/graceful-fs/-/graceful-fs-4.1.6.tgz", + "integrity": "sha512-Sig0SNORX9fdW+bQuTEovKj3uHcUL6LQKbCrrqb1X7J6/ReAbhCXRAhc+SMejhLELFj2QcyuxmUooZ4bt5ReSw==", + "dev": true, + "dependencies": { + "@types/node": "*" + } + }, + "node_modules/@types/istanbul-lib-coverage": { + "version": "2.0.4", + "resolved": "https://registry.npmjs.org/@types/istanbul-lib-coverage/-/istanbul-lib-coverage-2.0.4.tgz", + "integrity": "sha512-z/QT1XN4K4KYuslS23k62yDIDLwLFkzxOuMplDtObz0+y7VqJCaO2o+SPwHCvLFZh7xazvvoor2tA/hPz9ee7g==", + "dev": true + }, + "node_modules/@types/istanbul-lib-report": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/@types/istanbul-lib-report/-/istanbul-lib-report-3.0.0.tgz", + "integrity": "sha512-plGgXAPfVKFoYfa9NpYDAkseG+g6Jr294RqeqcqDixSbU34MZVJRi/P+7Y8GDpzkEwLaGZZOpKIEmeVZNtKsrg==", + "dev": true, + "dependencies": { + "@types/istanbul-lib-coverage": "*" + } + }, + "node_modules/@types/istanbul-reports": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/@types/istanbul-reports/-/istanbul-reports-3.0.1.tgz", + "integrity": "sha512-c3mAZEuK0lvBp8tmuL74XRKn1+y2dcwOUpH7x4WrF6gk1GIgiluDRgMYQtw2OFcBvAJWlt6ASU3tSqxp0Uu0Aw==", + "dev": true, + "dependencies": { + "@types/istanbul-lib-report": "*" + } + }, + "node_modules/@types/node": { + "version": "18.14.6", + "resolved": "https://registry.npmjs.org/@types/node/-/node-18.14.6.tgz", + "integrity": "sha512-93+VvleD3mXwlLI/xASjw0FzKcwzl3OdTCzm1LaRfqgS21gfFtK3zDXM5Op9TeeMsJVOaJ2VRDpT9q4Y3d0AvA==", + "dev": true + }, + "node_modules/@types/prettier": { + "version": "2.7.2", + "resolved": "https://registry.npmjs.org/@types/prettier/-/prettier-2.7.2.tgz", + "integrity": "sha512-KufADq8uQqo1pYKVIYzfKbJfBAc0sOeXqGbFaSpv8MRmC/zXgowNZmFcbngndGk922QDmOASEXUZCaY48gs4cg==", + "dev": true + }, + "node_modules/@types/stack-utils": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/@types/stack-utils/-/stack-utils-2.0.1.tgz", + "integrity": "sha512-Hl219/BT5fLAaz6NDkSuhzasy49dwQS/DSdu4MdggFB8zcXv7vflBI3xp7FEmkmdDkBUI2bPUNeMttp2knYdxw==", + "dev": true + }, + "node_modules/@types/yargs": { + "version": "17.0.22", + "resolved": "https://registry.npmjs.org/@types/yargs/-/yargs-17.0.22.tgz", + "integrity": "sha512-pet5WJ9U8yPVRhkwuEIp5ktAeAqRZOq4UdAyWLWzxbtpyXnzbtLdKiXAjJzi/KLmPGS9wk86lUFWZFN6sISo4g==", + "dev": true, + "dependencies": { + "@types/yargs-parser": "*" + } + }, + "node_modules/@types/yargs-parser": { + "version": "21.0.0", + "resolved": "https://registry.npmjs.org/@types/yargs-parser/-/yargs-parser-21.0.0.tgz", + "integrity": "sha512-iO9ZQHkZxHn4mSakYV0vFHAVDyEOIJQrV2uZ06HxEPcx+mt8swXoZHIbaaJ2crJYFfErySgktuTZ3BeLz+XmFA==", + "dev": true + }, + "node_modules/@vercel/ncc": { + "version": "0.36.1", + "resolved": "https://registry.npmjs.org/@vercel/ncc/-/ncc-0.36.1.tgz", + "integrity": "sha512-S4cL7Taa9yb5qbv+6wLgiKVZ03Qfkc4jGRuiUQMQ8HGBD5pcNRnHeYM33zBvJE4/zJGjJJ8GScB+WmTsn9mORw==", + "dev": true, + "bin": { + "ncc": "dist/ncc/cli.js" + } + }, + "node_modules/abbrev": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/abbrev/-/abbrev-1.1.1.tgz", + "integrity": "sha512-nne9/IiQ/hzIhY6pdDnbBtz7DjPTKrY00P/zvPSm5pOFkl6xuGrGnXn/VtTNNfNtAfZ9/1RtehkszU9qcTii0Q==" + }, + "node_modules/acorn": { + "version": "8.8.2", + "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.8.2.tgz", + "integrity": "sha512-xjIYgE8HBrkpd/sJqOGNspf8uHG+NOHGOw6a/Urj8taM2EXfdNAH2oFcPeIFfsv3+kz/mJrS5VuMqbNLjCa2vw==", + "dev": true, + "bin": { + "acorn": "bin/acorn" + }, + "engines": { + "node": ">=0.4.0" + } + }, + "node_modules/acorn-jsx": { + "version": "5.3.2", + "resolved": "https://registry.npmjs.org/acorn-jsx/-/acorn-jsx-5.3.2.tgz", + "integrity": "sha512-rq9s+JNhf0IChjtDXxllJ7g41oZk5SlXtp0LHwyA5cejwn7vKmKp4pPri6YEePv2PU65sAsegbXtIinmDFDXgQ==", + "dev": true, + "peerDependencies": { + "acorn": "^6.0.0 || ^7.0.0 || ^8.0.0" + } + }, + "node_modules/agent-base": { + "version": "6.0.2", + "resolved": "https://registry.npmjs.org/agent-base/-/agent-base-6.0.2.tgz", + "integrity": "sha512-RZNwNclF7+MS/8bDg70amg32dyeZGZxiDuQmZxKLAlQjr3jGyLx+4Kkk58UO7D2QdgFIQCovuSuZESne6RG6XQ==", + "dependencies": { + "debug": "4" + }, + "engines": { + "node": ">= 6.0.0" + } + }, + "node_modules/ajv": { + "version": "6.12.6", + "resolved": "https://registry.npmjs.org/ajv/-/ajv-6.12.6.tgz", + "integrity": "sha512-j3fVLgvTo527anyYyJOGTYJbG+vnnQYvE0m5mmkc1TK+nxAppkCLMIL0aZ4dblVCNoGShhm+kzE4ZUykBoMg4g==", + "dev": true, + "dependencies": { + "fast-deep-equal": "^3.1.1", + "fast-json-stable-stringify": "^2.0.0", + "json-schema-traverse": "^0.4.1", + "uri-js": "^4.2.2" + }, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/epoberezkin" + } + }, + "node_modules/ansi-escapes": { + "version": "4.3.2", + "resolved": "https://registry.npmjs.org/ansi-escapes/-/ansi-escapes-4.3.2.tgz", + "integrity": "sha512-gKXj5ALrKWQLsYG9jlTRmR/xKluxHV+Z9QEwNIgCfM1/uwPMCuzVVnh5mwTd+OuBZcwSIMbqssNWRm1lE51QaQ==", + "dev": true, + "dependencies": { + "type-fest": "^0.21.3" + }, + "engines": { + "node": ">=8" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/ansi-escapes/node_modules/type-fest": { + "version": "0.21.3", + "resolved": "https://registry.npmjs.org/type-fest/-/type-fest-0.21.3.tgz", + "integrity": "sha512-t0rzBq87m3fVcduHDUFhKmyyX+9eo6WQjZvf51Ea/M0Q7+T374Jp1aUiyUl0GKxp8M/OETVHSDvmkyPgvX+X2w==", + "dev": true, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/ansi-regex": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.1.tgz", + "integrity": "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==", + "engines": { + "node": ">=8" + } + }, + "node_modules/ansi-styles": { + "version": "4.3.0", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz", + "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==", + "dev": true, + "dependencies": { + "color-convert": "^2.0.1" + }, + "engines": { + "node": ">=8" + }, + "funding": { + "url": "https://github.com/chalk/ansi-styles?sponsor=1" + } + }, + "node_modules/anymatch": { + "version": "3.1.3", + "resolved": "https://registry.npmjs.org/anymatch/-/anymatch-3.1.3.tgz", + "integrity": "sha512-KMReFUr0B4t+D+OBkjR3KYqvocp2XaSzO55UcB6mgQMd3KbcE+mWTyvVV7D/zsdEbNnV6acZUutkiHQXvTr1Rw==", + "dev": true, + "dependencies": { + "normalize-path": "^3.0.0", + "picomatch": "^2.0.4" + }, + "engines": { + "node": ">= 8" + } + }, + "node_modules/aproba": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/aproba/-/aproba-2.0.0.tgz", + "integrity": "sha512-lYe4Gx7QT+MKGbDsA+Z+he/Wtef0BiwDOlK/XkBrdfsh9J/jPPXbX0tE9x9cl27Tmu5gg3QUbUrQYa/y+KOHPQ==" + }, + "node_modules/are-we-there-yet": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/are-we-there-yet/-/are-we-there-yet-2.0.0.tgz", + "integrity": "sha512-Ci/qENmwHnsYo9xKIcUJN5LeDKdJ6R1Z1j9V/J5wyq8nh/mYPEpIKJbBZXtZjG04HiK7zV/p6Vs9952MrMeUIw==", + "dependencies": { + "delegates": "^1.0.0", + "readable-stream": "^3.6.0" + }, + "engines": { + "node": ">=10" + } + }, + "node_modules/argparse": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/argparse/-/argparse-2.0.1.tgz", + "integrity": "sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q==", + "dev": true + }, + "node_modules/array.prototype.filter": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/array.prototype.filter/-/array.prototype.filter-1.0.2.tgz", + "integrity": "sha512-us+UrmGOilqttSOgoWZTpOvHu68vZT2YCjc/H4vhu56vzZpaDFBhB+Se2UwqWzMKbDv7Myq5M5pcZLAtUvTQdQ==", + "dev": true, + "dependencies": { + "call-bind": "^1.0.2", + "define-properties": "^1.1.4", + "es-abstract": "^1.20.4", + "es-array-method-boxes-properly": "^1.0.0", + "is-string": "^1.0.7" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/array.prototype.flat": { + "version": "1.3.1", + "resolved": "https://registry.npmjs.org/array.prototype.flat/-/array.prototype.flat-1.3.1.tgz", + "integrity": "sha512-roTU0KWIOmJ4DRLmwKd19Otg0/mT3qPNt0Qb3GWW8iObuZXxrjB/pzn0R3hqpRSWg4HCwqx+0vwOnWnvlOyeIA==", + "dev": true, + "dependencies": { + "call-bind": "^1.0.2", + "define-properties": "^1.1.4", + "es-abstract": "^1.20.4", + "es-shim-unscopables": "^1.0.0" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/available-typed-arrays": { + "version": "1.0.5", + "resolved": "https://registry.npmjs.org/available-typed-arrays/-/available-typed-arrays-1.0.5.tgz", + "integrity": "sha512-DMD0KiN46eipeziST1LPP/STfDU0sufISXmjSgvVsoU2tqxctQeASejWcfNtxYKqETM1UxQ8sp2OrSBWpHY6sw==", + "dev": true, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/babel-jest": { + "version": "29.5.0", + "resolved": "https://registry.npmjs.org/babel-jest/-/babel-jest-29.5.0.tgz", + "integrity": "sha512-mA4eCDh5mSo2EcA9xQjVTpmbbNk32Zb3Q3QFQsNhaK56Q+yoXowzFodLux30HRgyOho5rsQ6B0P9QpMkvvnJ0Q==", + "dev": true, + "dependencies": { + "@jest/transform": "^29.5.0", + "@types/babel__core": "^7.1.14", + "babel-plugin-istanbul": "^6.1.1", + "babel-preset-jest": "^29.5.0", + "chalk": "^4.0.0", + "graceful-fs": "^4.2.9", + "slash": "^3.0.0" + }, + "engines": { + "node": "^14.15.0 || ^16.10.0 || >=18.0.0" + }, + "peerDependencies": { + "@babel/core": "^7.8.0" + } + }, + "node_modules/babel-plugin-istanbul": { + "version": "6.1.1", + "resolved": "https://registry.npmjs.org/babel-plugin-istanbul/-/babel-plugin-istanbul-6.1.1.tgz", + "integrity": "sha512-Y1IQok9821cC9onCx5otgFfRm7Lm+I+wwxOx738M/WLPZ9Q42m4IG5W0FNX8WLL2gYMZo3JkuXIH2DOpWM+qwA==", + "dev": true, + "dependencies": { + "@babel/helper-plugin-utils": "^7.0.0", + "@istanbuljs/load-nyc-config": "^1.0.0", + "@istanbuljs/schema": "^0.1.2", + "istanbul-lib-instrument": "^5.0.4", + "test-exclude": "^6.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/babel-plugin-jest-hoist": { + "version": "29.5.0", + "resolved": "https://registry.npmjs.org/babel-plugin-jest-hoist/-/babel-plugin-jest-hoist-29.5.0.tgz", + "integrity": "sha512-zSuuuAlTMT4mzLj2nPnUm6fsE6270vdOfnpbJ+RmruU75UhLFvL0N2NgI7xpeS7NaB6hGqmd5pVpGTDYvi4Q3w==", + "dev": true, + "dependencies": { + "@babel/template": "^7.3.3", + "@babel/types": "^7.3.3", + "@types/babel__core": "^7.1.14", + "@types/babel__traverse": "^7.0.6" + }, + "engines": { + "node": "^14.15.0 || ^16.10.0 || >=18.0.0" + } + }, + "node_modules/babel-preset-current-node-syntax": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/babel-preset-current-node-syntax/-/babel-preset-current-node-syntax-1.0.1.tgz", + "integrity": "sha512-M7LQ0bxarkxQoN+vz5aJPsLBn77n8QgTFmo8WK0/44auK2xlCXrYcUxHFxgU7qW5Yzw/CjmLRK2uJzaCd7LvqQ==", + "dev": true, + "dependencies": { + "@babel/plugin-syntax-async-generators": "^7.8.4", + "@babel/plugin-syntax-bigint": "^7.8.3", + "@babel/plugin-syntax-class-properties": "^7.8.3", + "@babel/plugin-syntax-import-meta": "^7.8.3", + "@babel/plugin-syntax-json-strings": "^7.8.3", + "@babel/plugin-syntax-logical-assignment-operators": "^7.8.3", + "@babel/plugin-syntax-nullish-coalescing-operator": "^7.8.3", + "@babel/plugin-syntax-numeric-separator": "^7.8.3", + "@babel/plugin-syntax-object-rest-spread": "^7.8.3", + "@babel/plugin-syntax-optional-catch-binding": "^7.8.3", + "@babel/plugin-syntax-optional-chaining": "^7.8.3", + "@babel/plugin-syntax-top-level-await": "^7.8.3" + }, + "peerDependencies": { + "@babel/core": "^7.0.0" + } + }, + "node_modules/babel-preset-jest": { + "version": "29.5.0", + "resolved": "https://registry.npmjs.org/babel-preset-jest/-/babel-preset-jest-29.5.0.tgz", + "integrity": "sha512-JOMloxOqdiBSxMAzjRaH023/vvcaSaec49zvg+2LmNsktC7ei39LTJGw02J+9uUtTZUq6xbLyJ4dxe9sSmIuAg==", + "dev": true, + "dependencies": { + "babel-plugin-jest-hoist": "^29.5.0", + "babel-preset-current-node-syntax": "^1.0.0" + }, + "engines": { + "node": "^14.15.0 || ^16.10.0 || >=18.0.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0" + } + }, + "node_modules/balanced-match": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.2.tgz", + "integrity": "sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==" + }, + "node_modules/before-after-hook": { + "version": "2.2.3", + "resolved": "https://registry.npmjs.org/before-after-hook/-/before-after-hook-2.2.3.tgz", + "integrity": "sha512-NzUnlZexiaH/46WDhANlyR2bXRopNg4F/zuSA3OpZnllCUgRaOF2znDioDWrmbNVsuZk6l9pMquQB38cfBZwkQ==" + }, + "node_modules/bindings": { + "version": "1.3.1", + "resolved": "https://registry.npmjs.org/bindings/-/bindings-1.3.1.tgz", + "integrity": "sha512-i47mqjF9UbjxJhxGf+pZ6kSxrnI3wBLlnGI2ArWJ4r0VrvDS7ZYXkprq/pLaBWYq4GM0r4zdHY+NNRqEMU7uew==" + }, + "node_modules/boolbase": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/boolbase/-/boolbase-1.0.0.tgz", + "integrity": "sha512-JZOSA7Mo9sNGB8+UjSgzdLtokWAky1zbztM3WRLCbZ70/3cTANmQmOdR7y2g+J0e2WXywy1yS468tY+IruqEww==", + "dev": true + }, + "node_modules/bottleneck": { + "version": "2.19.5", + "resolved": "https://registry.npmjs.org/bottleneck/-/bottleneck-2.19.5.tgz", + "integrity": "sha512-VHiNCbI1lKdl44tGrhNfU3lup0Tj/ZBMJB5/2ZbNXRCPuRCO7ed2mgcK4r17y+KB2EfuYuRaVlwNbAeaWGSpbw==" + }, + "node_modules/brace-expansion": { + "version": "1.1.11", + "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.11.tgz", + "integrity": "sha512-iCuPHDFgrHX7H2vEI/5xpz07zSHB00TpugqhmYtVmMO6518mCuRMoOYFldEBl0g187ufozdaHgWKcYFb61qGiA==", + "dependencies": { + "balanced-match": "^1.0.0", + "concat-map": "0.0.1" + } + }, + "node_modules/braces": { + "version": "3.0.2", + "resolved": "https://registry.npmjs.org/braces/-/braces-3.0.2.tgz", + "integrity": "sha512-b8um+L1RzM3WDSzvhm6gIz1yfTbBt6YTlcEKAvsmqCZZFw46z626lVj9j1yEPW33H5H+lBQpZMP1k8l+78Ha0A==", + "dev": true, + "dependencies": { + "fill-range": "^7.0.1" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/browserslist": { + "version": "4.21.5", + "resolved": "https://registry.npmjs.org/browserslist/-/browserslist-4.21.5.tgz", + "integrity": "sha512-tUkiguQGW7S3IhB7N+c2MV/HZPSCPAAiYBZXLsBhFB/PCy6ZKKsZrmBayHV9fdGV/ARIfJ14NkxKzRDjvp7L6w==", + "dev": true, + "funding": [ + { + "type": "opencollective", + "url": "https://opencollective.com/browserslist" + }, + { + "type": "tidelift", + "url": "https://tidelift.com/funding/github/npm/browserslist" + } + ], + "dependencies": { + "caniuse-lite": "^1.0.30001449", + "electron-to-chromium": "^1.4.284", + "node-releases": "^2.0.8", + "update-browserslist-db": "^1.0.10" + }, + "bin": { + "browserslist": "cli.js" + }, + "engines": { + "node": "^6 || ^7 || ^8 || ^9 || ^10 || ^11 || ^12 || >=13.7" + } + }, + "node_modules/bser": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/bser/-/bser-2.1.1.tgz", + "integrity": "sha512-gQxTNE/GAfIIrmHLUE3oJyp5FO6HRBfhjnw4/wMmA63ZGDJnWBmgY/lyQBpnDUkGmAhbSe39tx2d/iTOAfglwQ==", + "dev": true, + "dependencies": { + "node-int64": "^0.4.0" + } + }, + "node_modules/buffer-from": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/buffer-from/-/buffer-from-1.1.2.tgz", + "integrity": "sha512-E+XQCRwSbaaiChtv6k6Dwgc+bx+Bs6vuKJHHl5kox/BaKbhiXzqQOwK4cO22yElGp2OCmjwVhT3HmxgyPGnJfQ==", + "dev": true + }, + "node_modules/call-bind": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/call-bind/-/call-bind-1.0.2.tgz", + "integrity": "sha512-7O+FbCihrB5WGbFYesctwmTKae6rOiIzmz1icreWJ+0aA7LJfuqhEso2T9ncpcFtzMQtzXf2QGGueWJGTYsqrA==", + "dev": true, + "dependencies": { + "function-bind": "^1.1.1", + "get-intrinsic": "^1.0.2" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/callsites": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/callsites/-/callsites-3.1.0.tgz", + "integrity": "sha512-P8BjAsXvZS+VIDUI11hHCQEv74YT67YUi5JJFNWIqL235sBmjX4+qx9Muvls5ivyNENctx46xQLQ3aTuE7ssaQ==", + "dev": true, + "engines": { + "node": ">=6" + } + }, + "node_modules/camelcase": { + "version": "5.3.1", + "resolved": "https://registry.npmjs.org/camelcase/-/camelcase-5.3.1.tgz", + "integrity": "sha512-L28STB170nwWS63UjtlEOE3dldQApaJXZkOI1uMFfzf3rRuPegHaHesyee+YxQ+W6SvRDQV6UrdOdRiR153wJg==", + "dev": true, + "engines": { + "node": ">=6" + } + }, + "node_modules/caniuse-lite": { + "version": "1.0.30001462", + "resolved": "https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30001462.tgz", + "integrity": "sha512-PDd20WuOBPiasZ7KbFnmQRyuLE7cFXW2PVd7dmALzbkUXEP46upAuCDm9eY9vho8fgNMGmbAX92QBZHzcnWIqw==", + "dev": true, + "funding": [ + { + "type": "opencollective", + "url": "https://opencollective.com/browserslist" + }, + { + "type": "tidelift", + "url": "https://tidelift.com/funding/github/npm/caniuse-lite" + } + ] + }, + "node_modules/chalk": { + "version": "4.1.2", + "resolved": "https://registry.npmjs.org/chalk/-/chalk-4.1.2.tgz", + "integrity": "sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==", + "dev": true, + "dependencies": { + "ansi-styles": "^4.1.0", + "supports-color": "^7.1.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/chalk/chalk?sponsor=1" + } + }, + "node_modules/char-regex": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/char-regex/-/char-regex-1.0.2.tgz", + "integrity": "sha512-kWWXztvZ5SBQV+eRgKFeh8q5sLuZY2+8WUIzlxWVTg+oGwY14qylx1KbKzHd8P6ZYkAg0xyIDU9JMHhyJMZ1jw==", + "dev": true, + "engines": { + "node": ">=10" + } + }, + "node_modules/cheerio": { + "version": "1.0.0-rc.12", + "resolved": "https://registry.npmjs.org/cheerio/-/cheerio-1.0.0-rc.12.tgz", + "integrity": "sha512-VqR8m68vM46BNnuZ5NtnGBKIE/DfN0cRIzg9n40EIq9NOv90ayxLBXA8fXC5gquFRGJSTRqBq25Jt2ECLR431Q==", + "dev": true, + "dependencies": { + "cheerio-select": "^2.1.0", + "dom-serializer": "^2.0.0", + "domhandler": "^5.0.3", + "domutils": "^3.0.1", + "htmlparser2": "^8.0.1", + "parse5": "^7.0.0", + "parse5-htmlparser2-tree-adapter": "^7.0.0" + }, + "engines": { + "node": ">= 6" + }, + "funding": { + "url": "https://github.com/cheeriojs/cheerio?sponsor=1" + } + }, + "node_modules/cheerio-select": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/cheerio-select/-/cheerio-select-2.1.0.tgz", + "integrity": "sha512-9v9kG0LvzrlcungtnJtpGNxY+fzECQKhK4EGJX2vByejiMX84MFNQw4UxPJl3bFbTMw+Dfs37XaIkCwTZfLh4g==", + "dev": true, + "dependencies": { + "boolbase": "^1.0.0", + "css-select": "^5.1.0", + "css-what": "^6.1.0", + "domelementtype": "^2.3.0", + "domhandler": "^5.0.3", + "domutils": "^3.0.1" + }, + "funding": { + "url": "https://github.com/sponsors/fb55" + } + }, + "node_modules/chownr": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/chownr/-/chownr-2.0.0.tgz", + "integrity": "sha512-bIomtDF5KGpdogkLd9VspvFzk9KfpyyGlS8YFVZl7TGPBHL5snIOnxeshwVgPteQ9b4Eydl+pVbIyE1DcvCWgQ==", + "engines": { + "node": ">=10" + } + }, + "node_modules/ci-info": { + "version": "3.8.0", + "resolved": "https://registry.npmjs.org/ci-info/-/ci-info-3.8.0.tgz", + "integrity": "sha512-eXTggHWSooYhq49F2opQhuHWgzucfF2YgODK4e1566GQs5BIfP30B0oenwBJHfWxAs2fyPB1s7Mg949zLf61Yw==", + "dev": true, + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/sibiraj-s" + } + ], + "engines": { + "node": ">=8" + } + }, + "node_modules/cjs-module-lexer": { + "version": "1.2.2", + "resolved": "https://registry.npmjs.org/cjs-module-lexer/-/cjs-module-lexer-1.2.2.tgz", + "integrity": "sha512-cOU9usZw8/dXIXKtwa8pM0OTJQuJkxMN6w30csNRUerHfeQ5R6U3kkU/FtJeIf3M202OHfY2U8ccInBG7/xogA==", + "dev": true + }, + "node_modules/cliui": { + "version": "8.0.1", + "resolved": "https://registry.npmjs.org/cliui/-/cliui-8.0.1.tgz", + "integrity": "sha512-BSeNnyus75C4//NQ9gQt1/csTXyo/8Sb+afLAkzAptFuMsod9HFokGNudZpi/oQV73hnVK+sR+5PVRMd+Dr7YQ==", + "dev": true, + "dependencies": { + "string-width": "^4.2.0", + "strip-ansi": "^6.0.1", + "wrap-ansi": "^7.0.0" + }, + "engines": { + "node": ">=12" + } + }, + "node_modules/co": { + "version": "4.6.0", + "resolved": "https://registry.npmjs.org/co/-/co-4.6.0.tgz", + "integrity": "sha512-QVb0dM5HvG+uaxitm8wONl7jltx8dqhfU33DcqtOZcLSVIKSDDLDi7+0LbAKiyI8hD9u42m2YxXSkMGWThaecQ==", + "dev": true, + "engines": { + "iojs": ">= 1.0.0", + "node": ">= 0.12.0" + } + }, + "node_modules/collect-v8-coverage": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/collect-v8-coverage/-/collect-v8-coverage-1.0.1.tgz", + "integrity": "sha512-iBPtljfCNcTKNAto0KEtDfZ3qzjJvqE3aTGZsbhjSBlorqpXJlaWWtPO35D+ZImoC3KWejX64o+yPGxhWSTzfg==", + "dev": true + }, + "node_modules/color-convert": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz", + "integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==", + "dev": true, + "dependencies": { + "color-name": "~1.1.4" + }, + "engines": { + "node": ">=7.0.0" + } + }, + "node_modules/color-name": { + "version": "1.1.4", + "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz", + "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==", + "dev": true + }, + "node_modules/color-support": { + "version": "1.1.3", + "resolved": "https://registry.npmjs.org/color-support/-/color-support-1.1.3.tgz", + "integrity": "sha512-qiBjkpbMLO/HL68y+lh4q0/O1MZFj2RX6X/KmMa3+gJD3z+WwI1ZzDHysvqHGS3mP6mznPckpXmw1nI9cJjyRg==", + "bin": { + "color-support": "bin.js" + } + }, + "node_modules/colors": { + "version": "1.4.0", + "resolved": "https://registry.npmjs.org/colors/-/colors-1.4.0.tgz", + "integrity": "sha512-a+UqTh4kgZg/SlGvfbzDHpgRu7AAQOmmqRHJnxhRZICKFUT91brVhNNt58CMWU9PsBbv3PDCZUHbVxuDiH2mtA==", + "dev": true, + "engines": { + "node": ">=0.1.90" + } + }, + "node_modules/commander": { + "version": "2.20.3", + "resolved": "https://registry.npmjs.org/commander/-/commander-2.20.3.tgz", + "integrity": "sha512-GpVkmM8vF2vQUkj2LvZmD35JxeJOLCwJ9cUkugyk2nuhbv3+mJvpLYYt+0+USMxE+oj+ey/lJEnhZw75x/OMcQ==", + "dev": true + }, + "node_modules/concat-map": { + "version": "0.0.1", + "resolved": "https://registry.npmjs.org/concat-map/-/concat-map-0.0.1.tgz", + "integrity": "sha512-/Srv4dswyQNBfohGpz9o6Yb3Gz3SrUDqBH5rTuhGR7ahtlbYKnVxw2bCFMRljaA7EXHaXZ8wsHdodFvbkhKmqg==" + }, + "node_modules/console-control-strings": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/console-control-strings/-/console-control-strings-1.1.0.tgz", + "integrity": "sha512-ty/fTekppD2fIwRvnZAVdeOiGd1c7YXEixbgJTNzqcxJWKQnjJ/V1bNEEE6hygpM3WjwHFUVK6HTjWSzV4a8sQ==" + }, + "node_modules/convert-source-map": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/convert-source-map/-/convert-source-map-2.0.0.tgz", + "integrity": "sha512-Kvp459HrV2FEJ1CAsi1Ku+MY3kasH19TFykTz2xWmMeq6bk2NU3XXvfJ+Q61m0xktWwt+1HSYf3JZsTms3aRJg==", + "dev": true + }, + "node_modules/cross-spawn": { + "version": "7.0.3", + "resolved": "https://registry.npmjs.org/cross-spawn/-/cross-spawn-7.0.3.tgz", + "integrity": "sha512-iRDPJKUPVEND7dHPO8rkbOnPpyDygcDFtWjpeWNCgy8WP2rXcxXL8TskReQl6OrB2G7+UJrags1q15Fudc7G6w==", + "dev": true, + "dependencies": { + "path-key": "^3.1.0", + "shebang-command": "^2.0.0", + "which": "^2.0.1" + }, + "engines": { + "node": ">= 8" + } + }, + "node_modules/css-select": { + "version": "5.1.0", + "resolved": "https://registry.npmjs.org/css-select/-/css-select-5.1.0.tgz", + "integrity": "sha512-nwoRF1rvRRnnCqqY7updORDsuqKzqYJ28+oSMaJMMgOauh3fvwHqMS7EZpIPqK8GL+g9mKxF1vP/ZjSeNjEVHg==", + "dev": true, + "dependencies": { + "boolbase": "^1.0.0", + "css-what": "^6.1.0", + "domhandler": "^5.0.2", + "domutils": "^3.0.1", + "nth-check": "^2.0.1" + }, + "funding": { + "url": "https://github.com/sponsors/fb55" + } + }, + "node_modules/css-what": { + "version": "6.1.0", + "resolved": "https://registry.npmjs.org/css-what/-/css-what-6.1.0.tgz", + "integrity": "sha512-HTUrgRJ7r4dsZKU6GjmpfRK1O76h97Z8MfS1G0FozR+oF2kG6Vfe8JE6zwrkbxigziPHinCJ+gCPjA9EaBDtRw==", + "dev": true, + "engines": { + "node": ">= 6" + }, + "funding": { + "url": "https://github.com/sponsors/fb55" + } + }, + "node_modules/debug": { + "version": "4.3.4", + "resolved": "https://registry.npmjs.org/debug/-/debug-4.3.4.tgz", + "integrity": "sha512-PRWFHuSU3eDtQJPvnNY7Jcket1j0t5OuOsFzPPzsekD52Zl8qUfFIPEiswXqIvHWGVHOgX+7G/vCNNhehwxfkQ==", + "dependencies": { + "ms": "2.1.2" + }, + "engines": { + "node": ">=6.0" + }, + "peerDependenciesMeta": { + "supports-color": { + "optional": true + } + } + }, + "node_modules/dedent": { + "version": "0.7.0", + "resolved": "https://registry.npmjs.org/dedent/-/dedent-0.7.0.tgz", + "integrity": "sha512-Q6fKUPqnAHAyhiUgFU7BUzLiv0kd8saH9al7tnu5Q/okj6dnupxyTgFIBjVzJATdfIAm9NAsvXNzjaKa+bxVyA==", + "dev": true + }, + "node_modules/deep-is": { + "version": "0.1.4", + "resolved": "https://registry.npmjs.org/deep-is/-/deep-is-0.1.4.tgz", + "integrity": "sha512-oIPzksmTg4/MriiaYGO+okXDT7ztn/w3Eptv/+gSIdMdKsJo0u4CfYNFJPy+4SKMuCqGw2wxnA+URMg3t8a/bQ==", + "dev": true + }, + "node_modules/deepmerge": { + "version": "4.3.0", + "resolved": "https://registry.npmjs.org/deepmerge/-/deepmerge-4.3.0.tgz", + "integrity": "sha512-z2wJZXrmeHdvYJp/Ux55wIjqo81G5Bp4c+oELTW+7ar6SogWHajt5a9gO3s3IDaGSAXjDk0vlQKN3rms8ab3og==", + "dev": true, + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/define-properties": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/define-properties/-/define-properties-1.2.0.tgz", + "integrity": "sha512-xvqAVKGfT1+UAvPwKTVw/njhdQ8ZhXK4lI0bCIuCMrp2up9nPnaDftrLtmpTazqd1o+UY4zgzU+avtMbDP+ldA==", + "dev": true, + "dependencies": { + "has-property-descriptors": "^1.0.0", + "object-keys": "^1.1.1" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/delegates": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/delegates/-/delegates-1.0.0.tgz", + "integrity": "sha512-bd2L678uiWATM6m5Z1VzNCErI3jiGzt6HGY8OVICs40JQq/HALfbyNJmp0UDakEY4pMMaN0Ly5om/B1VI/+xfQ==" + }, + "node_modules/deprecation": { + "version": "2.3.1", + "resolved": "https://registry.npmjs.org/deprecation/-/deprecation-2.3.1.tgz", + "integrity": "sha512-xmHIy4F3scKVwMsQ4WnVaS8bHOx0DmVwRywosKhaILI0ywMDWPtBSku2HNxRvF7jtwDRsoEwYQSfbxj8b7RlJQ==" + }, + "node_modules/detect-libc": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/detect-libc/-/detect-libc-2.0.1.tgz", + "integrity": "sha512-463v3ZeIrcWtdgIg6vI6XUncguvr2TnGl4SzDXinkt9mSLpBJKXT3mW6xT3VQdDN11+WVs29pgvivTc4Lp8v+w==", + "engines": { + "node": ">=8" + } + }, + "node_modules/detect-newline": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/detect-newline/-/detect-newline-3.1.0.tgz", + "integrity": "sha512-TLz+x/vEXm/Y7P7wn1EJFNLxYpUD4TgMosxY6fAVJUnJMbupHBOncxyWUG9OpTaH9EBD7uFI5LfEgmMOc54DsA==", + "dev": true, + "engines": { + "node": ">=8" + } + }, + "node_modules/diff-sequences": { + "version": "29.4.3", + "resolved": "https://registry.npmjs.org/diff-sequences/-/diff-sequences-29.4.3.tgz", + "integrity": "sha512-ofrBgwpPhCD85kMKtE9RYFFq6OC1A89oW2vvgWZNCwxrUpRUILopY7lsYyMDSjc8g6U6aiO0Qubg6r4Wgt5ZnA==", + "dev": true, + "engines": { + "node": "^14.15.0 || ^16.10.0 || >=18.0.0" + } + }, + "node_modules/discontinuous-range": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/discontinuous-range/-/discontinuous-range-1.0.0.tgz", + "integrity": "sha512-c68LpLbO+7kP/b1Hr1qs8/BJ09F5khZGTxqxZuhzxpmwJKOgRFHJWIb9/KmqnqHhLdO55aOxFH/EGBvUQbL/RQ==", + "dev": true + }, + "node_modules/doctrine": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/doctrine/-/doctrine-3.0.0.tgz", + "integrity": "sha512-yS+Q5i3hBf7GBkd4KG8a7eBNNWNGLTaEwwYWUijIYM7zrlYDM0BFXHjjPWlWZ1Rg7UaddZeIDmi9jF3HmqiQ2w==", + "dev": true, + "dependencies": { + "esutils": "^2.0.2" + }, + "engines": { + "node": ">=6.0.0" + } + }, + "node_modules/dom-serializer": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/dom-serializer/-/dom-serializer-2.0.0.tgz", + "integrity": "sha512-wIkAryiqt/nV5EQKqQpo3SToSOV9J0DnbJqwK7Wv/Trc92zIAYZ4FlMu+JPFW1DfGFt81ZTCGgDEabffXeLyJg==", + "dev": true, + "dependencies": { + "domelementtype": "^2.3.0", + "domhandler": "^5.0.2", + "entities": "^4.2.0" + }, + "funding": { + "url": "https://github.com/cheeriojs/dom-serializer?sponsor=1" + } + }, + "node_modules/domelementtype": { + "version": "2.3.0", + "resolved": "https://registry.npmjs.org/domelementtype/-/domelementtype-2.3.0.tgz", + "integrity": "sha512-OLETBj6w0OsagBwdXnPdN0cnMfF9opN69co+7ZrbfPGrdpPVNBUj02spi6B1N7wChLQiPn4CSH/zJvXw56gmHw==", + "dev": true, + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/fb55" + } + ] + }, + "node_modules/domhandler": { + "version": "5.0.3", + "resolved": "https://registry.npmjs.org/domhandler/-/domhandler-5.0.3.tgz", + "integrity": "sha512-cgwlv/1iFQiFnU96XXgROh8xTeetsnJiDsTc7TYCLFd9+/WNkIqPTxiM/8pSd8VIrhXGTf1Ny1q1hquVqDJB5w==", + "dev": true, + "dependencies": { + "domelementtype": "^2.3.0" + }, + "engines": { + "node": ">= 4" + }, + "funding": { + "url": "https://github.com/fb55/domhandler?sponsor=1" + } + }, + "node_modules/domutils": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/domutils/-/domutils-3.0.1.tgz", + "integrity": "sha512-z08c1l761iKhDFtfXO04C7kTdPBLi41zwOZl00WS8b5eiaebNpY00HKbztwBq+e3vyqWNwWF3mP9YLUeqIrF+Q==", + "dev": true, + "dependencies": { + "dom-serializer": "^2.0.0", + "domelementtype": "^2.3.0", + "domhandler": "^5.0.1" + }, + "funding": { + "url": "https://github.com/fb55/domutils?sponsor=1" + } + }, + "node_modules/dreamopt": { + "version": "0.8.0", + "resolved": "https://registry.npmjs.org/dreamopt/-/dreamopt-0.8.0.tgz", + "integrity": "sha512-vyJTp8+mC+G+5dfgsY+r3ckxlz+QMX40VjPQsZc5gxVAxLmi64TBoVkP54A/pRAXMXsbu2GMMBrZPxNv23waMg==", + "dev": true, + "dependencies": { + "wordwrap": ">=0.0.2" + }, + "engines": { + "node": ">=0.4.0" + } + }, + "node_modules/electron-to-chromium": { + "version": "1.4.322", + "resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.4.322.tgz", + "integrity": "sha512-KovjizNC9XB7dno/2GjxX8VS0SlfPpCjtyoKft+bCO+UfD8bFy16hY4Sh9s0h9BDxbRH2U0zX5VBjpM1LTcNlg==", + "dev": true + }, + "node_modules/emittery": { + "version": "0.13.1", + "resolved": "https://registry.npmjs.org/emittery/-/emittery-0.13.1.tgz", + "integrity": "sha512-DeWwawk6r5yR9jFgnDKYt4sLS0LmHJJi3ZOnb5/JdbYwj3nW+FxQnHIjhBKz8YLC7oRNPVM9NQ47I3CVx34eqQ==", + "dev": true, + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://github.com/sindresorhus/emittery?sponsor=1" + } + }, + "node_modules/emoji-regex": { + "version": "8.0.0", + "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz", + "integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==" + }, + "node_modules/entities": { + "version": "4.4.0", + "resolved": "https://registry.npmjs.org/entities/-/entities-4.4.0.tgz", + "integrity": "sha512-oYp7156SP8LkeGD0GF85ad1X9Ai79WtRsZ2gxJqtBuzH+98YUV6jkHEKlZkMbcrjJjIVJNIDP/3WL9wQkoPbWA==", + "dev": true, + "engines": { + "node": ">=0.12" + }, + "funding": { + "url": "https://github.com/fb55/entities?sponsor=1" + } + }, + "node_modules/enzyme": { + "version": "3.11.0", + "resolved": "https://registry.npmjs.org/enzyme/-/enzyme-3.11.0.tgz", + "integrity": "sha512-Dw8/Gs4vRjxY6/6i9wU0V+utmQO9kvh9XLnz3LIudviOnVYDEe2ec+0k+NQoMamn1VrjKgCUOWj5jG/5M5M0Qw==", + "dev": true, + "dependencies": { + "array.prototype.flat": "^1.2.3", + "cheerio": "^1.0.0-rc.3", + "enzyme-shallow-equal": "^1.0.1", + "function.prototype.name": "^1.1.2", + "has": "^1.0.3", + "html-element-map": "^1.2.0", + "is-boolean-object": "^1.0.1", + "is-callable": "^1.1.5", + "is-number-object": "^1.0.4", + "is-regex": "^1.0.5", + "is-string": "^1.0.5", + "is-subset": "^0.1.1", + "lodash.escape": "^4.0.1", + "lodash.isequal": "^4.5.0", + "object-inspect": "^1.7.0", + "object-is": "^1.0.2", + "object.assign": "^4.1.0", + "object.entries": "^1.1.1", + "object.values": "^1.1.1", + "raf": "^3.4.1", + "rst-selector-parser": "^2.2.3", + "string.prototype.trim": "^1.2.1" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/enzyme-shallow-equal": { + "version": "1.0.5", + "resolved": "https://registry.npmjs.org/enzyme-shallow-equal/-/enzyme-shallow-equal-1.0.5.tgz", + "integrity": "sha512-i6cwm7hN630JXenxxJFBKzgLC3hMTafFQXflvzHgPmDhOBhxUWDe8AeRv1qp2/uWJ2Y8z5yLWMzmAfkTOiOCZg==", + "dev": true, + "dependencies": { + "has": "^1.0.3", + "object-is": "^1.1.5" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/error-ex": { + "version": "1.3.2", + "resolved": "https://registry.npmjs.org/error-ex/-/error-ex-1.3.2.tgz", + "integrity": "sha512-7dFHNmqeFSEt2ZBsCriorKnn3Z2pj+fd9kmI6QoWw4//DL+icEBfc0U7qJCisqrTsKTjw4fNFy2pW9OqStD84g==", + "dev": true, + "dependencies": { + "is-arrayish": "^0.2.1" + } + }, + "node_modules/es-abstract": { + "version": "1.21.1", + "resolved": "https://registry.npmjs.org/es-abstract/-/es-abstract-1.21.1.tgz", + "integrity": "sha512-QudMsPOz86xYz/1dG1OuGBKOELjCh99IIWHLzy5znUB6j8xG2yMA7bfTV86VSqKF+Y/H08vQPR+9jyXpuC6hfg==", + "dev": true, + "dependencies": { + "available-typed-arrays": "^1.0.5", + "call-bind": "^1.0.2", + "es-set-tostringtag": "^2.0.1", + "es-to-primitive": "^1.2.1", + "function-bind": "^1.1.1", + "function.prototype.name": "^1.1.5", + "get-intrinsic": "^1.1.3", + "get-symbol-description": "^1.0.0", + "globalthis": "^1.0.3", + "gopd": "^1.0.1", + "has": "^1.0.3", + "has-property-descriptors": "^1.0.0", + "has-proto": "^1.0.1", + "has-symbols": "^1.0.3", + "internal-slot": "^1.0.4", + "is-array-buffer": "^3.0.1", + "is-callable": "^1.2.7", + "is-negative-zero": "^2.0.2", + "is-regex": "^1.1.4", + "is-shared-array-buffer": "^1.0.2", + "is-string": "^1.0.7", + "is-typed-array": "^1.1.10", + "is-weakref": "^1.0.2", + "object-inspect": "^1.12.2", + "object-keys": "^1.1.1", + "object.assign": "^4.1.4", + "regexp.prototype.flags": "^1.4.3", + "safe-regex-test": "^1.0.0", + "string.prototype.trimend": "^1.0.6", + "string.prototype.trimstart": "^1.0.6", + "typed-array-length": "^1.0.4", + "unbox-primitive": "^1.0.2", + "which-typed-array": "^1.1.9" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/es-array-method-boxes-properly": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/es-array-method-boxes-properly/-/es-array-method-boxes-properly-1.0.0.tgz", + "integrity": "sha512-wd6JXUmyHmt8T5a2xreUwKcGPq6f1f+WwIJkijUqiGcJz1qqnZgP6XIK+QyIWU5lT7imeNxUll48bziG+TSYcA==", + "dev": true + }, + "node_modules/es-set-tostringtag": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/es-set-tostringtag/-/es-set-tostringtag-2.0.1.tgz", + "integrity": "sha512-g3OMbtlwY3QewlqAiMLI47KywjWZoEytKr8pf6iTC8uJq5bIAH52Z9pnQ8pVL6whrCto53JZDuUIsifGeLorTg==", + "dev": true, + "dependencies": { + "get-intrinsic": "^1.1.3", + "has": "^1.0.3", + "has-tostringtag": "^1.0.0" + }, + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/es-shim-unscopables": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/es-shim-unscopables/-/es-shim-unscopables-1.0.0.tgz", + "integrity": "sha512-Jm6GPcCdC30eMLbZ2x8z2WuRwAws3zTBBKuusffYVUrNj/GVSUAZ+xKMaUpfNDR5IbyNA5LJbaecoUVbmUcB1w==", + "dev": true, + "dependencies": { + "has": "^1.0.3" + } + }, + "node_modules/es-to-primitive": { + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/es-to-primitive/-/es-to-primitive-1.2.1.tgz", + "integrity": "sha512-QCOllgZJtaUo9miYBcLChTUaHNjJF3PYs1VidD7AwiEj1kYxKeQTctLAezAOH5ZKRH0g2IgPn6KwB4IT8iRpvA==", + "dev": true, + "dependencies": { + "is-callable": "^1.1.4", + "is-date-object": "^1.0.1", + "is-symbol": "^1.0.2" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/escalade": { + "version": "3.1.1", + "resolved": "https://registry.npmjs.org/escalade/-/escalade-3.1.1.tgz", + "integrity": "sha512-k0er2gUkLf8O0zKJiAhmkTnJlTvINGv7ygDNPbeIsX/TJjGJZHuh9B2UxbsaEkmlEo9MfhrSzmhIlhRlI2GXnw==", + "dev": true, + "engines": { + "node": ">=6" + } + }, + "node_modules/escape-string-regexp": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-4.0.0.tgz", + "integrity": "sha512-TtpcNJ3XAzx3Gq8sWRzJaVajRs0uVxA2YAkdb1jm2YkPz4G6egUFAyA3n5vtEIZefPk5Wa4UXbKuS5fKkJWdgA==", + "dev": true, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/eslint": { + "version": "8.33.0", + "resolved": "https://registry.npmjs.org/eslint/-/eslint-8.33.0.tgz", + "integrity": "sha512-WjOpFQgKK8VrCnAtl8We0SUOy/oVZ5NHykyMiagV1M9r8IFpIJX7DduK6n1mpfhlG7T1NLWm2SuD8QB7KFySaA==", + "dev": true, + "dependencies": { + "@eslint/eslintrc": "^1.4.1", + "@humanwhocodes/config-array": "^0.11.8", + "@humanwhocodes/module-importer": "^1.0.1", + "@nodelib/fs.walk": "^1.2.8", + "ajv": "^6.10.0", + "chalk": "^4.0.0", + "cross-spawn": "^7.0.2", + "debug": "^4.3.2", + "doctrine": "^3.0.0", + "escape-string-regexp": "^4.0.0", + "eslint-scope": "^7.1.1", + "eslint-utils": "^3.0.0", + "eslint-visitor-keys": "^3.3.0", + "espree": "^9.4.0", + "esquery": "^1.4.0", + "esutils": "^2.0.2", + "fast-deep-equal": "^3.1.3", + "file-entry-cache": "^6.0.1", + "find-up": "^5.0.0", + "glob-parent": "^6.0.2", + "globals": "^13.19.0", + "grapheme-splitter": "^1.0.4", + "ignore": "^5.2.0", + "import-fresh": "^3.0.0", + "imurmurhash": "^0.1.4", + "is-glob": "^4.0.0", + "is-path-inside": "^3.0.3", + "js-sdsl": "^4.1.4", + "js-yaml": "^4.1.0", + "json-stable-stringify-without-jsonify": "^1.0.1", + "levn": "^0.4.1", + "lodash.merge": "^4.6.2", + "minimatch": "^3.1.2", + "natural-compare": "^1.4.0", + "optionator": "^0.9.1", + "regexpp": "^3.2.0", + "strip-ansi": "^6.0.1", + "strip-json-comments": "^3.1.0", + "text-table": "^0.2.0" + }, + "bin": { + "eslint": "bin/eslint.js" + }, + "engines": { + "node": "^12.22.0 || ^14.17.0 || >=16.0.0" + }, + "funding": { + "url": "https://opencollective.com/eslint" + } + }, + "node_modules/eslint-scope": { + "version": "7.1.1", + "resolved": "https://registry.npmjs.org/eslint-scope/-/eslint-scope-7.1.1.tgz", + "integrity": "sha512-QKQM/UXpIiHcLqJ5AOyIW7XZmzjkzQXYE54n1++wb0u9V/abW3l9uQnxX8Z5Xd18xyKIMTUAyQ0k1e8pz6LUrw==", + "dev": true, + "dependencies": { + "esrecurse": "^4.3.0", + "estraverse": "^5.2.0" + }, + "engines": { + "node": "^12.22.0 || ^14.17.0 || >=16.0.0" + } + }, + "node_modules/eslint-utils": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/eslint-utils/-/eslint-utils-3.0.0.tgz", + "integrity": "sha512-uuQC43IGctw68pJA1RgbQS8/NP7rch6Cwd4j3ZBtgo4/8Flj4eGE7ZYSZRN3iq5pVUv6GPdW5Z1RFleo84uLDA==", + "dev": true, + "dependencies": { + "eslint-visitor-keys": "^2.0.0" + }, + "engines": { + "node": "^10.0.0 || ^12.0.0 || >= 14.0.0" + }, + "funding": { + "url": "https://github.com/sponsors/mysticatea" + }, + "peerDependencies": { + "eslint": ">=5" + } + }, + "node_modules/eslint-utils/node_modules/eslint-visitor-keys": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/eslint-visitor-keys/-/eslint-visitor-keys-2.1.0.tgz", + "integrity": "sha512-0rSmRBzXgDzIsD6mGdJgevzgezI534Cer5L/vyMX0kHzT/jiB43jRhd9YUlMGYLQy2zprNmoT8qasCGtY+QaKw==", + "dev": true, + "engines": { + "node": ">=10" + } + }, + "node_modules/eslint-visitor-keys": { + "version": "3.3.0", + "resolved": "https://registry.npmjs.org/eslint-visitor-keys/-/eslint-visitor-keys-3.3.0.tgz", + "integrity": "sha512-mQ+suqKJVyeuwGYHAdjMFqjCyfl8+Ldnxuyp3ldiMBFKkvytrXUZWaiPCEav8qDHKty44bD+qV1IP4T+w+xXRA==", + "dev": true, + "engines": { + "node": "^12.22.0 || ^14.17.0 || >=16.0.0" + } + }, + "node_modules/espree": { + "version": "9.4.1", + "resolved": "https://registry.npmjs.org/espree/-/espree-9.4.1.tgz", + "integrity": "sha512-XwctdmTO6SIvCzd9810yyNzIrOrqNYV9Koizx4C/mRhf9uq0o4yHoCEU/670pOxOL/MSraektvSAji79kX90Vg==", + "dev": true, + "dependencies": { + "acorn": "^8.8.0", + "acorn-jsx": "^5.3.2", + "eslint-visitor-keys": "^3.3.0" + }, + "engines": { + "node": "^12.22.0 || ^14.17.0 || >=16.0.0" + }, + "funding": { + "url": "https://opencollective.com/eslint" + } + }, + "node_modules/esprima": { + "version": "4.0.1", + "resolved": "https://registry.npmjs.org/esprima/-/esprima-4.0.1.tgz", + "integrity": "sha512-eGuFFw7Upda+g4p+QHvnW0RyTX/SVeJBDM/gCtMARO0cLuT2HcEKnTPvhjV6aGeqrCB/sbNop0Kszm0jsaWU4A==", + "dev": true, + "bin": { + "esparse": "bin/esparse.js", + "esvalidate": "bin/esvalidate.js" + }, + "engines": { + "node": ">=4" + } + }, + "node_modules/esquery": { + "version": "1.5.0", + "resolved": "https://registry.npmjs.org/esquery/-/esquery-1.5.0.tgz", + "integrity": "sha512-YQLXUplAwJgCydQ78IMJywZCceoqk1oH01OERdSAJc/7U2AylwjhSCLDEtqwg811idIS/9fIU5GjG73IgjKMVg==", + "dev": true, + "dependencies": { + "estraverse": "^5.1.0" + }, + "engines": { + "node": ">=0.10" + } + }, + "node_modules/esrecurse": { + "version": "4.3.0", + "resolved": "https://registry.npmjs.org/esrecurse/-/esrecurse-4.3.0.tgz", + "integrity": "sha512-KmfKL3b6G+RXvP8N1vr3Tq1kL/oCFgn2NYXEtqP8/L3pKapUA4G8cFVaoF3SU323CD4XypR/ffioHmkti6/Tag==", + "dev": true, + "dependencies": { + "estraverse": "^5.2.0" + }, + "engines": { + "node": ">=4.0" + } + }, + "node_modules/estraverse": { + "version": "5.3.0", + "resolved": "https://registry.npmjs.org/estraverse/-/estraverse-5.3.0.tgz", + "integrity": "sha512-MMdARuVEQziNTeJD8DgMqmhwR11BRQ/cBP+pLtYdSTnf3MIO8fFeiINEbX36ZdNlfU/7A9f3gUw49B3oQsvwBA==", + "dev": true, + "engines": { + "node": ">=4.0" + } + }, + "node_modules/esutils": { + "version": "2.0.3", + "resolved": "https://registry.npmjs.org/esutils/-/esutils-2.0.3.tgz", + "integrity": "sha512-kVscqXk4OCp68SZ0dkgEKVi6/8ij300KBWTJq32P/dYeWTSwK41WyTxalN1eRmA5Z9UU/LX9D7FWSmV9SAYx6g==", + "dev": true, + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/execa": { + "version": "5.1.1", + "resolved": "https://registry.npmjs.org/execa/-/execa-5.1.1.tgz", + "integrity": "sha512-8uSpZZocAZRBAPIEINJj3Lo9HyGitllczc27Eh5YYojjMFMn8yHMDMaUHE2Jqfq05D/wucwI4JGURyXt1vchyg==", + "dev": true, + "dependencies": { + "cross-spawn": "^7.0.3", + "get-stream": "^6.0.0", + "human-signals": "^2.1.0", + "is-stream": "^2.0.0", + "merge-stream": "^2.0.0", + "npm-run-path": "^4.0.1", + "onetime": "^5.1.2", + "signal-exit": "^3.0.3", + "strip-final-newline": "^2.0.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sindresorhus/execa?sponsor=1" + } + }, + "node_modules/exit": { + "version": "0.1.2", + "resolved": "https://registry.npmjs.org/exit/-/exit-0.1.2.tgz", + "integrity": "sha512-Zk/eNKV2zbjpKzrsQ+n1G6poVbErQxJ0LBOJXaKZ1EViLzH+hrLu9cdXI4zw9dBQJslwBEpbQ2P1oS7nDxs6jQ==", + "dev": true, + "engines": { + "node": ">= 0.8.0" + } + }, + "node_modules/expect": { + "version": "29.5.0", + "resolved": "https://registry.npmjs.org/expect/-/expect-29.5.0.tgz", + "integrity": "sha512-yM7xqUrCO2JdpFo4XpM82t+PJBFybdqoQuJLDGeDX2ij8NZzqRHyu3Hp188/JX7SWqud+7t4MUdvcgGBICMHZg==", + "dev": true, + "dependencies": { + "@jest/expect-utils": "^29.5.0", + "jest-get-type": "^29.4.3", + "jest-matcher-utils": "^29.5.0", + "jest-message-util": "^29.5.0", + "jest-util": "^29.5.0" + }, + "engines": { + "node": "^14.15.0 || ^16.10.0 || >=18.0.0" + } + }, + "node_modules/fast-deep-equal": { + "version": "3.1.3", + "resolved": "https://registry.npmjs.org/fast-deep-equal/-/fast-deep-equal-3.1.3.tgz", + "integrity": "sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q==", + "dev": true + }, + "node_modules/fast-json-stable-stringify": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/fast-json-stable-stringify/-/fast-json-stable-stringify-2.1.0.tgz", + "integrity": "sha512-lhd/wF+Lk98HZoTCtlVraHtfh5XYijIjalXck7saUtuanSDyLMxnHhSXEDJqHxD7msR8D0uCmqlkwjCV8xvwHw==", + "dev": true + }, + "node_modules/fast-levenshtein": { + "version": "2.0.6", + "resolved": "https://registry.npmjs.org/fast-levenshtein/-/fast-levenshtein-2.0.6.tgz", + "integrity": "sha512-DCXu6Ifhqcks7TZKY3Hxp3y6qphY5SJZmrWMDrKcERSOXWQdMhU9Ig/PYrzyw/ul9jOIyh0N4M0tbC5hodg8dw==", + "dev": true + }, + "node_modules/fastq": { + "version": "1.15.0", + "resolved": "https://registry.npmjs.org/fastq/-/fastq-1.15.0.tgz", + "integrity": "sha512-wBrocU2LCXXa+lWBt8RoIRD89Fi8OdABODa/kEnyeyjS5aZO5/GNvI5sEINADqP/h8M29UHTHUb53sUu5Ihqdw==", + "dev": true, + "dependencies": { + "reusify": "^1.0.4" + } + }, + "node_modules/fb-watchman": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/fb-watchman/-/fb-watchman-2.0.2.tgz", + "integrity": "sha512-p5161BqbuCaSnB8jIbzQHOlpgsPmK5rJVDfDKO91Axs5NC1uu3HRQm6wt9cd9/+GtQQIO53JdGXXoyDpTAsgYA==", + "dev": true, + "dependencies": { + "bser": "2.1.1" + } + }, + "node_modules/file-entry-cache": { + "version": "6.0.1", + "resolved": "https://registry.npmjs.org/file-entry-cache/-/file-entry-cache-6.0.1.tgz", + "integrity": "sha512-7Gps/XWymbLk2QLYK4NzpMOrYjMhdIxXuIvy2QBsLE6ljuodKvdkWs/cpyJJ3CVIVpH0Oi1Hvg1ovbMzLdFBBg==", + "dev": true, + "dependencies": { + "flat-cache": "^3.0.4" + }, + "engines": { + "node": "^10.12.0 || >=12.0.0" + } + }, + "node_modules/fill-range": { + "version": "7.0.1", + "resolved": "https://registry.npmjs.org/fill-range/-/fill-range-7.0.1.tgz", + "integrity": "sha512-qOo9F+dMUmC2Lcb4BbVvnKJxTPjCm+RRpe4gDuGrzkL7mEVl/djYSu2OdQ2Pa302N4oqkSg9ir6jaLWJ2USVpQ==", + "dev": true, + "dependencies": { + "to-regex-range": "^5.0.1" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/find-up": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/find-up/-/find-up-5.0.0.tgz", + "integrity": "sha512-78/PXT1wlLLDgTzDs7sjq9hzz0vXD+zn+7wypEe4fXQxCmdmqfGsEPQxmiCSQI3ajFV91bVSsvNtrJRiW6nGng==", + "dev": true, + "dependencies": { + "locate-path": "^6.0.0", + "path-exists": "^4.0.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/flat-cache": { + "version": "3.0.4", + "resolved": "https://registry.npmjs.org/flat-cache/-/flat-cache-3.0.4.tgz", + "integrity": "sha512-dm9s5Pw7Jc0GvMYbshN6zchCA9RgQlzzEZX3vylR9IqFfS8XciblUXOKfW6SiuJ0e13eDYZoZV5wdrev7P3Nwg==", + "dev": true, + "dependencies": { + "flatted": "^3.1.0", + "rimraf": "^3.0.2" + }, + "engines": { + "node": "^10.12.0 || >=12.0.0" + } + }, + "node_modules/flatted": { + "version": "3.2.7", + "resolved": "https://registry.npmjs.org/flatted/-/flatted-3.2.7.tgz", + "integrity": "sha512-5nqDSxl8nn5BSNxyR3n4I6eDmbolI6WT+QqR547RwxQapgjQBmtktdP+HTBb/a/zLsbzERTONyUB5pefh5TtjQ==", + "dev": true + }, + "node_modules/for-each": { + "version": "0.3.3", + "resolved": "https://registry.npmjs.org/for-each/-/for-each-0.3.3.tgz", + "integrity": "sha512-jqYfLp7mo9vIyQf8ykW2v7A+2N4QjeCeI5+Dz9XraiO1ign81wjiH7Fb9vSOWvQfNtmSa4H2RoQTrrXivdUZmw==", + "dev": true, + "dependencies": { + "is-callable": "^1.1.3" + } + }, + "node_modules/fs-minipass": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/fs-minipass/-/fs-minipass-2.1.0.tgz", + "integrity": "sha512-V/JgOLFCS+R6Vcq0slCuaeWEdNC3ouDlJMNIsacH2VtALiu9mV4LPrHc5cDl8k5aw6J8jwgWWpiTo5RYhmIzvg==", + "dependencies": { + "minipass": "^3.0.0" + }, + "engines": { + "node": ">= 8" + } + }, + "node_modules/fs-minipass/node_modules/minipass": { + "version": "3.3.6", + "resolved": "https://registry.npmjs.org/minipass/-/minipass-3.3.6.tgz", + "integrity": "sha512-DxiNidxSEK+tHG6zOIklvNOwm3hvCrbUrdtzY74U6HKTJxvIDfOUL5W5P2Ghd3DTkhhKPYGqeNUIh5qcM4YBfw==", + "dependencies": { + "yallist": "^4.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/fs-minipass/node_modules/yallist": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/yallist/-/yallist-4.0.0.tgz", + "integrity": "sha512-3wdGidZyq5PB084XLES5TpOSRA3wjXAlIWMhum2kRcv/41Sn2emQ0dycQW4uZXLejwKvg6EsvbdlVL+FYEct7A==" + }, + "node_modules/fs.realpath": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/fs.realpath/-/fs.realpath-1.0.0.tgz", + "integrity": "sha512-OO0pH2lK6a0hZnAdau5ItzHPI6pUlvI7jMVnxUQRtw4owF2wk8lOSabtGDCTP4Ggrg2MbGnWO9X8K1t4+fGMDw==" + }, + "node_modules/fsevents": { + "version": "2.3.2", + "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.2.tgz", + "integrity": "sha512-xiqMQR4xAeHTuB9uWm+fFRcIOgKBMiOBP+eXiyT7jsgVCq1bkVygt00oASowB7EdtpOHaaPgKt812P9ab+DDKA==", + "dev": true, + "hasInstallScript": true, + "optional": true, + "os": [ + "darwin" + ], + "engines": { + "node": "^8.16.0 || ^10.6.0 || >=11.0.0" + } + }, + "node_modules/function-bind": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/function-bind/-/function-bind-1.1.1.tgz", + "integrity": "sha512-yIovAzMX49sF8Yl58fSCWJ5svSLuaibPxXQJFLmBObTuCr0Mf1KiPopGM9NiFjiYBCbfaa2Fh6breQ6ANVTI0A==", + "dev": true + }, + "node_modules/function.prototype.name": { + "version": "1.1.5", + "resolved": "https://registry.npmjs.org/function.prototype.name/-/function.prototype.name-1.1.5.tgz", + "integrity": "sha512-uN7m/BzVKQnCUF/iW8jYea67v++2u7m5UgENbHRtdDVclOUP+FMPlCNdmk0h/ysGyo2tavMJEDqJAkJdRa1vMA==", + "dev": true, + "dependencies": { + "call-bind": "^1.0.2", + "define-properties": "^1.1.3", + "es-abstract": "^1.19.0", + "functions-have-names": "^1.2.2" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/functions-have-names": { + "version": "1.2.3", + "resolved": "https://registry.npmjs.org/functions-have-names/-/functions-have-names-1.2.3.tgz", + "integrity": "sha512-xckBUXyTIqT97tq2x2AMb+g163b5JFysYk0x4qxNFwbfQkmNZoiRHb6sPzI9/QV33WeuvVYBUIiD4NzNIyqaRQ==", + "dev": true, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/gauge": { + "version": "3.0.2", + "resolved": "https://registry.npmjs.org/gauge/-/gauge-3.0.2.tgz", + "integrity": "sha512-+5J6MS/5XksCuXq++uFRsnUd7Ovu1XenbeuIuNRJxYWjgQbPuFhT14lAvsWfqfAmnwluf1OwMjz39HjfLPci0Q==", + "dependencies": { + "aproba": "^1.0.3 || ^2.0.0", + "color-support": "^1.1.2", + "console-control-strings": "^1.0.0", + "has-unicode": "^2.0.1", + "object-assign": "^4.1.1", + "signal-exit": "^3.0.0", + "string-width": "^4.2.3", + "strip-ansi": "^6.0.1", + "wide-align": "^1.1.2" + }, + "engines": { + "node": ">=10" + } + }, + "node_modules/gensync": { + "version": "1.0.0-beta.2", + "resolved": "https://registry.npmjs.org/gensync/-/gensync-1.0.0-beta.2.tgz", + "integrity": "sha512-3hN7NaskYvMDLQY55gnW3NQ+mesEAepTqlg+VEbj7zzqEMBVNhzcGYYeqFo/TlYz6eQiFcp1HcsCZO+nGgS8zg==", + "dev": true, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/get-caller-file": { + "version": "2.0.5", + "resolved": "https://registry.npmjs.org/get-caller-file/-/get-caller-file-2.0.5.tgz", + "integrity": "sha512-DyFP3BM/3YHTQOCUL/w0OZHR0lpKeGrxotcHWcqNEdnltqFwXVfhEBQ94eIo34AfQpo0rGki4cyIiftY06h2Fg==", + "dev": true, + "engines": { + "node": "6.* || 8.* || >= 10.*" + } + }, + "node_modules/get-intrinsic": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/get-intrinsic/-/get-intrinsic-1.2.0.tgz", + "integrity": "sha512-L049y6nFOuom5wGyRc3/gdTLO94dySVKRACj1RmJZBQXlbTMhtNIgkWkUHq+jYmZvKf14EW1EoJnnjbmoHij0Q==", + "dev": true, + "dependencies": { + "function-bind": "^1.1.1", + "has": "^1.0.3", + "has-symbols": "^1.0.3" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/get-package-type": { + "version": "0.1.0", + "resolved": "https://registry.npmjs.org/get-package-type/-/get-package-type-0.1.0.tgz", + "integrity": "sha512-pjzuKtY64GYfWizNAJ0fr9VqttZkNiK2iS430LtIHzjBEr6bX8Am2zm4sW4Ro5wjWW5cAlRL1qAMTcXbjNAO2Q==", + "dev": true, + "engines": { + "node": ">=8.0.0" + } + }, + "node_modules/get-stream": { + "version": "6.0.1", + "resolved": "https://registry.npmjs.org/get-stream/-/get-stream-6.0.1.tgz", + "integrity": "sha512-ts6Wi+2j3jQjqi70w5AlN8DFnkSwC+MqmxEzdEALB2qXZYV3X/b1CTfgPLGJNMeAWxdPfU8FO1ms3NUfaHCPYg==", + "dev": true, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/get-symbol-description": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/get-symbol-description/-/get-symbol-description-1.0.0.tgz", + "integrity": "sha512-2EmdH1YvIQiZpltCNgkuiUnyukzxM/R6NDJX31Ke3BG1Nq5b0S2PhX59UKi9vZpPDQVdqn+1IcaAwnzTT5vCjw==", + "dev": true, + "dependencies": { + "call-bind": "^1.0.2", + "get-intrinsic": "^1.1.1" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/glob": { + "version": "7.2.3", + "resolved": "https://registry.npmjs.org/glob/-/glob-7.2.3.tgz", + "integrity": "sha512-nFR0zLpU2YCaRxwoCJvL6UvCH2JFyFVIvwTLsIf21AuHlMskA1hhTdk+LlYJtOlYt9v6dvszD2BGRqBL+iQK9Q==", + "dependencies": { + "fs.realpath": "^1.0.0", + "inflight": "^1.0.4", + "inherits": "2", + "minimatch": "^3.1.1", + "once": "^1.3.0", + "path-is-absolute": "^1.0.0" + }, + "engines": { + "node": "*" + }, + "funding": { + "url": "https://github.com/sponsors/isaacs" + } + }, + "node_modules/glob-parent": { + "version": "6.0.2", + "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-6.0.2.tgz", + "integrity": "sha512-XxwI8EOhVQgWp6iDL+3b0r86f4d6AX6zSU55HfB4ydCEuXLXc5FcYeOu+nnGftS4TEju/11rt4KJPTMgbfmv4A==", + "dev": true, + "dependencies": { + "is-glob": "^4.0.3" + }, + "engines": { + "node": ">=10.13.0" + } + }, + "node_modules/globals": { + "version": "13.20.0", + "resolved": "https://registry.npmjs.org/globals/-/globals-13.20.0.tgz", + "integrity": "sha512-Qg5QtVkCy/kv3FUSlu4ukeZDVf9ee0iXLAUYX13gbR17bnejFTzr4iS9bY7kwCf1NztRNm1t91fjOiyx4CSwPQ==", + "dev": true, + "dependencies": { + "type-fest": "^0.20.2" + }, + "engines": { + "node": ">=8" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/globalthis": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/globalthis/-/globalthis-1.0.3.tgz", + "integrity": "sha512-sFdI5LyBiNTHjRd7cGPWapiHWMOXKyuBNX/cWJ3NfzrZQVa8GI/8cofCl74AOVqq9W5kNmguTIzJ/1s2gyI9wA==", + "dev": true, + "dependencies": { + "define-properties": "^1.1.3" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/gopd": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/gopd/-/gopd-1.0.1.tgz", + "integrity": "sha512-d65bNlIadxvpb/A2abVdlqKqV563juRnZ1Wtk6s1sIR8uNsXR70xqIzVqxVf1eTqDunwT2MkczEeaezCKTZhwA==", + "dev": true, + "dependencies": { + "get-intrinsic": "^1.1.3" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/graceful-fs": { + "version": "4.2.10", + "resolved": "https://registry.npmjs.org/graceful-fs/-/graceful-fs-4.2.10.tgz", + "integrity": "sha512-9ByhssR2fPVsNZj478qUUbKfmL0+t5BDVyjShtyZZLiK7ZDAArFFfopyOTj0M05wE2tJPisA4iTnnXl2YoPvOA==", + "dev": true + }, + "node_modules/grapheme-splitter": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/grapheme-splitter/-/grapheme-splitter-1.0.4.tgz", + "integrity": "sha512-bzh50DW9kTPM00T8y4o8vQg89Di9oLJVLW/KaOGIXJWP/iqCN6WKYkbNOF04vFLJhwcpYUh9ydh/+5vpOqV4YQ==", + "dev": true + }, + "node_modules/has": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/has/-/has-1.0.3.tgz", + "integrity": "sha512-f2dvO0VU6Oej7RkWJGrehjbzMAjFp5/VKPp5tTpWIV4JHHZK1/BxbFRtf/siA2SWTe09caDmVtYYzWEIbBS4zw==", + "dev": true, + "dependencies": { + "function-bind": "^1.1.1" + }, + "engines": { + "node": ">= 0.4.0" + } + }, + "node_modules/has-bigints": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/has-bigints/-/has-bigints-1.0.2.tgz", + "integrity": "sha512-tSvCKtBr9lkF0Ex0aQiP9N+OpV4zi2r/Nee5VkRDbaqv35RLYMzbwQfFSZZH0kR+Rd6302UJZ2p/bJCEoR3VoQ==", + "dev": true, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/has-flag": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz", + "integrity": "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==", + "dev": true, + "engines": { + "node": ">=8" + } + }, + "node_modules/has-property-descriptors": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/has-property-descriptors/-/has-property-descriptors-1.0.0.tgz", + "integrity": "sha512-62DVLZGoiEBDHQyqG4w9xCuZ7eJEwNmJRWw2VY84Oedb7WFcA27fiEVe8oUQx9hAUJ4ekurquucTGwsyO1XGdQ==", + "dev": true, + "dependencies": { + "get-intrinsic": "^1.1.1" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/has-proto": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/has-proto/-/has-proto-1.0.1.tgz", + "integrity": "sha512-7qE+iP+O+bgF9clE5+UoBFzE65mlBiVj3tKCrlNQ0Ogwm0BjpT/gK4SlLYDMybDh5I3TCTKnPPa0oMG7JDYrhg==", + "dev": true, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/has-symbols": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/has-symbols/-/has-symbols-1.0.3.tgz", + "integrity": "sha512-l3LCuF6MgDNwTDKkdYGEihYjt5pRPbEg46rtlmnSPlUbgmB8LOIrKJbYYFBSbnPaJexMKtiPO8hmeRjRz2Td+A==", + "dev": true, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/has-tostringtag": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/has-tostringtag/-/has-tostringtag-1.0.0.tgz", + "integrity": "sha512-kFjcSNhnlGV1kyoGk7OXKSawH5JOb/LzUc5w9B02hOTO0dfFRjbHQKvg1d6cf3HbeUmtU9VbbV3qzZ2Teh97WQ==", + "dev": true, + "dependencies": { + "has-symbols": "^1.0.2" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/has-unicode": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/has-unicode/-/has-unicode-2.0.1.tgz", + "integrity": "sha512-8Rf9Y83NBReMnx0gFzA8JImQACstCYWUplepDa9xprwwtmgEZUF0h/i5xSA625zB/I37EtrswSST6OXxwaaIJQ==" + }, + "node_modules/heap": { + "version": "0.2.7", + "resolved": "https://registry.npmjs.org/heap/-/heap-0.2.7.tgz", + "integrity": "sha512-2bsegYkkHO+h/9MGbn6KWcE45cHZgPANo5LXF7EvWdT0yT2EguSVO1nDgU5c8+ZOPwp2vMNa7YFsJhVcDR9Sdg==", + "dev": true + }, + "node_modules/html-element-map": { + "version": "1.3.1", + "resolved": "https://registry.npmjs.org/html-element-map/-/html-element-map-1.3.1.tgz", + "integrity": "sha512-6XMlxrAFX4UEEGxctfFnmrFaaZFNf9i5fNuV5wZ3WWQ4FVaNP1aX1LkX9j2mfEx1NpjeE/rL3nmgEn23GdFmrg==", + "dev": true, + "dependencies": { + "array.prototype.filter": "^1.0.0", + "call-bind": "^1.0.2" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/html-escaper": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/html-escaper/-/html-escaper-2.0.2.tgz", + "integrity": "sha512-H2iMtd0I4Mt5eYiapRdIDjp+XzelXQ0tFE4JS7YFwFevXXMmOp9myNrUvCg0D6ws8iqkRPBfKHgbwig1SmlLfg==", + "dev": true + }, + "node_modules/htmlparser2": { + "version": "8.0.1", + "resolved": "https://registry.npmjs.org/htmlparser2/-/htmlparser2-8.0.1.tgz", + "integrity": "sha512-4lVbmc1diZC7GUJQtRQ5yBAeUCL1exyMwmForWkRLnwyzWBFxN633SALPMGYaWZvKe9j1pRZJpauvmxENSp/EA==", + "dev": true, + "funding": [ + "https://github.com/fb55/htmlparser2?sponsor=1", + { + "type": "github", + "url": "https://github.com/sponsors/fb55" + } + ], + "dependencies": { + "domelementtype": "^2.3.0", + "domhandler": "^5.0.2", + "domutils": "^3.0.1", + "entities": "^4.3.0" + } + }, + "node_modules/https-proxy-agent": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/https-proxy-agent/-/https-proxy-agent-5.0.1.tgz", + "integrity": "sha512-dFcAjpTQFgoLMzC2VwU+C/CbS7uRL0lWmxDITmqm7C+7F0Odmj6s9l6alZc6AELXhrnggM2CeWSXHGOdX2YtwA==", + "dependencies": { + "agent-base": "6", + "debug": "4" + }, + "engines": { + "node": ">= 6" + } + }, + "node_modules/human-signals": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/human-signals/-/human-signals-2.1.0.tgz", + "integrity": "sha512-B4FFZ6q/T2jhhksgkbEW3HBvWIfDW85snkQgawt07S7J5QXTk6BkNV+0yAeZrM5QpMAdYlocGoljn0sJ/WQkFw==", + "dev": true, + "engines": { + "node": ">=10.17.0" + } + }, + "node_modules/ignore": { + "version": "5.2.4", + "resolved": "https://registry.npmjs.org/ignore/-/ignore-5.2.4.tgz", + "integrity": "sha512-MAb38BcSbH0eHNBxn7ql2NH/kX33OkB3lZ1BNdh7ENeRChHTYsTvWrMubiIAMNS2llXEEgZ1MUOBtXChP3kaFQ==", + "dev": true, + "engines": { + "node": ">= 4" + } + }, + "node_modules/import-fresh": { + "version": "3.3.0", + "resolved": "https://registry.npmjs.org/import-fresh/-/import-fresh-3.3.0.tgz", + "integrity": "sha512-veYYhQa+D1QBKznvhUHxb8faxlrwUnxseDAbAp457E0wLNio2bOSKnjYDhMj+YiAq61xrMGhQk9iXVk5FzgQMw==", + "dev": true, + "dependencies": { + "parent-module": "^1.0.0", + "resolve-from": "^4.0.0" + }, + "engines": { + "node": ">=6" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/import-local": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/import-local/-/import-local-3.1.0.tgz", + "integrity": "sha512-ASB07uLtnDs1o6EHjKpX34BKYDSqnFerfTOJL2HvMqF70LnxpjkzDB8J44oT9pu4AMPkQwf8jl6szgvNd2tRIg==", + "dev": true, + "dependencies": { + "pkg-dir": "^4.2.0", + "resolve-cwd": "^3.0.0" + }, + "bin": { + "import-local-fixture": "fixtures/cli.js" + }, + "engines": { + "node": ">=8" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/imurmurhash": { + "version": "0.1.4", + "resolved": "https://registry.npmjs.org/imurmurhash/-/imurmurhash-0.1.4.tgz", + "integrity": "sha512-JmXMZ6wuvDmLiHEml9ykzqO6lwFbof0GG4IkcGaENdCRDDmMVnny7s5HsIgHCbaq0w2MyPhDqkhTUgS2LU2PHA==", + "dev": true, + "engines": { + "node": ">=0.8.19" + } + }, + "node_modules/inflight": { + "version": "1.0.6", + "resolved": "https://registry.npmjs.org/inflight/-/inflight-1.0.6.tgz", + "integrity": "sha512-k92I/b08q4wvFscXCLvqfsHCrjrF7yiXsQuIVvVE7N82W3+aqpzuUdBbfhWcy/FZR3/4IgflMgKLOsvPDrGCJA==", + "dependencies": { + "once": "^1.3.0", + "wrappy": "1" + } + }, + "node_modules/inherits": { + "version": "2.0.4", + "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.4.tgz", + "integrity": "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==" + }, + "node_modules/internal-slot": { + "version": "1.0.5", + "resolved": "https://registry.npmjs.org/internal-slot/-/internal-slot-1.0.5.tgz", + "integrity": "sha512-Y+R5hJrzs52QCG2laLn4udYVnxsfny9CpOhNhUvk/SSSVyF6T27FzRbF0sroPidSu3X8oEAkOn2K804mjpt6UQ==", + "dev": true, + "dependencies": { + "get-intrinsic": "^1.2.0", + "has": "^1.0.3", + "side-channel": "^1.0.4" + }, + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/is-array-buffer": { + "version": "3.0.2", + "resolved": "https://registry.npmjs.org/is-array-buffer/-/is-array-buffer-3.0.2.tgz", + "integrity": "sha512-y+FyyR/w8vfIRq4eQcM1EYgSTnmHXPqaF+IgzgraytCFq5Xh8lllDVmAZolPJiZttZLeFSINPYMaEJ7/vWUa1w==", + "dev": true, + "dependencies": { + "call-bind": "^1.0.2", + "get-intrinsic": "^1.2.0", + "is-typed-array": "^1.1.10" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/is-arrayish": { + "version": "0.2.1", + "resolved": "https://registry.npmjs.org/is-arrayish/-/is-arrayish-0.2.1.tgz", + "integrity": "sha512-zz06S8t0ozoDXMG+ube26zeCTNXcKIPJZJi8hBrF4idCLms4CG9QtK7qBl1boi5ODzFpjswb5JPmHCbMpjaYzg==", + "dev": true + }, + "node_modules/is-bigint": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/is-bigint/-/is-bigint-1.0.4.tgz", + "integrity": "sha512-zB9CruMamjym81i2JZ3UMn54PKGsQzsJeo6xvN3HJJ4CAsQNB6iRutp2To77OfCNuoxspsIhzaPoO1zyCEhFOg==", + "dev": true, + "dependencies": { + "has-bigints": "^1.0.1" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/is-boolean-object": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/is-boolean-object/-/is-boolean-object-1.1.2.tgz", + "integrity": "sha512-gDYaKHJmnj4aWxyj6YHyXVpdQawtVLHU5cb+eztPGczf6cjuTdwve5ZIEfgXqH4e57An1D1AKf8CZ3kYrQRqYA==", + "dev": true, + "dependencies": { + "call-bind": "^1.0.2", + "has-tostringtag": "^1.0.0" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/is-callable": { + "version": "1.2.7", + "resolved": "https://registry.npmjs.org/is-callable/-/is-callable-1.2.7.tgz", + "integrity": "sha512-1BC0BVFhS/p0qtw6enp8e+8OD0UrK0oFLztSjNzhcKA3WDuJxxAPXzPuPtKkjEY9UUoEWlX/8fgKeu2S8i9JTA==", + "dev": true, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/is-core-module": { + "version": "2.11.0", + "resolved": "https://registry.npmjs.org/is-core-module/-/is-core-module-2.11.0.tgz", + "integrity": "sha512-RRjxlvLDkD1YJwDbroBHMb+cukurkDWNyHx7D3oNB5x9rb5ogcksMC5wHCadcXoo67gVr/+3GFySh3134zi6rw==", + "dev": true, + "dependencies": { + "has": "^1.0.3" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/is-date-object": { + "version": "1.0.5", + "resolved": "https://registry.npmjs.org/is-date-object/-/is-date-object-1.0.5.tgz", + "integrity": "sha512-9YQaSxsAiSwcvS33MBk3wTCVnWK+HhF8VZR2jRxehM16QcVOdHqPn4VPHmRK4lSr38n9JriurInLcP90xsYNfQ==", + "dev": true, + "dependencies": { + "has-tostringtag": "^1.0.0" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/is-extglob": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/is-extglob/-/is-extglob-2.1.1.tgz", + "integrity": "sha512-SbKbANkN603Vi4jEZv49LeVJMn4yGwsbzZworEoyEiutsN3nJYdbO36zfhGJ6QEDpOZIFkDtnq5JRxmvl3jsoQ==", + "dev": true, + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/is-fullwidth-code-point": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-3.0.0.tgz", + "integrity": "sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg==", + "engines": { + "node": ">=8" + } + }, + "node_modules/is-generator-fn": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/is-generator-fn/-/is-generator-fn-2.1.0.tgz", + "integrity": "sha512-cTIB4yPYL/Grw0EaSzASzg6bBy9gqCofvWN8okThAYIxKJZC+udlRAmGbM0XLeniEJSs8uEgHPGuHSe1XsOLSQ==", + "dev": true, + "engines": { + "node": ">=6" + } + }, + "node_modules/is-glob": { + "version": "4.0.3", + "resolved": "https://registry.npmjs.org/is-glob/-/is-glob-4.0.3.tgz", + "integrity": "sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg==", + "dev": true, + "dependencies": { + "is-extglob": "^2.1.1" + }, + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/is-negative-zero": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/is-negative-zero/-/is-negative-zero-2.0.2.tgz", + "integrity": "sha512-dqJvarLawXsFbNDeJW7zAz8ItJ9cd28YufuuFzh0G8pNHjJMnY08Dv7sYX2uF5UpQOwieAeOExEYAWWfu7ZZUA==", + "dev": true, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/is-number": { + "version": "7.0.0", + "resolved": "https://registry.npmjs.org/is-number/-/is-number-7.0.0.tgz", + "integrity": "sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng==", + "dev": true, + "engines": { + "node": ">=0.12.0" + } + }, + "node_modules/is-number-object": { + "version": "1.0.7", + "resolved": "https://registry.npmjs.org/is-number-object/-/is-number-object-1.0.7.tgz", + "integrity": "sha512-k1U0IRzLMo7ZlYIfzRu23Oh6MiIFasgpb9X76eqfFZAqwH44UI4KTBvBYIZ1dSL9ZzChTB9ShHfLkR4pdW5krQ==", + "dev": true, + "dependencies": { + "has-tostringtag": "^1.0.0" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/is-path-inside": { + "version": "3.0.3", + "resolved": "https://registry.npmjs.org/is-path-inside/-/is-path-inside-3.0.3.tgz", + "integrity": "sha512-Fd4gABb+ycGAmKou8eMftCupSir5lRxqf4aD/vd0cD2qc4HL07OjCeuHMr8Ro4CoMaeCKDB0/ECBOVWjTwUvPQ==", + "dev": true, + "engines": { + "node": ">=8" + } + }, + "node_modules/is-plain-object": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/is-plain-object/-/is-plain-object-5.0.0.tgz", + "integrity": "sha512-VRSzKkbMm5jMDoKLbltAkFQ5Qr7VDiTFGXxYFXXowVj387GeGNOCsOH6Msy00SGZ3Fp84b1Naa1psqgcCIEP5Q==", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/is-regex": { + "version": "1.1.4", + "resolved": "https://registry.npmjs.org/is-regex/-/is-regex-1.1.4.tgz", + "integrity": "sha512-kvRdxDsxZjhzUX07ZnLydzS1TU/TJlTUHHY4YLL87e37oUA49DfkLqgy+VjFocowy29cKvcSiu+kIv728jTTVg==", + "dev": true, + "dependencies": { + "call-bind": "^1.0.2", + "has-tostringtag": "^1.0.0" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/is-shared-array-buffer": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/is-shared-array-buffer/-/is-shared-array-buffer-1.0.2.tgz", + "integrity": "sha512-sqN2UDu1/0y6uvXyStCOzyhAjCSlHceFoMKJW8W9EU9cvic/QdsZ0kEU93HEy3IUEFZIiH/3w+AH/UQbPHNdhA==", + "dev": true, + "dependencies": { + "call-bind": "^1.0.2" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/is-stream": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/is-stream/-/is-stream-2.0.1.tgz", + "integrity": "sha512-hFoiJiTl63nn+kstHGBtewWSKnQLpyb155KHheA1l39uvtO9nWIop1p3udqPcUd/xbF1VLMO4n7OI6p7RbngDg==", + "dev": true, + "engines": { + "node": ">=8" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/is-string": { + "version": "1.0.7", + "resolved": "https://registry.npmjs.org/is-string/-/is-string-1.0.7.tgz", + "integrity": "sha512-tE2UXzivje6ofPW7l23cjDOMa09gb7xlAqG6jG5ej6uPV32TlWP3NKPigtaGeHNu9fohccRYvIiZMfOOnOYUtg==", + "dev": true, + "dependencies": { + "has-tostringtag": "^1.0.0" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/is-subset": { + "version": "0.1.1", + "resolved": "https://registry.npmjs.org/is-subset/-/is-subset-0.1.1.tgz", + "integrity": "sha512-6Ybun0IkarhmEqxXCNw/C0bna6Zb/TkfUX9UbwJtK6ObwAVCxmAP308WWTHviM/zAqXk05cdhYsUsZeGQh99iw==", + "dev": true + }, + "node_modules/is-symbol": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/is-symbol/-/is-symbol-1.0.4.tgz", + "integrity": "sha512-C/CPBqKWnvdcxqIARxyOh4v1UUEOCHpgDa0WYgpKDFMszcrPcffg5uhwSgPCLD2WWxmq6isisz87tzT01tuGhg==", + "dev": true, + "dependencies": { + "has-symbols": "^1.0.2" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/is-typed-array": { + "version": "1.1.10", + "resolved": "https://registry.npmjs.org/is-typed-array/-/is-typed-array-1.1.10.tgz", + "integrity": "sha512-PJqgEHiWZvMpaFZ3uTc8kHPM4+4ADTlDniuQL7cU/UDA0Ql7F70yGfHph3cLNe+c9toaigv+DFzTJKhc2CtO6A==", + "dev": true, + "dependencies": { + "available-typed-arrays": "^1.0.5", + "call-bind": "^1.0.2", + "for-each": "^0.3.3", + "gopd": "^1.0.1", + "has-tostringtag": "^1.0.0" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/is-weakref": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/is-weakref/-/is-weakref-1.0.2.tgz", + "integrity": "sha512-qctsuLZmIQ0+vSSMfoVvyFe2+GSEvnmZ2ezTup1SBse9+twCCeial6EEi3Nc2KFcf6+qz2FBPnjXsk8xhKSaPQ==", + "dev": true, + "dependencies": { + "call-bind": "^1.0.2" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/isexe": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/isexe/-/isexe-2.0.0.tgz", + "integrity": "sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw==", + "dev": true + }, + "node_modules/istanbul-lib-coverage": { + "version": "3.2.0", + "resolved": "https://registry.npmjs.org/istanbul-lib-coverage/-/istanbul-lib-coverage-3.2.0.tgz", + "integrity": "sha512-eOeJ5BHCmHYvQK7xt9GkdHuzuCGS1Y6g9Gvnx3Ym33fz/HpLRYxiS0wHNr+m/MBC8B647Xt608vCDEvhl9c6Mw==", + "dev": true, + "engines": { + "node": ">=8" + } + }, + "node_modules/istanbul-lib-instrument": { + "version": "5.2.1", + "resolved": "https://registry.npmjs.org/istanbul-lib-instrument/-/istanbul-lib-instrument-5.2.1.tgz", + "integrity": "sha512-pzqtp31nLv/XFOzXGuvhCb8qhjmTVo5vjVk19XE4CRlSWz0KoeJ3bw9XsA7nOp9YBf4qHjwBxkDzKcME/J29Yg==", + "dev": true, + "dependencies": { + "@babel/core": "^7.12.3", + "@babel/parser": "^7.14.7", + "@istanbuljs/schema": "^0.1.2", + "istanbul-lib-coverage": "^3.2.0", + "semver": "^6.3.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/istanbul-lib-report": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/istanbul-lib-report/-/istanbul-lib-report-3.0.0.tgz", + "integrity": "sha512-wcdi+uAKzfiGT2abPpKZ0hSU1rGQjUQnLvtY5MpQ7QCTahD3VODhcu4wcfY1YtkGaDD5yuydOLINXsfbus9ROw==", + "dev": true, + "dependencies": { + "istanbul-lib-coverage": "^3.0.0", + "make-dir": "^3.0.0", + "supports-color": "^7.1.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/istanbul-lib-source-maps": { + "version": "4.0.1", + "resolved": "https://registry.npmjs.org/istanbul-lib-source-maps/-/istanbul-lib-source-maps-4.0.1.tgz", + "integrity": "sha512-n3s8EwkdFIJCG3BPKBYvskgXGoy88ARzvegkitk60NxRdwltLOTaH7CUiMRXvwYorl0Q712iEjcWB+fK/MrWVw==", + "dev": true, + "dependencies": { + "debug": "^4.1.1", + "istanbul-lib-coverage": "^3.0.0", + "source-map": "^0.6.1" + }, + "engines": { + "node": ">=10" + } + }, + "node_modules/istanbul-reports": { + "version": "3.1.5", + "resolved": "https://registry.npmjs.org/istanbul-reports/-/istanbul-reports-3.1.5.tgz", + "integrity": "sha512-nUsEMa9pBt/NOHqbcbeJEgqIlY/K7rVWUX6Lql2orY5e9roQOthbR3vtY4zzf2orPELg80fnxxk9zUyPlgwD1w==", + "dev": true, + "dependencies": { + "html-escaper": "^2.0.0", + "istanbul-lib-report": "^3.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/jest": { + "version": "29.4.2", + "resolved": "https://registry.npmjs.org/jest/-/jest-29.4.2.tgz", + "integrity": "sha512-+5hLd260vNIHu+7ZgMIooSpKl7Jp5pHKb51e73AJU3owd5dEo/RfVwHbA/na3C/eozrt3hJOLGf96c7EWwIAzg==", + "dev": true, + "dependencies": { + "@jest/core": "^29.4.2", + "@jest/types": "^29.4.2", + "import-local": "^3.0.2", + "jest-cli": "^29.4.2" + }, + "bin": { + "jest": "bin/jest.js" + }, + "engines": { + "node": "^14.15.0 || ^16.10.0 || >=18.0.0" + }, + "peerDependencies": { + "node-notifier": "^8.0.1 || ^9.0.0 || ^10.0.0" + }, + "peerDependenciesMeta": { + "node-notifier": { + "optional": true + } + } + }, + "node_modules/jest-changed-files": { + "version": "29.5.0", + "resolved": "https://registry.npmjs.org/jest-changed-files/-/jest-changed-files-29.5.0.tgz", + "integrity": "sha512-IFG34IUMUaNBIxjQXF/iu7g6EcdMrGRRxaUSw92I/2g2YC6vCdTltl4nHvt7Ci5nSJwXIkCu8Ka1DKF+X7Z1Ag==", + "dev": true, + "dependencies": { + "execa": "^5.0.0", + "p-limit": "^3.1.0" + }, + "engines": { + "node": "^14.15.0 || ^16.10.0 || >=18.0.0" + } + }, + "node_modules/jest-circus": { + "version": "29.5.0", + "resolved": "https://registry.npmjs.org/jest-circus/-/jest-circus-29.5.0.tgz", + "integrity": "sha512-gq/ongqeQKAplVxqJmbeUOJJKkW3dDNPY8PjhJ5G0lBRvu0e3EWGxGy5cI4LAGA7gV2UHCtWBI4EMXK8c9nQKA==", + "dev": true, + "dependencies": { + "@jest/environment": "^29.5.0", + "@jest/expect": "^29.5.0", + "@jest/test-result": "^29.5.0", + "@jest/types": "^29.5.0", + "@types/node": "*", + "chalk": "^4.0.0", + "co": "^4.6.0", + "dedent": "^0.7.0", + "is-generator-fn": "^2.0.0", + "jest-each": "^29.5.0", + "jest-matcher-utils": "^29.5.0", + "jest-message-util": "^29.5.0", + "jest-runtime": "^29.5.0", + "jest-snapshot": "^29.5.0", + "jest-util": "^29.5.0", + "p-limit": "^3.1.0", + "pretty-format": "^29.5.0", + "pure-rand": "^6.0.0", + "slash": "^3.0.0", + "stack-utils": "^2.0.3" + }, + "engines": { + "node": "^14.15.0 || ^16.10.0 || >=18.0.0" + } + }, + "node_modules/jest-cli": { + "version": "29.5.0", + "resolved": "https://registry.npmjs.org/jest-cli/-/jest-cli-29.5.0.tgz", + "integrity": "sha512-L1KcP1l4HtfwdxXNFCL5bmUbLQiKrakMUriBEcc1Vfz6gx31ORKdreuWvmQVBit+1ss9NNR3yxjwfwzZNdQXJw==", + "dev": true, + "dependencies": { + "@jest/core": "^29.5.0", + "@jest/test-result": "^29.5.0", + "@jest/types": "^29.5.0", + "chalk": "^4.0.0", + "exit": "^0.1.2", + "graceful-fs": "^4.2.9", + "import-local": "^3.0.2", + "jest-config": "^29.5.0", + "jest-util": "^29.5.0", + "jest-validate": "^29.5.0", + "prompts": "^2.0.1", + "yargs": "^17.3.1" + }, + "bin": { + "jest": "bin/jest.js" + }, + "engines": { + "node": "^14.15.0 || ^16.10.0 || >=18.0.0" + }, + "peerDependencies": { + "node-notifier": "^8.0.1 || ^9.0.0 || ^10.0.0" + }, + "peerDependenciesMeta": { + "node-notifier": { + "optional": true + } + } + }, + "node_modules/jest-config": { + "version": "29.5.0", + "resolved": "https://registry.npmjs.org/jest-config/-/jest-config-29.5.0.tgz", + "integrity": "sha512-kvDUKBnNJPNBmFFOhDbm59iu1Fii1Q6SxyhXfvylq3UTHbg6o7j/g8k2dZyXWLvfdKB1vAPxNZnMgtKJcmu3kA==", + "dev": true, + "dependencies": { + "@babel/core": "^7.11.6", + "@jest/test-sequencer": "^29.5.0", + "@jest/types": "^29.5.0", + "babel-jest": "^29.5.0", + "chalk": "^4.0.0", + "ci-info": "^3.2.0", + "deepmerge": "^4.2.2", + "glob": "^7.1.3", + "graceful-fs": "^4.2.9", + "jest-circus": "^29.5.0", + "jest-environment-node": "^29.5.0", + "jest-get-type": "^29.4.3", + "jest-regex-util": "^29.4.3", + "jest-resolve": "^29.5.0", + "jest-runner": "^29.5.0", + "jest-util": "^29.5.0", + "jest-validate": "^29.5.0", + "micromatch": "^4.0.4", + "parse-json": "^5.2.0", + "pretty-format": "^29.5.0", + "slash": "^3.0.0", + "strip-json-comments": "^3.1.1" + }, + "engines": { + "node": "^14.15.0 || ^16.10.0 || >=18.0.0" + }, + "peerDependencies": { + "@types/node": "*", + "ts-node": ">=9.0.0" + }, + "peerDependenciesMeta": { + "@types/node": { + "optional": true + }, + "ts-node": { + "optional": true + } + } + }, + "node_modules/jest-diff": { + "version": "29.5.0", + "resolved": "https://registry.npmjs.org/jest-diff/-/jest-diff-29.5.0.tgz", + "integrity": "sha512-LtxijLLZBduXnHSniy0WMdaHjmQnt3g5sa16W4p0HqukYTTsyTW3GD1q41TyGl5YFXj/5B2U6dlh5FM1LIMgxw==", + "dev": true, + "dependencies": { + "chalk": "^4.0.0", + "diff-sequences": "^29.4.3", + "jest-get-type": "^29.4.3", + "pretty-format": "^29.5.0" + }, + "engines": { + "node": "^14.15.0 || ^16.10.0 || >=18.0.0" + } + }, + "node_modules/jest-docblock": { + "version": "29.4.3", + "resolved": "https://registry.npmjs.org/jest-docblock/-/jest-docblock-29.4.3.tgz", + "integrity": "sha512-fzdTftThczeSD9nZ3fzA/4KkHtnmllawWrXO69vtI+L9WjEIuXWs4AmyME7lN5hU7dB0sHhuPfcKofRsUb/2Fg==", + "dev": true, + "dependencies": { + "detect-newline": "^3.0.0" + }, + "engines": { + "node": "^14.15.0 || ^16.10.0 || >=18.0.0" + } + }, + "node_modules/jest-each": { + "version": "29.5.0", + "resolved": "https://registry.npmjs.org/jest-each/-/jest-each-29.5.0.tgz", + "integrity": "sha512-HM5kIJ1BTnVt+DQZ2ALp3rzXEl+g726csObrW/jpEGl+CDSSQpOJJX2KE/vEg8cxcMXdyEPu6U4QX5eruQv5hA==", + "dev": true, + "dependencies": { + "@jest/types": "^29.5.0", + "chalk": "^4.0.0", + "jest-get-type": "^29.4.3", + "jest-util": "^29.5.0", + "pretty-format": "^29.5.0" + }, + "engines": { + "node": "^14.15.0 || ^16.10.0 || >=18.0.0" + } + }, + "node_modules/jest-environment-node": { + "version": "29.5.0", + "resolved": "https://registry.npmjs.org/jest-environment-node/-/jest-environment-node-29.5.0.tgz", + "integrity": "sha512-ExxuIK/+yQ+6PRGaHkKewYtg6hto2uGCgvKdb2nfJfKXgZ17DfXjvbZ+jA1Qt9A8EQSfPnt5FKIfnOO3u1h9qw==", + "dev": true, + "dependencies": { + "@jest/environment": "^29.5.0", + "@jest/fake-timers": "^29.5.0", + "@jest/types": "^29.5.0", + "@types/node": "*", + "jest-mock": "^29.5.0", + "jest-util": "^29.5.0" + }, + "engines": { + "node": "^14.15.0 || ^16.10.0 || >=18.0.0" + } + }, + "node_modules/jest-get-type": { + "version": "29.4.3", + "resolved": "https://registry.npmjs.org/jest-get-type/-/jest-get-type-29.4.3.tgz", + "integrity": "sha512-J5Xez4nRRMjk8emnTpWrlkyb9pfRQQanDrvWHhsR1+VUfbwxi30eVcZFlcdGInRibU4G5LwHXpI7IRHU0CY+gg==", + "dev": true, + "engines": { + "node": "^14.15.0 || ^16.10.0 || >=18.0.0" + } + }, + "node_modules/jest-haste-map": { + "version": "29.5.0", + "resolved": "https://registry.npmjs.org/jest-haste-map/-/jest-haste-map-29.5.0.tgz", + "integrity": "sha512-IspOPnnBro8YfVYSw6yDRKh/TiCdRngjxeacCps1cQ9cgVN6+10JUcuJ1EabrgYLOATsIAigxA0rLR9x/YlrSA==", + "dev": true, + "dependencies": { + "@jest/types": "^29.5.0", + "@types/graceful-fs": "^4.1.3", + "@types/node": "*", + "anymatch": "^3.0.3", + "fb-watchman": "^2.0.0", + "graceful-fs": "^4.2.9", + "jest-regex-util": "^29.4.3", + "jest-util": "^29.5.0", + "jest-worker": "^29.5.0", + "micromatch": "^4.0.4", + "walker": "^1.0.8" + }, + "engines": { + "node": "^14.15.0 || ^16.10.0 || >=18.0.0" + }, + "optionalDependencies": { + "fsevents": "^2.3.2" + } + }, + "node_modules/jest-junit": { + "version": "15.0.0", + "resolved": "https://registry.npmjs.org/jest-junit/-/jest-junit-15.0.0.tgz", + "integrity": "sha512-Z5sVX0Ag3HZdMUnD5DFlG+1gciIFSy7yIVPhOdGUi8YJaI9iLvvBb530gtQL2CHmv0JJeiwRZenr0VrSR7frvg==", + "dev": true, + "dependencies": { + "mkdirp": "^1.0.4", + "strip-ansi": "^6.0.1", + "uuid": "^8.3.2", + "xml": "^1.0.1" + }, + "engines": { + "node": ">=10.12.0" + } + }, + "node_modules/jest-leak-detector": { + "version": "29.5.0", + "resolved": "https://registry.npmjs.org/jest-leak-detector/-/jest-leak-detector-29.5.0.tgz", + "integrity": "sha512-u9YdeeVnghBUtpN5mVxjID7KbkKE1QU4f6uUwuxiY0vYRi9BUCLKlPEZfDGR67ofdFmDz9oPAy2G92Ujrntmow==", + "dev": true, + "dependencies": { + "jest-get-type": "^29.4.3", + "pretty-format": "^29.5.0" + }, + "engines": { + "node": "^14.15.0 || ^16.10.0 || >=18.0.0" + } + }, + "node_modules/jest-matcher-utils": { + "version": "29.5.0", + "resolved": "https://registry.npmjs.org/jest-matcher-utils/-/jest-matcher-utils-29.5.0.tgz", + "integrity": "sha512-lecRtgm/rjIK0CQ7LPQwzCs2VwW6WAahA55YBuI+xqmhm7LAaxokSB8C97yJeYyT+HvQkH741StzpU41wohhWw==", + "dev": true, + "dependencies": { + "chalk": "^4.0.0", + "jest-diff": "^29.5.0", + "jest-get-type": "^29.4.3", + "pretty-format": "^29.5.0" + }, + "engines": { + "node": "^14.15.0 || ^16.10.0 || >=18.0.0" + } + }, + "node_modules/jest-message-util": { + "version": "29.5.0", + "resolved": "https://registry.npmjs.org/jest-message-util/-/jest-message-util-29.5.0.tgz", + "integrity": "sha512-Kijeg9Dag6CKtIDA7O21zNTACqD5MD/8HfIV8pdD94vFyFuer52SigdC3IQMhab3vACxXMiFk+yMHNdbqtyTGA==", + "dev": true, + "dependencies": { + "@babel/code-frame": "^7.12.13", + "@jest/types": "^29.5.0", + "@types/stack-utils": "^2.0.0", + "chalk": "^4.0.0", + "graceful-fs": "^4.2.9", + "micromatch": "^4.0.4", + "pretty-format": "^29.5.0", + "slash": "^3.0.0", + "stack-utils": "^2.0.3" + }, + "engines": { + "node": "^14.15.0 || ^16.10.0 || >=18.0.0" + } + }, + "node_modules/jest-mock": { + "version": "29.5.0", + "resolved": "https://registry.npmjs.org/jest-mock/-/jest-mock-29.5.0.tgz", + "integrity": "sha512-GqOzvdWDE4fAV2bWQLQCkujxYWL7RxjCnj71b5VhDAGOevB3qj3Ovg26A5NI84ZpODxyzaozXLOh2NCgkbvyaw==", + "dev": true, + "dependencies": { + "@jest/types": "^29.5.0", + "@types/node": "*", + "jest-util": "^29.5.0" + }, + "engines": { + "node": "^14.15.0 || ^16.10.0 || >=18.0.0" + } + }, + "node_modules/jest-pnp-resolver": { + "version": "1.2.3", + "resolved": "https://registry.npmjs.org/jest-pnp-resolver/-/jest-pnp-resolver-1.2.3.tgz", + "integrity": "sha512-+3NpwQEnRoIBtx4fyhblQDPgJI0H1IEIkX7ShLUjPGA7TtUTvI1oiKi3SR4oBR0hQhQR80l4WAe5RrXBwWMA8w==", + "dev": true, + "engines": { + "node": ">=6" + }, + "peerDependencies": { + "jest-resolve": "*" + }, + "peerDependenciesMeta": { + "jest-resolve": { + "optional": true + } + } + }, + "node_modules/jest-regex-util": { + "version": "29.4.3", + "resolved": "https://registry.npmjs.org/jest-regex-util/-/jest-regex-util-29.4.3.tgz", + "integrity": "sha512-O4FglZaMmWXbGHSQInfXewIsd1LMn9p3ZXB/6r4FOkyhX2/iP/soMG98jGvk/A3HAN78+5VWcBGO0BJAPRh4kg==", + "dev": true, + "engines": { + "node": "^14.15.0 || ^16.10.0 || >=18.0.0" + } + }, + "node_modules/jest-resolve": { + "version": "29.5.0", + "resolved": "https://registry.npmjs.org/jest-resolve/-/jest-resolve-29.5.0.tgz", + "integrity": "sha512-1TzxJ37FQq7J10jPtQjcc+MkCkE3GBpBecsSUWJ0qZNJpmg6m0D9/7II03yJulm3H/fvVjgqLh/k2eYg+ui52w==", + "dev": true, + "dependencies": { + "chalk": "^4.0.0", + "graceful-fs": "^4.2.9", + "jest-haste-map": "^29.5.0", + "jest-pnp-resolver": "^1.2.2", + "jest-util": "^29.5.0", + "jest-validate": "^29.5.0", + "resolve": "^1.20.0", + "resolve.exports": "^2.0.0", + "slash": "^3.0.0" + }, + "engines": { + "node": "^14.15.0 || ^16.10.0 || >=18.0.0" + } + }, + "node_modules/jest-resolve-dependencies": { + "version": "29.5.0", + "resolved": "https://registry.npmjs.org/jest-resolve-dependencies/-/jest-resolve-dependencies-29.5.0.tgz", + "integrity": "sha512-sjV3GFr0hDJMBpYeUuGduP+YeCRbd7S/ck6IvL3kQ9cpySYKqcqhdLLC2rFwrcL7tz5vYibomBrsFYWkIGGjOg==", + "dev": true, + "dependencies": { + "jest-regex-util": "^29.4.3", + "jest-snapshot": "^29.5.0" + }, + "engines": { + "node": "^14.15.0 || ^16.10.0 || >=18.0.0" + } + }, + "node_modules/jest-runner": { + "version": "29.5.0", + "resolved": "https://registry.npmjs.org/jest-runner/-/jest-runner-29.5.0.tgz", + "integrity": "sha512-m7b6ypERhFghJsslMLhydaXBiLf7+jXy8FwGRHO3BGV1mcQpPbwiqiKUR2zU2NJuNeMenJmlFZCsIqzJCTeGLQ==", + "dev": true, + "dependencies": { + "@jest/console": "^29.5.0", + "@jest/environment": "^29.5.0", + "@jest/test-result": "^29.5.0", + "@jest/transform": "^29.5.0", + "@jest/types": "^29.5.0", + "@types/node": "*", + "chalk": "^4.0.0", + "emittery": "^0.13.1", + "graceful-fs": "^4.2.9", + "jest-docblock": "^29.4.3", + "jest-environment-node": "^29.5.0", + "jest-haste-map": "^29.5.0", + "jest-leak-detector": "^29.5.0", + "jest-message-util": "^29.5.0", + "jest-resolve": "^29.5.0", + "jest-runtime": "^29.5.0", + "jest-util": "^29.5.0", + "jest-watcher": "^29.5.0", + "jest-worker": "^29.5.0", + "p-limit": "^3.1.0", + "source-map-support": "0.5.13" + }, + "engines": { + "node": "^14.15.0 || ^16.10.0 || >=18.0.0" + } + }, + "node_modules/jest-runtime": { + "version": "29.5.0", + "resolved": "https://registry.npmjs.org/jest-runtime/-/jest-runtime-29.5.0.tgz", + "integrity": "sha512-1Hr6Hh7bAgXQP+pln3homOiEZtCDZFqwmle7Ew2j8OlbkIu6uE3Y/etJQG8MLQs3Zy90xrp2C0BRrtPHG4zryw==", + "dev": true, + "dependencies": { + "@jest/environment": "^29.5.0", + "@jest/fake-timers": "^29.5.0", + "@jest/globals": "^29.5.0", + "@jest/source-map": "^29.4.3", + "@jest/test-result": "^29.5.0", + "@jest/transform": "^29.5.0", + "@jest/types": "^29.5.0", + "@types/node": "*", + "chalk": "^4.0.0", + "cjs-module-lexer": "^1.0.0", + "collect-v8-coverage": "^1.0.0", + "glob": "^7.1.3", + "graceful-fs": "^4.2.9", + "jest-haste-map": "^29.5.0", + "jest-message-util": "^29.5.0", + "jest-mock": "^29.5.0", + "jest-regex-util": "^29.4.3", + "jest-resolve": "^29.5.0", + "jest-snapshot": "^29.5.0", + "jest-util": "^29.5.0", + "slash": "^3.0.0", + "strip-bom": "^4.0.0" + }, + "engines": { + "node": "^14.15.0 || ^16.10.0 || >=18.0.0" + } + }, + "node_modules/jest-snapshot": { + "version": "29.5.0", + "resolved": "https://registry.npmjs.org/jest-snapshot/-/jest-snapshot-29.5.0.tgz", + "integrity": "sha512-x7Wolra5V0tt3wRs3/ts3S6ciSQVypgGQlJpz2rsdQYoUKxMxPNaoHMGJN6qAuPJqS+2iQ1ZUn5kl7HCyls84g==", + "dev": true, + "dependencies": { + "@babel/core": "^7.11.6", + "@babel/generator": "^7.7.2", + "@babel/plugin-syntax-jsx": "^7.7.2", + "@babel/plugin-syntax-typescript": "^7.7.2", + "@babel/traverse": "^7.7.2", + "@babel/types": "^7.3.3", + "@jest/expect-utils": "^29.5.0", + "@jest/transform": "^29.5.0", + "@jest/types": "^29.5.0", + "@types/babel__traverse": "^7.0.6", + "@types/prettier": "^2.1.5", + "babel-preset-current-node-syntax": "^1.0.0", + "chalk": "^4.0.0", + "expect": "^29.5.0", + "graceful-fs": "^4.2.9", + "jest-diff": "^29.5.0", + "jest-get-type": "^29.4.3", + "jest-matcher-utils": "^29.5.0", + "jest-message-util": "^29.5.0", + "jest-util": "^29.5.0", + "natural-compare": "^1.4.0", + "pretty-format": "^29.5.0", + "semver": "^7.3.5" + }, + "engines": { + "node": "^14.15.0 || ^16.10.0 || >=18.0.0" + } + }, + "node_modules/jest-snapshot/node_modules/lru-cache": { + "version": "6.0.0", + "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-6.0.0.tgz", + "integrity": "sha512-Jo6dJ04CmSjuznwJSS3pUeWmd/H0ffTlkXXgwZi+eq1UCmqQwCh+eLsYOYCwY991i2Fah4h1BEMCx4qThGbsiA==", + "dev": true, + "dependencies": { + "yallist": "^4.0.0" + }, + "engines": { + "node": ">=10" + } + }, + "node_modules/jest-snapshot/node_modules/semver": { + "version": "7.3.8", + "resolved": "https://registry.npmjs.org/semver/-/semver-7.3.8.tgz", + "integrity": "sha512-NB1ctGL5rlHrPJtFDVIVzTyQylMLu9N9VICA6HSFJo8MCGVTMW6gfpicwKmmK/dAjTOrqu5l63JJOpDSrAis3A==", + "dev": true, + "dependencies": { + "lru-cache": "^6.0.0" + }, + "bin": { + "semver": "bin/semver.js" + }, + "engines": { + "node": ">=10" + } + }, + "node_modules/jest-snapshot/node_modules/yallist": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/yallist/-/yallist-4.0.0.tgz", + "integrity": "sha512-3wdGidZyq5PB084XLES5TpOSRA3wjXAlIWMhum2kRcv/41Sn2emQ0dycQW4uZXLejwKvg6EsvbdlVL+FYEct7A==", + "dev": true + }, + "node_modules/jest-util": { + "version": "29.5.0", + "resolved": "https://registry.npmjs.org/jest-util/-/jest-util-29.5.0.tgz", + "integrity": "sha512-RYMgG/MTadOr5t8KdhejfvUU82MxsCu5MF6KuDUHl+NuwzUt+Sm6jJWxTJVrDR1j5M/gJVCPKQEpWXY+yIQ6lQ==", + "dev": true, + "dependencies": { + "@jest/types": "^29.5.0", + "@types/node": "*", + "chalk": "^4.0.0", + "ci-info": "^3.2.0", + "graceful-fs": "^4.2.9", + "picomatch": "^2.2.3" + }, + "engines": { + "node": "^14.15.0 || ^16.10.0 || >=18.0.0" + } + }, + "node_modules/jest-validate": { + "version": "29.5.0", + "resolved": "https://registry.npmjs.org/jest-validate/-/jest-validate-29.5.0.tgz", + "integrity": "sha512-pC26etNIi+y3HV8A+tUGr/lph9B18GnzSRAkPaaZJIE1eFdiYm6/CewuiJQ8/RlfHd1u/8Ioi8/sJ+CmbA+zAQ==", + "dev": true, + "dependencies": { + "@jest/types": "^29.5.0", + "camelcase": "^6.2.0", + "chalk": "^4.0.0", + "jest-get-type": "^29.4.3", + "leven": "^3.1.0", + "pretty-format": "^29.5.0" + }, + "engines": { + "node": "^14.15.0 || ^16.10.0 || >=18.0.0" + } + }, + "node_modules/jest-validate/node_modules/camelcase": { + "version": "6.3.0", + "resolved": "https://registry.npmjs.org/camelcase/-/camelcase-6.3.0.tgz", + "integrity": "sha512-Gmy6FhYlCY7uOElZUSbxo2UCDH8owEk996gkbrpsgGtrJLM3J7jGxl9Ic7Qwwj4ivOE5AWZWRMecDdF7hqGjFA==", + "dev": true, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/jest-watcher": { + "version": "29.5.0", + "resolved": "https://registry.npmjs.org/jest-watcher/-/jest-watcher-29.5.0.tgz", + "integrity": "sha512-KmTojKcapuqYrKDpRwfqcQ3zjMlwu27SYext9pt4GlF5FUgB+7XE1mcCnSm6a4uUpFyQIkb6ZhzZvHl+jiBCiA==", + "dev": true, + "dependencies": { + "@jest/test-result": "^29.5.0", + "@jest/types": "^29.5.0", + "@types/node": "*", + "ansi-escapes": "^4.2.1", + "chalk": "^4.0.0", + "emittery": "^0.13.1", + "jest-util": "^29.5.0", + "string-length": "^4.0.1" + }, + "engines": { + "node": "^14.15.0 || ^16.10.0 || >=18.0.0" + } + }, + "node_modules/jest-worker": { + "version": "29.5.0", + "resolved": "https://registry.npmjs.org/jest-worker/-/jest-worker-29.5.0.tgz", + "integrity": "sha512-NcrQnevGoSp4b5kg+akIpthoAFHxPBcb5P6mYPY0fUNT+sSvmtu6jlkEle3anczUKIKEbMxFimk9oTP/tpIPgA==", + "dev": true, + "dependencies": { + "@types/node": "*", + "jest-util": "^29.5.0", + "merge-stream": "^2.0.0", + "supports-color": "^8.0.0" + }, + "engines": { + "node": "^14.15.0 || ^16.10.0 || >=18.0.0" + } + }, + "node_modules/jest-worker/node_modules/supports-color": { + "version": "8.1.1", + "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-8.1.1.tgz", + "integrity": "sha512-MpUEN2OodtUzxvKQl72cUF7RQ5EiHsGvSsVG0ia9c5RbWGL2CI4C7EpPS8UTBIplnlzZiNuV56w+FuNxy3ty2Q==", + "dev": true, + "dependencies": { + "has-flag": "^4.0.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/chalk/supports-color?sponsor=1" + } + }, + "node_modules/js-sdsl": { + "version": "4.3.0", + "resolved": "https://registry.npmjs.org/js-sdsl/-/js-sdsl-4.3.0.tgz", + "integrity": "sha512-mifzlm2+5nZ+lEcLJMoBK0/IH/bDg8XnJfd/Wq6IP+xoCjLZsTOnV2QpxlVbX9bMnkl5PdEjNtBJ9Cj1NjifhQ==", + "dev": true, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/js-sdsl" + } + }, + "node_modules/js-tokens": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/js-tokens/-/js-tokens-4.0.0.tgz", + "integrity": "sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ==", + "dev": true + }, + "node_modules/js-yaml": { + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-4.1.0.tgz", + "integrity": "sha512-wpxZs9NoxZaJESJGIZTyDEaYpl0FKSA+FB9aJiyemKhMwkxQg63h4T1KJgUGHpTqPDNRcmmYLugrRjJlBtWvRA==", + "dev": true, + "dependencies": { + "argparse": "^2.0.1" + }, + "bin": { + "js-yaml": "bin/js-yaml.js" + } + }, + "node_modules/jsesc": { + "version": "2.5.2", + "resolved": "https://registry.npmjs.org/jsesc/-/jsesc-2.5.2.tgz", + "integrity": "sha512-OYu7XEzjkCQ3C5Ps3QIZsQfNpqoJyZZA99wd9aWd05NCtC5pWOkShK2mkL6HXQR6/Cy2lbNdPlZBpuQHXE63gA==", + "dev": true, + "bin": { + "jsesc": "bin/jsesc" + }, + "engines": { + "node": ">=4" + } + }, + "node_modules/json-diff": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/json-diff/-/json-diff-1.0.3.tgz", + "integrity": "sha512-W0yk/xzjz7bag9v9eS4qthvPG4O07uxNeXwirhvcOqmX4w8HLtB/Pw76o5Z7Pblwvf4vpCi4+iHOlHDnmav/rA==", + "dev": true, + "dependencies": { + "@ewoudenberg/difflib": "0.1.0", + "colors": "^1.4.0", + "dreamopt": "~0.8.0" + }, + "bin": { + "json-diff": "bin/json-diff.js" + }, + "engines": { + "node": "*" + } + }, + "node_modules/json-parse-even-better-errors": { + "version": "2.3.1", + "resolved": "https://registry.npmjs.org/json-parse-even-better-errors/-/json-parse-even-better-errors-2.3.1.tgz", + "integrity": "sha512-xyFwyhro/JEof6Ghe2iz2NcXoj2sloNsWr/XsERDK/oiPCfaNhl5ONfp+jQdAZRQQ0IJWNzH9zIZF7li91kh2w==", + "dev": true + }, + "node_modules/json-schema-traverse": { + "version": "0.4.1", + "resolved": "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-0.4.1.tgz", + "integrity": "sha512-xbbCH5dCYU5T8LcEhhuh7HJ88HXuW3qsI3Y0zOZFKfZEHcpWiHU/Jxzk629Brsab/mMiHQti9wMP+845RPe3Vg==", + "dev": true + }, + "node_modules/json-stable-stringify-without-jsonify": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/json-stable-stringify-without-jsonify/-/json-stable-stringify-without-jsonify-1.0.1.tgz", + "integrity": "sha512-Bdboy+l7tA3OGW6FjyFHWkP5LuByj1Tk33Ljyq0axyzdk9//JSi2u3fP1QSmd1KNwq6VOKYGlAu87CisVir6Pw==", + "dev": true + }, + "node_modules/json-stringify-safe": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/json-stringify-safe/-/json-stringify-safe-5.0.1.tgz", + "integrity": "sha512-ZClg6AaYvamvYEE82d3Iyd3vSSIjQ+odgjaTzRuO3s7toCdFKczob2i0zCh7JE8kWn17yvAWhUVxvqGwUalsRA==", + "dev": true + }, + "node_modules/json5": { + "version": "2.2.3", + "resolved": "https://registry.npmjs.org/json5/-/json5-2.2.3.tgz", + "integrity": "sha512-XmOWe7eyHYH14cLdVPoyg+GOH3rYX++KpzrylJwSW98t3Nk+U8XOl8FWKOgwtzdb8lXGf6zYwDUzeHMWfxasyg==", + "dev": true, + "bin": { + "json5": "lib/cli.js" + }, + "engines": { + "node": ">=6" + } + }, + "node_modules/kleur": { + "version": "3.0.3", + "resolved": "https://registry.npmjs.org/kleur/-/kleur-3.0.3.tgz", + "integrity": "sha512-eTIzlVOSUR+JxdDFepEYcBMtZ9Qqdef+rnzWdRZuMbOywu5tO2w2N7rqjoANZ5k9vywhL6Br1VRjUIgTQx4E8w==", + "dev": true, + "engines": { + "node": ">=6" + } + }, + "node_modules/leven": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/leven/-/leven-3.1.0.tgz", + "integrity": "sha512-qsda+H8jTaUaN/x5vzW2rzc+8Rw4TAQ/4KjB46IwK5VH+IlVeeeje/EoZRpiXvIqjFgK84QffqPztGI3VBLG1A==", + "dev": true, + "engines": { + "node": ">=6" + } + }, + "node_modules/levn": { + "version": "0.4.1", + "resolved": "https://registry.npmjs.org/levn/-/levn-0.4.1.tgz", + "integrity": "sha512-+bT2uH4E5LGE7h/n3evcS/sQlJXCpIp6ym8OWJ5eV6+67Dsql/LaaT7qJBAt2rzfoa/5QBGBhxDix1dMt2kQKQ==", + "dev": true, + "dependencies": { + "prelude-ls": "^1.2.1", + "type-check": "~0.4.0" + }, + "engines": { + "node": ">= 0.8.0" + } + }, + "node_modules/libxmljs": { + "version": "0.19.10", + "resolved": "https://registry.npmjs.org/libxmljs/-/libxmljs-0.19.10.tgz", + "integrity": "sha512-RY5/MD8Po8sGVocbODbYcdrbP6pJyA171LjFyd7Bp9wwxhmA8C5bm/VmXfpdED07fdW0FeC3lopxhG7UbwGx+g==", + "hasInstallScript": true, + "dependencies": { + "@mapbox/node-pre-gyp": "^1.0.9", + "bindings": "~1.3.0", + "nan": "~2.14.0" + }, + "engines": { + "node": ">=0.8.0" + } + }, + "node_modules/lines-and-columns": { + "version": "1.2.4", + "resolved": "https://registry.npmjs.org/lines-and-columns/-/lines-and-columns-1.2.4.tgz", + "integrity": "sha512-7ylylesZQ/PV29jhEDl3Ufjo6ZX7gCqJr5F7PKrqc93v7fzSymt1BpwEU8nAUXs8qzzvqhbjhK5QZg6Mt/HkBg==", + "dev": true + }, + "node_modules/locate-path": { + "version": "6.0.0", + "resolved": "https://registry.npmjs.org/locate-path/-/locate-path-6.0.0.tgz", + "integrity": "sha512-iPZK6eYjbxRu3uB4/WZ3EsEIMJFMqAoopl3R+zuq0UjcAm/MO6KCweDgPfP3elTztoKP3KtnVHxTn2NHBSDVUw==", + "dev": true, + "dependencies": { + "p-locate": "^5.0.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/lodash": { + "version": "4.17.21", + "resolved": "https://registry.npmjs.org/lodash/-/lodash-4.17.21.tgz", + "integrity": "sha512-v2kDEe57lecTulaDIuNTPy3Ry4gLGJ6Z1O3vE1krgXZNrsQ+LFTGHVxVjcXPs17LhbZVGedAJv8XZ1tvj5FvSg==", + "dev": true + }, + "node_modules/lodash.escape": { + "version": "4.0.1", + "resolved": "https://registry.npmjs.org/lodash.escape/-/lodash.escape-4.0.1.tgz", + "integrity": "sha512-nXEOnb/jK9g0DYMr1/Xvq6l5xMD7GDG55+GSYIYmS0G4tBk/hURD4JR9WCavs04t33WmJx9kCyp9vJ+mr4BOUw==", + "dev": true + }, + "node_modules/lodash.flattendeep": { + "version": "4.4.0", + "resolved": "https://registry.npmjs.org/lodash.flattendeep/-/lodash.flattendeep-4.4.0.tgz", + "integrity": "sha512-uHaJFihxmJcEX3kT4I23ABqKKalJ/zDrDg0lsFtc1h+3uw49SIJ5beyhx5ExVRti3AvKoOJngIj7xz3oylPdWQ==", + "dev": true + }, + "node_modules/lodash.isequal": { + "version": "4.5.0", + "resolved": "https://registry.npmjs.org/lodash.isequal/-/lodash.isequal-4.5.0.tgz", + "integrity": "sha512-pDo3lu8Jhfjqls6GkMgpahsF9kCyayhgykjyLMNFTKWrpVdAQtYyB4muAMWozBB4ig/dtWAmsMxLEI8wuz+DYQ==", + "dev": true + }, + "node_modules/lodash.merge": { + "version": "4.6.2", + "resolved": "https://registry.npmjs.org/lodash.merge/-/lodash.merge-4.6.2.tgz", + "integrity": "sha512-0KpjqXRVvrYyCsX1swR/XTK0va6VQkQM6MNo7PqW77ByjAhoARA8EfrP1N4+KlKj8YS0ZUCtRT/YUuhyYDujIQ==", + "dev": true + }, + "node_modules/lru-cache": { + "version": "5.1.1", + "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-5.1.1.tgz", + "integrity": "sha512-KpNARQA3Iwv+jTA0utUVVbrh+Jlrr1Fv0e56GGzAFOXN7dk/FviaDW8LHmK52DlcH4WP2n6gI8vN1aesBFgo9w==", + "dev": true, + "dependencies": { + "yallist": "^3.0.2" + } + }, + "node_modules/make-dir": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/make-dir/-/make-dir-3.1.0.tgz", + "integrity": "sha512-g3FeP20LNwhALb/6Cz6Dd4F2ngze0jz7tbzrD2wAV+o9FeNHe4rL+yK2md0J/fiSf1sa1ADhXqi5+oVwOM/eGw==", + "dependencies": { + "semver": "^6.0.0" + }, + "engines": { + "node": ">=8" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/makeerror": { + "version": "1.0.12", + "resolved": "https://registry.npmjs.org/makeerror/-/makeerror-1.0.12.tgz", + "integrity": "sha512-JmqCvUhmt43madlpFzG4BQzG2Z3m6tvQDNKdClZnO3VbIudJYmxsT0FNJMeiB2+JTSlTQTSbU8QdesVmwJcmLg==", + "dev": true, + "dependencies": { + "tmpl": "1.0.5" + } + }, + "node_modules/merge-stream": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/merge-stream/-/merge-stream-2.0.0.tgz", + "integrity": "sha512-abv/qOcuPfk3URPfDzmZU1LKmuw8kT+0nIHvKrKgFrwifol/doWcdA4ZqsWQ8ENrFKkd67Mfpo/LovbIUsbt3w==", + "dev": true + }, + "node_modules/micromatch": { + "version": "4.0.5", + "resolved": "https://registry.npmjs.org/micromatch/-/micromatch-4.0.5.tgz", + "integrity": "sha512-DMy+ERcEW2q8Z2Po+WNXuw3c5YaUSFjAO5GsJqfEl7UjvtIuFKO6ZrKvcItdy98dwFI2N1tg3zNIdKaQT+aNdA==", + "dev": true, + "dependencies": { + "braces": "^3.0.2", + "picomatch": "^2.3.1" + }, + "engines": { + "node": ">=8.6" + } + }, + "node_modules/mimic-fn": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/mimic-fn/-/mimic-fn-2.1.0.tgz", + "integrity": "sha512-OqbOk5oEQeAZ8WXWydlu9HJjz9WVdEIvamMCcXmuqUYjTknH/sqsWvhQ3vgwKFRR1HpjvNBKQ37nbJgYzGqGcg==", + "dev": true, + "engines": { + "node": ">=6" + } + }, + "node_modules/minimatch": { + "version": "3.1.2", + "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.2.tgz", + "integrity": "sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==", + "dependencies": { + "brace-expansion": "^1.1.7" + }, + "engines": { + "node": "*" + } + }, + "node_modules/minipass": { + "version": "4.2.4", + "resolved": "https://registry.npmjs.org/minipass/-/minipass-4.2.4.tgz", + "integrity": "sha512-lwycX3cBMTvcejsHITUgYj6Gy6A7Nh4Q6h9NP4sTHY1ccJlC7yKzDmiShEHsJ16Jf1nKGDEaiHxiltsJEvk0nQ==", + "engines": { + "node": ">=8" + } + }, + "node_modules/minizlib": { + "version": "2.1.2", + "resolved": "https://registry.npmjs.org/minizlib/-/minizlib-2.1.2.tgz", + "integrity": "sha512-bAxsR8BVfj60DWXHE3u30oHzfl4G7khkSuPW+qvpd7jFRHm7dLxOjUk1EHACJ/hxLY8phGJ0YhYHZo7jil7Qdg==", + "dependencies": { + "minipass": "^3.0.0", + "yallist": "^4.0.0" + }, + "engines": { + "node": ">= 8" + } + }, + "node_modules/minizlib/node_modules/minipass": { + "version": "3.3.6", + "resolved": "https://registry.npmjs.org/minipass/-/minipass-3.3.6.tgz", + "integrity": "sha512-DxiNidxSEK+tHG6zOIklvNOwm3hvCrbUrdtzY74U6HKTJxvIDfOUL5W5P2Ghd3DTkhhKPYGqeNUIh5qcM4YBfw==", + "dependencies": { + "yallist": "^4.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/minizlib/node_modules/yallist": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/yallist/-/yallist-4.0.0.tgz", + "integrity": "sha512-3wdGidZyq5PB084XLES5TpOSRA3wjXAlIWMhum2kRcv/41Sn2emQ0dycQW4uZXLejwKvg6EsvbdlVL+FYEct7A==" + }, + "node_modules/mkdirp": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/mkdirp/-/mkdirp-1.0.4.tgz", + "integrity": "sha512-vVqVZQyf3WLx2Shd0qJ9xuvqgAyKPLAiqITEtqW0oIUjzo3PePDd6fW9iFz30ef7Ysp/oiWqbhszeGWW2T6Gzw==", + "bin": { + "mkdirp": "bin/cmd.js" + }, + "engines": { + "node": ">=10" + } + }, + "node_modules/moo": { + "version": "0.5.2", + "resolved": "https://registry.npmjs.org/moo/-/moo-0.5.2.tgz", + "integrity": "sha512-iSAJLHYKnX41mKcJKjqvnAN9sf0LMDTXDEvFv+ffuRR9a1MIuXLjMNL6EsnDHSkKLTWNqQQ5uo61P4EbU4NU+Q==", + "dev": true + }, + "node_modules/ms": { + "version": "2.1.2", + "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.2.tgz", + "integrity": "sha512-sGkPx+VjMtmA6MX27oA4FBFELFCZZ4S4XqeGOXCv68tT+jb3vk/RyaKWP0PTKyWtmLSM0b+adUTEvbs1PEaH2w==" + }, + "node_modules/nan": { + "version": "2.14.2", + "resolved": "https://registry.npmjs.org/nan/-/nan-2.14.2.tgz", + "integrity": "sha512-M2ufzIiINKCuDfBSAUr1vWQ+vuVcA9kqx8JJUsbQi6yf1uGRyb7HfpdfUr5qLXf3B/t8dPvcjhKMmlfnP47EzQ==" + }, + "node_modules/natural-compare": { + "version": "1.4.0", + "resolved": "https://registry.npmjs.org/natural-compare/-/natural-compare-1.4.0.tgz", + "integrity": "sha512-OWND8ei3VtNC9h7V60qff3SVobHr996CTwgxubgyQYEpg290h9J0buyECNNJexkFm5sOajh5G116RYA1c8ZMSw==", + "dev": true + }, + "node_modules/nearley": { + "version": "2.20.1", + "resolved": "https://registry.npmjs.org/nearley/-/nearley-2.20.1.tgz", + "integrity": "sha512-+Mc8UaAebFzgV+KpI5n7DasuuQCHA89dmwm7JXw3TV43ukfNQ9DnBH3Mdb2g/I4Fdxc26pwimBWvjIw0UAILSQ==", + "dev": true, + "dependencies": { + "commander": "^2.19.0", + "moo": "^0.5.0", + "railroad-diagrams": "^1.0.0", + "randexp": "0.4.6" + }, + "bin": { + "nearley-railroad": "bin/nearley-railroad.js", + "nearley-test": "bin/nearley-test.js", + "nearley-unparse": "bin/nearley-unparse.js", + "nearleyc": "bin/nearleyc.js" + }, + "funding": { + "type": "individual", + "url": "https://nearley.js.org/#give-to-nearley" + } + }, + "node_modules/nock": { + "version": "13.3.0", + "resolved": "https://registry.npmjs.org/nock/-/nock-13.3.0.tgz", + "integrity": "sha512-HHqYQ6mBeiMc+N038w8LkMpDCRquCHWeNmN3v6645P3NhN2+qXOBqvPqo7Rt1VyCMzKhJ733wZqw5B7cQVFNPg==", + "dev": true, + "dependencies": { + "debug": "^4.1.0", + "json-stringify-safe": "^5.0.1", + "lodash": "^4.17.21", + "propagate": "^2.0.0" + }, + "engines": { + "node": ">= 10.13" + } + }, + "node_modules/node-fetch": { + "version": "2.6.9", + "resolved": "https://registry.npmjs.org/node-fetch/-/node-fetch-2.6.9.tgz", + "integrity": "sha512-DJm/CJkZkRjKKj4Zi4BsKVZh3ValV5IR5s7LVZnW+6YMh0W1BfNA8XSs6DLMGYlId5F3KnA70uu2qepcR08Qqg==", + "dependencies": { + "whatwg-url": "^5.0.0" + }, + "engines": { + "node": "4.x || >=6.0.0" + }, + "peerDependencies": { + "encoding": "^0.1.0" + }, + "peerDependenciesMeta": { + "encoding": { + "optional": true + } + } + }, + "node_modules/node-int64": { + "version": "0.4.0", + "resolved": "https://registry.npmjs.org/node-int64/-/node-int64-0.4.0.tgz", + "integrity": "sha512-O5lz91xSOeoXP6DulyHfllpq+Eg00MWitZIbtPfoSEvqIHdl5gfcY6hYzDWnj0qD5tz52PI08u9qUvSVeUBeHw==", + "dev": true + }, + "node_modules/node-releases": { + "version": "2.0.10", + "resolved": "https://registry.npmjs.org/node-releases/-/node-releases-2.0.10.tgz", + "integrity": "sha512-5GFldHPXVG/YZmFzJvKK2zDSzPKhEp0+ZR5SVaoSag9fsL5YgHbUHDfnG5494ISANDcK4KwPXAx2xqVEydmd7w==", + "dev": true + }, + "node_modules/nopt": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/nopt/-/nopt-5.0.0.tgz", + "integrity": "sha512-Tbj67rffqceeLpcRXrT7vKAN8CwfPeIBgM7E6iBkmKLV7bEMwpGgYLGv0jACUsECaa/vuxP0IjEont6umdMgtQ==", + "dependencies": { + "abbrev": "1" + }, + "bin": { + "nopt": "bin/nopt.js" + }, + "engines": { + "node": ">=6" + } + }, + "node_modules/normalize-path": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/normalize-path/-/normalize-path-3.0.0.tgz", + "integrity": "sha512-6eZs5Ls3WtCisHWp9S2GUy8dqkpGi4BVSz3GaqiE6ezub0512ESztXUwUB6C6IKbQkY2Pnb/mD4WYojCRwcwLA==", + "dev": true, + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/npm-run-path": { + "version": "4.0.1", + "resolved": "https://registry.npmjs.org/npm-run-path/-/npm-run-path-4.0.1.tgz", + "integrity": "sha512-S48WzZW777zhNIrn7gxOlISNAqi9ZC/uQFnRdbeIHhZhCA6UqpkOT8T1G7BvfdgP4Er8gF4sUbaS0i7QvIfCWw==", + "dev": true, + "dependencies": { + "path-key": "^3.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/npmlog": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/npmlog/-/npmlog-5.0.1.tgz", + "integrity": "sha512-AqZtDUWOMKs1G/8lwylVjrdYgqA4d9nu8hc+0gzRxlDb1I10+FHBGMXs6aiQHFdCUUlqH99MUMuLfzWDNDtfxw==", + "dependencies": { + "are-we-there-yet": "^2.0.0", + "console-control-strings": "^1.1.0", + "gauge": "^3.0.0", + "set-blocking": "^2.0.0" + } + }, + "node_modules/nth-check": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/nth-check/-/nth-check-2.1.1.tgz", + "integrity": "sha512-lqjrjmaOoAnWfMmBPL+XNnynZh2+swxiX3WUE0s4yEHI6m+AwrK2UZOimIRl3X/4QctVqS8AiZjFqyOGrMXb/w==", + "dev": true, + "dependencies": { + "boolbase": "^1.0.0" + }, + "funding": { + "url": "https://github.com/fb55/nth-check?sponsor=1" + } + }, + "node_modules/object-assign": { + "version": "4.1.1", + "resolved": "https://registry.npmjs.org/object-assign/-/object-assign-4.1.1.tgz", + "integrity": "sha512-rJgTQnkUnH1sFw8yT6VSU3zD3sWmu6sZhIseY8VX+GRu3P6F7Fu+JNDoXfklElbLJSnc3FUQHVe4cU5hj+BcUg==", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/object-inspect": { + "version": "1.12.3", + "resolved": "https://registry.npmjs.org/object-inspect/-/object-inspect-1.12.3.tgz", + "integrity": "sha512-geUvdk7c+eizMNUDkRpW1wJwgfOiOeHbxBR/hLXK1aT6zmVSO0jsQcs7fj6MGw89jC/cjGfLcNOrtMYtGqm81g==", + "dev": true, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/object-is": { + "version": "1.1.5", + "resolved": "https://registry.npmjs.org/object-is/-/object-is-1.1.5.tgz", + "integrity": "sha512-3cyDsyHgtmi7I7DfSSI2LDp6SK2lwvtbg0p0R1e0RvTqF5ceGx+K2dfSjm1bKDMVCFEDAQvy+o8c6a7VujOddw==", + "dev": true, + "dependencies": { + "call-bind": "^1.0.2", + "define-properties": "^1.1.3" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/object-keys": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/object-keys/-/object-keys-1.1.1.tgz", + "integrity": "sha512-NuAESUOUMrlIXOfHKzD6bpPu3tYt3xvjNdRIQ+FeT0lNb4K8WR70CaDxhuNguS2XG+GjkyMwOzsN5ZktImfhLA==", + "dev": true, + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/object.assign": { + "version": "4.1.4", + "resolved": "https://registry.npmjs.org/object.assign/-/object.assign-4.1.4.tgz", + "integrity": "sha512-1mxKf0e58bvyjSCtKYY4sRe9itRk3PJpquJOjeIkz885CczcI4IvJJDLPS72oowuSh+pBxUFROpX+TU++hxhZQ==", + "dev": true, + "dependencies": { + "call-bind": "^1.0.2", + "define-properties": "^1.1.4", + "has-symbols": "^1.0.3", + "object-keys": "^1.1.1" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/object.entries": { + "version": "1.1.6", + "resolved": "https://registry.npmjs.org/object.entries/-/object.entries-1.1.6.tgz", + "integrity": "sha512-leTPzo4Zvg3pmbQ3rDK69Rl8GQvIqMWubrkxONG9/ojtFE2rD9fjMKfSI5BxW3osRH1m6VdzmqK8oAY9aT4x5w==", + "dev": true, + "dependencies": { + "call-bind": "^1.0.2", + "define-properties": "^1.1.4", + "es-abstract": "^1.20.4" + }, + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/object.values": { + "version": "1.1.6", + "resolved": "https://registry.npmjs.org/object.values/-/object.values-1.1.6.tgz", + "integrity": "sha512-FVVTkD1vENCsAcwNs9k6jea2uHC/X0+JcjG8YA60FN5CMaJmG95wT9jek/xX9nornqGRrBkKtzuAu2wuHpKqvw==", + "dev": true, + "dependencies": { + "call-bind": "^1.0.2", + "define-properties": "^1.1.4", + "es-abstract": "^1.20.4" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/once": { + "version": "1.4.0", + "resolved": "https://registry.npmjs.org/once/-/once-1.4.0.tgz", + "integrity": "sha512-lNaJgI+2Q5URQBkccEKHTQOPaXdUxnZZElQTZY0MFUAuaEqe1E+Nyvgdz/aIyNi6Z9MzO5dv1H8n58/GELp3+w==", + "dependencies": { + "wrappy": "1" + } + }, + "node_modules/onetime": { + "version": "5.1.2", + "resolved": "https://registry.npmjs.org/onetime/-/onetime-5.1.2.tgz", + "integrity": "sha512-kbpaSSGJTWdAY5KPVeMOKXSrPtr8C8C7wodJbcsd51jRnmD+GZu8Y0VoU6Dm5Z4vWr0Ig/1NKuWRKf7j5aaYSg==", + "dev": true, + "dependencies": { + "mimic-fn": "^2.1.0" + }, + "engines": { + "node": ">=6" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/optionator": { + "version": "0.9.1", + "resolved": "https://registry.npmjs.org/optionator/-/optionator-0.9.1.tgz", + "integrity": "sha512-74RlY5FCnhq4jRxVUPKDaRwrVNXMqsGsiW6AJw4XK8hmtm10wC0ypZBLw5IIp85NZMr91+qd1RvvENwg7jjRFw==", + "dev": true, + "dependencies": { + "deep-is": "^0.1.3", + "fast-levenshtein": "^2.0.6", + "levn": "^0.4.1", + "prelude-ls": "^1.2.1", + "type-check": "^0.4.0", + "word-wrap": "^1.2.3" + }, + "engines": { + "node": ">= 0.8.0" + } + }, + "node_modules/p-limit": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/p-limit/-/p-limit-3.1.0.tgz", + "integrity": "sha512-TYOanM3wGwNGsZN2cVTYPArw454xnXj5qmWF1bEoAc4+cU/ol7GVh7odevjp1FNHduHc3KZMcFduxU5Xc6uJRQ==", + "dev": true, + "dependencies": { + "yocto-queue": "^0.1.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/p-locate": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/p-locate/-/p-locate-5.0.0.tgz", + "integrity": "sha512-LaNjtRWUBY++zB5nE/NwcaoMylSPk+S+ZHNB1TzdbMJMny6dynpAGt7X/tl/QYq3TIeE6nxHppbo2LGymrG5Pw==", + "dev": true, + "dependencies": { + "p-limit": "^3.0.2" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/p-try": { + "version": "2.2.0", + "resolved": "https://registry.npmjs.org/p-try/-/p-try-2.2.0.tgz", + "integrity": "sha512-R4nPAVTAU0B9D35/Gk3uJf/7XYbQcyohSKdvAxIRSNghFl4e71hVoGnBNQz9cWaXxO2I10KTC+3jMdvvoKw6dQ==", + "dev": true, + "engines": { + "node": ">=6" + } + }, + "node_modules/parent-module": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/parent-module/-/parent-module-1.0.1.tgz", + "integrity": "sha512-GQ2EWRpQV8/o+Aw8YqtfZZPfNRWZYkbidE9k5rpl/hC3vtHHBfGm2Ifi6qWV+coDGkrUKZAxE3Lot5kcsRlh+g==", + "dev": true, + "dependencies": { + "callsites": "^3.0.0" + }, + "engines": { + "node": ">=6" + } + }, + "node_modules/parse-json": { + "version": "5.2.0", + "resolved": "https://registry.npmjs.org/parse-json/-/parse-json-5.2.0.tgz", + "integrity": "sha512-ayCKvm/phCGxOkYRSCM82iDwct8/EonSEgCSxWxD7ve6jHggsFl4fZVQBPRNgQoKiuV/odhFrGzQXZwbifC8Rg==", + "dev": true, + "dependencies": { + "@babel/code-frame": "^7.0.0", + "error-ex": "^1.3.1", + "json-parse-even-better-errors": "^2.3.0", + "lines-and-columns": "^1.1.6" + }, + "engines": { + "node": ">=8" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/parse5": { + "version": "7.1.2", + "resolved": "https://registry.npmjs.org/parse5/-/parse5-7.1.2.tgz", + "integrity": "sha512-Czj1WaSVpaoj0wbhMzLmWD69anp2WH7FXMB9n1Sy8/ZFF9jolSQVMu1Ij5WIyGmcBmhk7EOndpO4mIpihVqAXw==", + "dev": true, + "dependencies": { + "entities": "^4.4.0" + }, + "funding": { + "url": "https://github.com/inikulin/parse5?sponsor=1" + } + }, + "node_modules/parse5-htmlparser2-tree-adapter": { + "version": "7.0.0", + "resolved": "https://registry.npmjs.org/parse5-htmlparser2-tree-adapter/-/parse5-htmlparser2-tree-adapter-7.0.0.tgz", + "integrity": "sha512-B77tOZrqqfUfnVcOrUvfdLbz4pu4RopLD/4vmu3HUPswwTA8OH0EMW9BlWR2B0RCoiZRAHEUu7IxeP1Pd1UU+g==", + "dev": true, + "dependencies": { + "domhandler": "^5.0.2", + "parse5": "^7.0.0" + }, + "funding": { + "url": "https://github.com/inikulin/parse5?sponsor=1" + } + }, + "node_modules/path-exists": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/path-exists/-/path-exists-4.0.0.tgz", + "integrity": "sha512-ak9Qy5Q7jYb2Wwcey5Fpvg2KoAc/ZIhLSLOSBmRmygPsGwkVVt0fZa0qrtMz+m6tJTAHfZQ8FnmB4MG4LWy7/w==", + "dev": true, + "engines": { + "node": ">=8" + } + }, + "node_modules/path-is-absolute": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/path-is-absolute/-/path-is-absolute-1.0.1.tgz", + "integrity": "sha512-AVbw3UJ2e9bq64vSaS9Am0fje1Pa8pbGqTTsmXfaIiMpnr5DlDhfJOuLj9Sf95ZPVDAUerDfEk88MPmPe7UCQg==", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/path-key": { + "version": "3.1.1", + "resolved": "https://registry.npmjs.org/path-key/-/path-key-3.1.1.tgz", + "integrity": "sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q==", + "dev": true, + "engines": { + "node": ">=8" + } + }, + "node_modules/path-parse": { + "version": "1.0.7", + "resolved": "https://registry.npmjs.org/path-parse/-/path-parse-1.0.7.tgz", + "integrity": "sha512-LDJzPVEEEPR+y48z93A0Ed0yXb8pAByGWo/k5YYdYgpY2/2EsOsksJrq7lOHxryrVOn1ejG6oAp8ahvOIQD8sw==", + "dev": true + }, + "node_modules/performance-now": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/performance-now/-/performance-now-2.1.0.tgz", + "integrity": "sha512-7EAHlyLHI56VEIdK57uwHdHKIaAGbnXPiw0yWbarQZOKaKpvUIgW0jWRVLiatnM+XXlSwsanIBH/hzGMJulMow==", + "dev": true + }, + "node_modules/picocolors": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/picocolors/-/picocolors-1.0.0.tgz", + "integrity": "sha512-1fygroTLlHu66zi26VoTDv8yRgm0Fccecssto+MhsZ0D/DGW2sm8E8AjW7NU5VVTRt5GxbeZ5qBuJr+HyLYkjQ==", + "dev": true + }, + "node_modules/picomatch": { + "version": "2.3.1", + "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-2.3.1.tgz", + "integrity": "sha512-JU3teHTNjmE2VCGFzuY8EXzCDVwEqB2a8fsIvwaStHhAWJEeVd1o1QD80CU6+ZdEXXSLbSsuLwJjkCBWqRQUVA==", + "dev": true, + "engines": { + "node": ">=8.6" + }, + "funding": { + "url": "https://github.com/sponsors/jonschlinkert" + } + }, + "node_modules/pirates": { + "version": "4.0.5", + "resolved": "https://registry.npmjs.org/pirates/-/pirates-4.0.5.tgz", + "integrity": "sha512-8V9+HQPupnaXMA23c5hvl69zXvTwTzyAYasnkb0Tts4XvO4CliqONMOnvlq26rkhLC3nWDFBJf73LU1e1VZLaQ==", + "dev": true, + "engines": { + "node": ">= 6" + } + }, + "node_modules/pkg-dir": { + "version": "4.2.0", + "resolved": "https://registry.npmjs.org/pkg-dir/-/pkg-dir-4.2.0.tgz", + "integrity": "sha512-HRDzbaKjC+AOWVXxAU/x54COGeIv9eb+6CkDSQoNTt4XyWoIJvuPsXizxu/Fr23EiekbtZwmh1IcIG/l/a10GQ==", + "dev": true, + "dependencies": { + "find-up": "^4.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/pkg-dir/node_modules/find-up": { + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/find-up/-/find-up-4.1.0.tgz", + "integrity": "sha512-PpOwAdQ/YlXQ2vj8a3h8IipDuYRi3wceVQQGYWxNINccq40Anw7BlsEXCMbt1Zt+OLA6Fq9suIpIWD0OsnISlw==", + "dev": true, + "dependencies": { + "locate-path": "^5.0.0", + "path-exists": "^4.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/pkg-dir/node_modules/locate-path": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/locate-path/-/locate-path-5.0.0.tgz", + "integrity": "sha512-t7hw9pI+WvuwNJXwk5zVHpyhIqzg2qTlklJOf0mVxGSbe3Fp2VieZcduNYjaLDoy6p9uGpQEGWG87WpMKlNq8g==", + "dev": true, + "dependencies": { + "p-locate": "^4.1.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/pkg-dir/node_modules/p-limit": { + "version": "2.3.0", + "resolved": "https://registry.npmjs.org/p-limit/-/p-limit-2.3.0.tgz", + "integrity": "sha512-//88mFWSJx8lxCzwdAABTJL2MyWB12+eIY7MDL2SqLmAkeKU9qxRvWuSyTjm3FUmpBEMuFfckAIqEaVGUDxb6w==", + "dev": true, + "dependencies": { + "p-try": "^2.0.0" + }, + "engines": { + "node": ">=6" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/pkg-dir/node_modules/p-locate": { + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/p-locate/-/p-locate-4.1.0.tgz", + "integrity": "sha512-R79ZZ/0wAxKGu3oYMlz8jy/kbhsNrS7SKZ7PxEHBgJ5+F2mtFW2fK2cOtBh1cHYkQsbzFV7I+EoRKe6Yt0oK7A==", + "dev": true, + "dependencies": { + "p-limit": "^2.2.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/prelude-ls": { + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/prelude-ls/-/prelude-ls-1.2.1.tgz", + "integrity": "sha512-vkcDPrRZo1QZLbn5RLGPpg/WmIQ65qoWWhcGKf/b5eplkkarX0m9z8ppCat4mlOqUsWpyNuYgO3VRyrYHSzX5g==", + "dev": true, + "engines": { + "node": ">= 0.8.0" + } + }, + "node_modules/pretty-format": { + "version": "29.5.0", + "resolved": "https://registry.npmjs.org/pretty-format/-/pretty-format-29.5.0.tgz", + "integrity": "sha512-V2mGkI31qdttvTFX7Mt4efOqHXqJWMu4/r66Xh3Z3BwZaPfPJgp6/gbwoujRpPUtfEF6AUUWx3Jim3GCw5g/Qw==", + "dev": true, + "dependencies": { + "@jest/schemas": "^29.4.3", + "ansi-styles": "^5.0.0", + "react-is": "^18.0.0" + }, + "engines": { + "node": "^14.15.0 || ^16.10.0 || >=18.0.0" + } + }, + "node_modules/pretty-format/node_modules/ansi-styles": { + "version": "5.2.0", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-5.2.0.tgz", + "integrity": "sha512-Cxwpt2SfTzTtXcfOlzGEee8O+c+MmUgGrNiBcXnuWxuFJHe6a5Hz7qwhwe5OgaSYI0IJvkLqWX1ASG+cJOkEiA==", + "dev": true, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/chalk/ansi-styles?sponsor=1" + } + }, + "node_modules/prompts": { + "version": "2.4.2", + "resolved": "https://registry.npmjs.org/prompts/-/prompts-2.4.2.tgz", + "integrity": "sha512-NxNv/kLguCA7p3jE8oL2aEBsrJWgAakBpgmgK6lpPWV+WuOmY6r2/zbAVnP+T8bQlA0nzHXSJSJW0Hq7ylaD2Q==", + "dev": true, + "dependencies": { + "kleur": "^3.0.3", + "sisteransi": "^1.0.5" + }, + "engines": { + "node": ">= 6" + } + }, + "node_modules/propagate": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/propagate/-/propagate-2.0.1.tgz", + "integrity": "sha512-vGrhOavPSTz4QVNuBNdcNXePNdNMaO1xj9yBeH1ScQPjk/rhg9sSlCXPhMkFuaNNW/syTvYqsnbIJxMBfRbbag==", + "dev": true, + "engines": { + "node": ">= 8" + } + }, + "node_modules/punycode": { + "version": "2.3.0", + "resolved": "https://registry.npmjs.org/punycode/-/punycode-2.3.0.tgz", + "integrity": "sha512-rRV+zQD8tVFys26lAGR9WUuS4iUAngJScM+ZRSKtvl5tKeZ2t5bvdNFdNHBW9FWR4guGHlgmsZ1G7BSm2wTbuA==", + "dev": true, + "engines": { + "node": ">=6" + } + }, + "node_modules/pure-rand": { + "version": "6.0.0", + "resolved": "https://registry.npmjs.org/pure-rand/-/pure-rand-6.0.0.tgz", + "integrity": "sha512-rLSBxJjP+4DQOgcJAx6RZHT2he2pkhQdSnofG5VWyVl6GRq/K02ISOuOLcsMOrtKDIJb8JN2zm3FFzWNbezdPw==", + "dev": true, + "funding": [ + { + "type": "individual", + "url": "https://github.com/sponsors/dubzzz" + }, + { + "type": "opencollective", + "url": "https://opencollective.com/fast-check" + } + ] + }, + "node_modules/queue-microtask": { + "version": "1.2.3", + "resolved": "https://registry.npmjs.org/queue-microtask/-/queue-microtask-1.2.3.tgz", + "integrity": "sha512-NuaNSa6flKT5JaSYQzJok04JzTL1CA6aGhv5rfLW3PgqA+M2ChpZQnAC8h8i4ZFkBS8X5RqkDBHA7r4hej3K9A==", + "dev": true, + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/feross" + }, + { + "type": "patreon", + "url": "https://www.patreon.com/feross" + }, + { + "type": "consulting", + "url": "https://feross.org/support" + } + ] + }, + "node_modules/raf": { + "version": "3.4.1", + "resolved": "https://registry.npmjs.org/raf/-/raf-3.4.1.tgz", + "integrity": "sha512-Sq4CW4QhwOHE8ucn6J34MqtZCeWFP2aQSmrlroYgqAV1PjStIhJXxYuTgUIfkEk7zTLjmIjLmU5q+fbD1NnOJA==", + "dev": true, + "dependencies": { + "performance-now": "^2.1.0" + } + }, + "node_modules/railroad-diagrams": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/railroad-diagrams/-/railroad-diagrams-1.0.0.tgz", + "integrity": "sha512-cz93DjNeLY0idrCNOH6PviZGRN9GJhsdm9hpn1YCS879fj4W+x5IFJhhkRZcwVgMmFF7R82UA/7Oh+R8lLZg6A==", + "dev": true + }, + "node_modules/randexp": { + "version": "0.4.6", + "resolved": "https://registry.npmjs.org/randexp/-/randexp-0.4.6.tgz", + "integrity": "sha512-80WNmd9DA0tmZrw9qQa62GPPWfuXJknrmVmLcxvq4uZBdYqb1wYoKTmnlGUchvVWe0XiLupYkBoXVOxz3C8DYQ==", + "dev": true, + "dependencies": { + "discontinuous-range": "1.0.0", + "ret": "~0.1.10" + }, + "engines": { + "node": ">=0.12" + } + }, + "node_modules/react-is": { + "version": "18.2.0", + "resolved": "https://registry.npmjs.org/react-is/-/react-is-18.2.0.tgz", + "integrity": "sha512-xWGDIW6x921xtzPkhiULtthJHoJvBbF3q26fzloPCK0hsvxtPVelvftw3zjbHWSkR2km9Z+4uxbDDK/6Zw9B8w==", + "dev": true + }, + "node_modules/readable-stream": { + "version": "3.6.1", + "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-3.6.1.tgz", + "integrity": "sha512-+rQmrWMYGA90yenhTYsLWAsLsqVC8osOw6PKE1HDYiO0gdPeKe/xDHNzIAIn4C91YQ6oenEhfYqqc1883qHbjQ==", + "dependencies": { + "inherits": "^2.0.3", + "string_decoder": "^1.1.1", + "util-deprecate": "^1.0.1" + }, + "engines": { + "node": ">= 6" + } + }, + "node_modules/regexp.prototype.flags": { + "version": "1.4.3", + "resolved": "https://registry.npmjs.org/regexp.prototype.flags/-/regexp.prototype.flags-1.4.3.tgz", + "integrity": "sha512-fjggEOO3slI6Wvgjwflkc4NFRCTZAu5CnNfBd5qOMYhWdn67nJBBu34/TkD++eeFmd8C9r9jfXJ27+nSiRkSUA==", + "dev": true, + "dependencies": { + "call-bind": "^1.0.2", + "define-properties": "^1.1.3", + "functions-have-names": "^1.2.2" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/regexpp": { + "version": "3.2.0", + "resolved": "https://registry.npmjs.org/regexpp/-/regexpp-3.2.0.tgz", + "integrity": "sha512-pq2bWo9mVD43nbts2wGv17XLiNLya+GklZ8kaDLV2Z08gDCsGpnKn9BFMepvWuHCbyVvY7J5o5+BVvoQbmlJLg==", + "dev": true, + "engines": { + "node": ">=8" + }, + "funding": { + "url": "https://github.com/sponsors/mysticatea" + } + }, + "node_modules/require-directory": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/require-directory/-/require-directory-2.1.1.tgz", + "integrity": "sha512-fGxEI7+wsG9xrvdjsrlmL22OMTTiHRwAMroiEeMgq8gzoLC/PQr7RsRDSTLUg/bZAZtF+TVIkHc6/4RIKrui+Q==", + "dev": true, + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/resolve": { + "version": "1.22.1", + "resolved": "https://registry.npmjs.org/resolve/-/resolve-1.22.1.tgz", + "integrity": "sha512-nBpuuYuY5jFsli/JIs1oldw6fOQCBioohqWZg/2hiaOybXOft4lonv85uDOKXdf8rhyK159cxU5cDcK/NKk8zw==", + "dev": true, + "dependencies": { + "is-core-module": "^2.9.0", + "path-parse": "^1.0.7", + "supports-preserve-symlinks-flag": "^1.0.0" + }, + "bin": { + "resolve": "bin/resolve" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/resolve-cwd": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/resolve-cwd/-/resolve-cwd-3.0.0.tgz", + "integrity": "sha512-OrZaX2Mb+rJCpH/6CpSqt9xFVpN++x01XnN2ie9g6P5/3xelLAkXWVADpdz1IHD/KFfEXyE6V0U01OQ3UO2rEg==", + "dev": true, + "dependencies": { + "resolve-from": "^5.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/resolve-cwd/node_modules/resolve-from": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/resolve-from/-/resolve-from-5.0.0.tgz", + "integrity": "sha512-qYg9KP24dD5qka9J47d0aVky0N+b4fTU89LN9iDnjB5waksiC49rvMB0PrUJQGoTmH50XPiqOvAjDfaijGxYZw==", + "dev": true, + "engines": { + "node": ">=8" + } + }, + "node_modules/resolve-from": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/resolve-from/-/resolve-from-4.0.0.tgz", + "integrity": "sha512-pb/MYmXstAkysRFx8piNI1tGFNQIFA3vkE3Gq4EuA1dF6gHp/+vgZqsCGJapvy8N3Q+4o7FwvquPJcnZ7RYy4g==", + "dev": true, + "engines": { + "node": ">=4" + } + }, + "node_modules/resolve.exports": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/resolve.exports/-/resolve.exports-2.0.1.tgz", + "integrity": "sha512-OEJWVeimw8mgQuj3HfkNl4KqRevH7lzeQNaWRPfx0PPse7Jk6ozcsG4FKVgtzDsC1KUF+YlTHh17NcgHOPykLw==", + "dev": true, + "engines": { + "node": ">=10" + } + }, + "node_modules/ret": { + "version": "0.1.15", + "resolved": "https://registry.npmjs.org/ret/-/ret-0.1.15.tgz", + "integrity": "sha512-TTlYpa+OL+vMMNG24xSlQGEJ3B/RzEfUlLct7b5G/ytav+wPrplCpVMFuwzXbkecJrb6IYo1iFb0S9v37754mg==", + "dev": true, + "engines": { + "node": ">=0.12" + } + }, + "node_modules/reusify": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/reusify/-/reusify-1.0.4.tgz", + "integrity": "sha512-U9nH88a3fc/ekCF1l0/UP1IosiuIjyTh7hBvXVMHYgVcfGvt897Xguj2UOLDeI5BG2m7/uwyaLVT6fbtCwTyzw==", + "dev": true, + "engines": { + "iojs": ">=1.0.0", + "node": ">=0.10.0" + } + }, + "node_modules/rimraf": { + "version": "3.0.2", + "resolved": "https://registry.npmjs.org/rimraf/-/rimraf-3.0.2.tgz", + "integrity": "sha512-JZkJMZkAGFFPP2YqXZXPbMlMBgsxzE8ILs4lMIX/2o0L9UBw9O/Y3o6wFw/i9YLapcUJWwqbi3kdxIPdC62TIA==", + "dependencies": { + "glob": "^7.1.3" + }, + "bin": { + "rimraf": "bin.js" + }, + "funding": { + "url": "https://github.com/sponsors/isaacs" + } + }, + "node_modules/rst-selector-parser": { + "version": "2.2.3", + "resolved": "https://registry.npmjs.org/rst-selector-parser/-/rst-selector-parser-2.2.3.tgz", + "integrity": "sha512-nDG1rZeP6oFTLN6yNDV/uiAvs1+FS/KlrEwh7+y7dpuApDBy6bI2HTBcc0/V8lv9OTqfyD34eF7au2pm8aBbhA==", + "dev": true, + "dependencies": { + "lodash.flattendeep": "^4.4.0", + "nearley": "^2.7.10" + } + }, + "node_modules/run-parallel": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/run-parallel/-/run-parallel-1.2.0.tgz", + "integrity": "sha512-5l4VyZR86LZ/lDxZTR6jqL8AFE2S0IFLMP26AbjsLVADxHdhB/c0GUsH+y39UfCi3dzz8OlQuPmnaJOMoDHQBA==", + "dev": true, + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/feross" + }, + { + "type": "patreon", + "url": "https://www.patreon.com/feross" + }, + { + "type": "consulting", + "url": "https://feross.org/support" + } + ], + "dependencies": { + "queue-microtask": "^1.2.2" + } + }, + "node_modules/safe-buffer": { + "version": "5.2.1", + "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.2.1.tgz", + "integrity": "sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ==", + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/feross" + }, + { + "type": "patreon", + "url": "https://www.patreon.com/feross" + }, + { + "type": "consulting", + "url": "https://feross.org/support" + } + ] + }, + "node_modules/safe-regex-test": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/safe-regex-test/-/safe-regex-test-1.0.0.tgz", + "integrity": "sha512-JBUUzyOgEwXQY1NuPtvcj/qcBDbDmEvWufhlnXZIm75DEHp+afM1r1ujJpJsV/gSM4t59tpDyPi1sd6ZaPFfsA==", + "dev": true, + "dependencies": { + "call-bind": "^1.0.2", + "get-intrinsic": "^1.1.3", + "is-regex": "^1.1.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/semver": { + "version": "6.3.0", + "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.0.tgz", + "integrity": "sha512-b39TBaTSfV6yBrapU89p5fKekE2m/NwnDocOVruQFS1/veMgdzuPcnOM34M6CwxW8jH/lxEa5rBoDeUwu5HHTw==", + "bin": { + "semver": "bin/semver.js" + } + }, + "node_modules/set-blocking": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/set-blocking/-/set-blocking-2.0.0.tgz", + "integrity": "sha512-KiKBS8AnWGEyLzofFfmvKwpdPzqiy16LvQfK3yv/fVH7Bj13/wl3JSR1J+rfgRE9q7xUJK4qvgS8raSOeLUehw==" + }, + "node_modules/shebang-command": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/shebang-command/-/shebang-command-2.0.0.tgz", + "integrity": "sha512-kHxr2zZpYtdmrN1qDjrrX/Z1rR1kG8Dx+gkpK1G4eXmvXswmcE1hTWBWYUzlraYw1/yZp6YuDY77YtvbN0dmDA==", + "dev": true, + "dependencies": { + "shebang-regex": "^3.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/shebang-regex": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/shebang-regex/-/shebang-regex-3.0.0.tgz", + "integrity": "sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A==", + "dev": true, + "engines": { + "node": ">=8" + } + }, + "node_modules/side-channel": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/side-channel/-/side-channel-1.0.4.tgz", + "integrity": "sha512-q5XPytqFEIKHkGdiMIrY10mvLRvnQh42/+GoBlFW3b2LXLE2xxJpZFdm94we0BaoV3RwJyGqg5wS7epxTv0Zvw==", + "dev": true, + "dependencies": { + "call-bind": "^1.0.0", + "get-intrinsic": "^1.0.2", + "object-inspect": "^1.9.0" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/signal-exit": { + "version": "3.0.7", + "resolved": "https://registry.npmjs.org/signal-exit/-/signal-exit-3.0.7.tgz", + "integrity": "sha512-wnD2ZE+l+SPC/uoS0vXeE9L1+0wuaMqKlfz9AMUo38JsyLSBWSFcHR1Rri62LZc12vLr1gb3jl7iwQhgwpAbGQ==" + }, + "node_modules/sisteransi": { + "version": "1.0.5", + "resolved": "https://registry.npmjs.org/sisteransi/-/sisteransi-1.0.5.tgz", + "integrity": "sha512-bLGGlR1QxBcynn2d5YmDX4MGjlZvy2MRBDRNHLJ8VI6l6+9FUiyTFNJ0IveOSP0bcXgVDPRcfGqA0pjaqUpfVg==", + "dev": true + }, + "node_modules/slash": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/slash/-/slash-3.0.0.tgz", + "integrity": "sha512-g9Q1haeby36OSStwb4ntCGGGaKsaVSjQ68fBxoQcutl5fS1vuY18H3wSt3jFyFtrkx+Kz0V1G85A4MyAdDMi2Q==", + "dev": true, + "engines": { + "node": ">=8" + } + }, + "node_modules/source-map": { + "version": "0.6.1", + "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.6.1.tgz", + "integrity": "sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==", + "dev": true, + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/source-map-support": { + "version": "0.5.13", + "resolved": "https://registry.npmjs.org/source-map-support/-/source-map-support-0.5.13.tgz", + "integrity": "sha512-SHSKFHadjVA5oR4PPqhtAVdcBWwRYVd6g6cAXnIbRiIwc2EhPrTuKUBdSLvlEKyIP3GCf89fltvcZiP9MMFA1w==", + "dev": true, + "dependencies": { + "buffer-from": "^1.0.0", + "source-map": "^0.6.0" + } + }, + "node_modules/sprintf-js": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/sprintf-js/-/sprintf-js-1.0.3.tgz", + "integrity": "sha512-D9cPgkvLlV3t3IzL0D0YLvGA9Ahk4PcvVwUbN0dSGr1aP0Nrt4AEnTUbuGvquEC0mA64Gqt1fzirlRs5ibXx8g==", + "dev": true + }, + "node_modules/stack-utils": { + "version": "2.0.6", + "resolved": "https://registry.npmjs.org/stack-utils/-/stack-utils-2.0.6.tgz", + "integrity": "sha512-XlkWvfIm6RmsWtNJx+uqtKLS8eqFbxUg0ZzLXqY0caEy9l7hruX8IpiDnjsLavoBgqCCR71TqWO8MaXYheJ3RQ==", + "dev": true, + "dependencies": { + "escape-string-regexp": "^2.0.0" + }, + "engines": { + "node": ">=10" + } + }, + "node_modules/stack-utils/node_modules/escape-string-regexp": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-2.0.0.tgz", + "integrity": "sha512-UpzcLCXolUWcNu5HtVMHYdXJjArjsF9C0aNnquZYY4uW/Vu0miy5YoWvbV345HauVvcAUnpRuhMMcqTcGOY2+w==", + "dev": true, + "engines": { + "node": ">=8" + } + }, + "node_modules/string_decoder": { + "version": "1.3.0", + "resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-1.3.0.tgz", + "integrity": "sha512-hkRX8U1WjJFd8LsDJ2yQ/wWWxaopEsABU1XfkM8A+j0+85JAGppt16cr1Whg6KIbb4okU6Mql6BOj+uup/wKeA==", + "dependencies": { + "safe-buffer": "~5.2.0" + } + }, + "node_modules/string-length": { + "version": "4.0.2", + "resolved": "https://registry.npmjs.org/string-length/-/string-length-4.0.2.tgz", + "integrity": "sha512-+l6rNN5fYHNhZZy41RXsYptCjA2Igmq4EG7kZAYFQI1E1VTXarr6ZPXBg6eq7Y6eK4FEhY6AJlyuFIb/v/S0VQ==", + "dev": true, + "dependencies": { + "char-regex": "^1.0.2", + "strip-ansi": "^6.0.0" + }, + "engines": { + "node": ">=10" + } + }, + "node_modules/string-width": { + "version": "4.2.3", + "resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.3.tgz", + "integrity": "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==", + "dependencies": { + "emoji-regex": "^8.0.0", + "is-fullwidth-code-point": "^3.0.0", + "strip-ansi": "^6.0.1" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/string.prototype.trim": { + "version": "1.2.7", + "resolved": "https://registry.npmjs.org/string.prototype.trim/-/string.prototype.trim-1.2.7.tgz", + "integrity": "sha512-p6TmeT1T3411M8Cgg9wBTMRtY2q9+PNy9EV1i2lIXUN/btt763oIfxwN3RR8VU6wHX8j/1CFy0L+YuThm6bgOg==", + "dev": true, + "dependencies": { + "call-bind": "^1.0.2", + "define-properties": "^1.1.4", + "es-abstract": "^1.20.4" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/string.prototype.trimend": { + "version": "1.0.6", + "resolved": "https://registry.npmjs.org/string.prototype.trimend/-/string.prototype.trimend-1.0.6.tgz", + "integrity": "sha512-JySq+4mrPf9EsDBEDYMOb/lM7XQLulwg5R/m1r0PXEFqrV0qHvl58sdTilSXtKOflCsK2E8jxf+GKC0T07RWwQ==", + "dev": true, + "dependencies": { + "call-bind": "^1.0.2", + "define-properties": "^1.1.4", + "es-abstract": "^1.20.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/string.prototype.trimstart": { + "version": "1.0.6", + "resolved": "https://registry.npmjs.org/string.prototype.trimstart/-/string.prototype.trimstart-1.0.6.tgz", + "integrity": "sha512-omqjMDaY92pbn5HOX7f9IccLA+U1tA9GvtU4JrodiXFfYB7jPzzHpRzpglLAjtUV6bB557zwClJezTqnAiYnQA==", + "dev": true, + "dependencies": { + "call-bind": "^1.0.2", + "define-properties": "^1.1.4", + "es-abstract": "^1.20.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/strip-ansi": { + "version": "6.0.1", + "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz", + "integrity": "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==", + "dependencies": { + "ansi-regex": "^5.0.1" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/strip-bom": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/strip-bom/-/strip-bom-4.0.0.tgz", + "integrity": "sha512-3xurFv5tEgii33Zi8Jtp55wEIILR9eh34FAW00PZf+JnSsTmV/ioewSgQl97JHvgjoRGwPShsWm+IdrxB35d0w==", + "dev": true, + "engines": { + "node": ">=8" + } + }, + "node_modules/strip-final-newline": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/strip-final-newline/-/strip-final-newline-2.0.0.tgz", + "integrity": "sha512-BrpvfNAE3dcvq7ll3xVumzjKjZQ5tI1sEUIKr3Uoks0XUl45St3FlatVqef9prk4jRDzhW6WZg+3bk93y6pLjA==", + "dev": true, + "engines": { + "node": ">=6" + } + }, + "node_modules/strip-json-comments": { + "version": "3.1.1", + "resolved": "https://registry.npmjs.org/strip-json-comments/-/strip-json-comments-3.1.1.tgz", + "integrity": "sha512-6fPc+R4ihwqP6N/aIv2f1gMH8lOVtWQHoqC4yK6oSDVVocumAsfCqjkXnqiYMhmMwS/mEHLp7Vehlt3ql6lEig==", + "dev": true, + "engines": { + "node": ">=8" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/supports-color": { + "version": "7.2.0", + "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-7.2.0.tgz", + "integrity": "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==", + "dev": true, + "dependencies": { + "has-flag": "^4.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/supports-preserve-symlinks-flag": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/supports-preserve-symlinks-flag/-/supports-preserve-symlinks-flag-1.0.0.tgz", + "integrity": "sha512-ot0WnXS9fgdkgIcePe6RHNk1WA8+muPa6cSjeR3V8K27q9BB1rTE3R1p7Hv0z1ZyAc8s6Vvv8DIyWf681MAt0w==", + "dev": true, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/tar": { + "version": "6.1.13", + "resolved": "https://registry.npmjs.org/tar/-/tar-6.1.13.tgz", + "integrity": "sha512-jdIBIN6LTIe2jqzay/2vtYLlBHa3JF42ot3h1dW8Q0PaAG4v8rm0cvpVePtau5C6OKXGGcgO9q2AMNSWxiLqKw==", + "dependencies": { + "chownr": "^2.0.0", + "fs-minipass": "^2.0.0", + "minipass": "^4.0.0", + "minizlib": "^2.1.1", + "mkdirp": "^1.0.3", + "yallist": "^4.0.0" + }, + "engines": { + "node": ">=10" + } + }, + "node_modules/tar/node_modules/yallist": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/yallist/-/yallist-4.0.0.tgz", + "integrity": "sha512-3wdGidZyq5PB084XLES5TpOSRA3wjXAlIWMhum2kRcv/41Sn2emQ0dycQW4uZXLejwKvg6EsvbdlVL+FYEct7A==" + }, + "node_modules/test-exclude": { + "version": "6.0.0", + "resolved": "https://registry.npmjs.org/test-exclude/-/test-exclude-6.0.0.tgz", + "integrity": "sha512-cAGWPIyOHU6zlmg88jwm7VRyXnMN7iV68OGAbYDk/Mh/xC/pzVPlQtY6ngoIH/5/tciuhGfvESU8GrHrcxD56w==", + "dev": true, + "dependencies": { + "@istanbuljs/schema": "^0.1.2", + "glob": "^7.1.4", + "minimatch": "^3.0.4" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/text-table": { + "version": "0.2.0", + "resolved": "https://registry.npmjs.org/text-table/-/text-table-0.2.0.tgz", + "integrity": "sha512-N+8UisAXDGk8PFXP4HAzVR9nbfmVJ3zYLAWiTIoqC5v5isinhr+r5uaO8+7r3BMfuNIufIsA7RdpVgacC2cSpw==", + "dev": true + }, + "node_modules/tmpl": { + "version": "1.0.5", + "resolved": "https://registry.npmjs.org/tmpl/-/tmpl-1.0.5.tgz", + "integrity": "sha512-3f0uOEAQwIqGuWW2MVzYg8fV/QNnc/IpuJNG837rLuczAaLVHslWHZQj4IGiEl5Hs3kkbhwL9Ab7Hrsmuj+Smw==", + "dev": true + }, + "node_modules/to-fast-properties": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/to-fast-properties/-/to-fast-properties-2.0.0.tgz", + "integrity": "sha512-/OaKK0xYrs3DmxRYqL/yDc+FxFUVYhDlXMhRmv3z915w2HF1tnN1omB354j8VUGO/hbRzyD6Y3sA7v7GS/ceog==", + "dev": true, + "engines": { + "node": ">=4" + } + }, + "node_modules/to-regex-range": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/to-regex-range/-/to-regex-range-5.0.1.tgz", + "integrity": "sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ==", + "dev": true, + "dependencies": { + "is-number": "^7.0.0" + }, + "engines": { + "node": ">=8.0" + } + }, + "node_modules/tr46": { + "version": "0.0.3", + "resolved": "https://registry.npmjs.org/tr46/-/tr46-0.0.3.tgz", + "integrity": "sha512-N3WMsuqV66lT30CrXNbEjx4GEwlow3v6rr4mCcv6prnfwhS01rkgyFdjPNBYd9br7LpXV1+Emh01fHnq2Gdgrw==" + }, + "node_modules/tunnel": { + "version": "0.0.6", + "resolved": "https://registry.npmjs.org/tunnel/-/tunnel-0.0.6.tgz", + "integrity": "sha512-1h/Lnq9yajKY2PEbBadPXj3VxsDDu844OnaAo52UVmIzIvwwtBPIuNvkjuzBlTWpfJyUbG3ez0KSBibQkj4ojg==", + "engines": { + "node": ">=0.6.11 <=0.7.0 || >=0.7.3" + } + }, + "node_modules/type-check": { + "version": "0.4.0", + "resolved": "https://registry.npmjs.org/type-check/-/type-check-0.4.0.tgz", + "integrity": "sha512-XleUoc9uwGXqjWwXaUTZAmzMcFZ5858QA2vvx1Ur5xIcixXIP+8LnFDgRplU30us6teqdlskFfu+ae4K79Ooew==", + "dev": true, + "dependencies": { + "prelude-ls": "^1.2.1" + }, + "engines": { + "node": ">= 0.8.0" + } + }, + "node_modules/type-detect": { + "version": "4.0.8", + "resolved": "https://registry.npmjs.org/type-detect/-/type-detect-4.0.8.tgz", + "integrity": "sha512-0fr/mIH1dlO+x7TlcMy+bIDqKPsw/70tVyeHW787goQjhmqaZe10uwLujubK9q9Lg6Fiho1KUKDYz0Z7k7g5/g==", + "dev": true, + "engines": { + "node": ">=4" + } + }, + "node_modules/type-fest": { + "version": "0.20.2", + "resolved": "https://registry.npmjs.org/type-fest/-/type-fest-0.20.2.tgz", + "integrity": "sha512-Ne+eE4r0/iWnpAxD852z3A+N0Bt5RN//NjJwRd2VFHEmrywxf5vsZlh4R6lixl6B+wz/8d+maTSAkN1FIkI3LQ==", + "dev": true, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/typed-array-length": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/typed-array-length/-/typed-array-length-1.0.4.tgz", + "integrity": "sha512-KjZypGq+I/H7HI5HlOoGHkWUUGq+Q0TPhQurLbyrVrvnKTBgzLhIJ7j6J/XTQOi0d1RjyZ0wdas8bKs2p0x3Ng==", + "dev": true, + "dependencies": { + "call-bind": "^1.0.2", + "for-each": "^0.3.3", + "is-typed-array": "^1.1.9" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/unbox-primitive": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/unbox-primitive/-/unbox-primitive-1.0.2.tgz", + "integrity": "sha512-61pPlCD9h51VoreyJ0BReideM3MDKMKnh6+V9L08331ipq6Q8OFXZYiqP6n/tbHx4s5I9uRhcye6BrbkizkBDw==", + "dev": true, + "dependencies": { + "call-bind": "^1.0.2", + "has-bigints": "^1.0.2", + "has-symbols": "^1.0.3", + "which-boxed-primitive": "^1.0.2" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/universal-user-agent": { + "version": "6.0.0", + "resolved": "https://registry.npmjs.org/universal-user-agent/-/universal-user-agent-6.0.0.tgz", + "integrity": "sha512-isyNax3wXoKaulPDZWHQqbmIx1k2tb9fb3GGDBRxCscfYV2Ch7WxPArBsFEG8s/safwXTT7H4QGhaIkTp9447w==" + }, + "node_modules/update-browserslist-db": { + "version": "1.0.10", + "resolved": "https://registry.npmjs.org/update-browserslist-db/-/update-browserslist-db-1.0.10.tgz", + "integrity": "sha512-OztqDenkfFkbSG+tRxBeAnCVPckDBcvibKd35yDONx6OU8N7sqgwc7rCbkJ/WcYtVRZ4ba68d6byhC21GFh7sQ==", + "dev": true, + "funding": [ + { + "type": "opencollective", + "url": "https://opencollective.com/browserslist" + }, + { + "type": "tidelift", + "url": "https://tidelift.com/funding/github/npm/browserslist" + } + ], + "dependencies": { + "escalade": "^3.1.1", + "picocolors": "^1.0.0" + }, + "bin": { + "browserslist-lint": "cli.js" + }, + "peerDependencies": { + "browserslist": ">= 4.21.0" + } + }, + "node_modules/uri-js": { + "version": "4.4.1", + "resolved": "https://registry.npmjs.org/uri-js/-/uri-js-4.4.1.tgz", + "integrity": "sha512-7rKUyy33Q1yc98pQ1DAmLtwX109F7TIfWlW1Ydo8Wl1ii1SeHieeh0HHfPeL2fMXK6z0s8ecKs9frCuLJvndBg==", + "dev": true, + "dependencies": { + "punycode": "^2.1.0" + } + }, + "node_modules/url-template": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/url-template/-/url-template-3.1.0.tgz", + "integrity": "sha512-vB/eHWttzhN+NZzk9FcQB2h1cSEgb7zDYyvyxPhw02LYw7YqIzO+w1AqkcKvZ51gPH8o4+nyiWve/xuQqMdJZw==", + "dev": true, + "engines": { + "node": "^12.20.0 || ^14.13.1 || >=16.0.0" + } + }, + "node_modules/util-deprecate": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/util-deprecate/-/util-deprecate-1.0.2.tgz", + "integrity": "sha512-EPD5q1uXyFxJpCrLnCc1nHnq3gOa6DZBocAIiI2TaSCA7VCJ1UJDMagCzIkXNsUYfD1daK//LTEQ8xiIbrHtcw==" + }, + "node_modules/uuid": { + "version": "8.3.2", + "resolved": "https://registry.npmjs.org/uuid/-/uuid-8.3.2.tgz", + "integrity": "sha512-+NYs2QeMWy+GWFOEm9xnn6HCDp0l7QBD7ml8zLUmJ+93Q5NF0NocErnwkTkXVFNiX3/fpC6afS8Dhb/gz7R7eg==", + "bin": { + "uuid": "dist/bin/uuid" + } + }, + "node_modules/v8-to-istanbul": { + "version": "9.1.0", + "resolved": "https://registry.npmjs.org/v8-to-istanbul/-/v8-to-istanbul-9.1.0.tgz", + "integrity": "sha512-6z3GW9x8G1gd+JIIgQQQxXuiJtCXeAjp6RaPEPLv62mH3iPHPxV6W3robxtCzNErRo6ZwTmzWhsbNvjyEBKzKA==", + "dev": true, + "dependencies": { + "@jridgewell/trace-mapping": "^0.3.12", + "@types/istanbul-lib-coverage": "^2.0.1", + "convert-source-map": "^1.6.0" + }, + "engines": { + "node": ">=10.12.0" + } + }, + "node_modules/v8-to-istanbul/node_modules/convert-source-map": { + "version": "1.9.0", + "resolved": "https://registry.npmjs.org/convert-source-map/-/convert-source-map-1.9.0.tgz", + "integrity": "sha512-ASFBup0Mz1uyiIjANan1jzLQami9z1PoYSZCiiYW2FczPbenXc45FZdBZLzOT+r6+iciuEModtmCti+hjaAk0A==", + "dev": true + }, + "node_modules/walker": { + "version": "1.0.8", + "resolved": "https://registry.npmjs.org/walker/-/walker-1.0.8.tgz", + "integrity": "sha512-ts/8E8l5b7kY0vlWLewOkDXMmPdLcVV4GmOQLyxuSswIJsweeFZtAsMF7k1Nszz+TYBQrlYRmzOnr398y1JemQ==", + "dev": true, + "dependencies": { + "makeerror": "1.0.12" + } + }, + "node_modules/webidl-conversions": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/webidl-conversions/-/webidl-conversions-3.0.1.tgz", + "integrity": "sha512-2JAn3z8AR6rjK8Sm8orRC0h/bcl/DqL7tRPdGZ4I1CjdF+EaMLmYxBHyXuKL849eucPFhvBoxMsflfOb8kxaeQ==" + }, + "node_modules/whatwg-url": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/whatwg-url/-/whatwg-url-5.0.0.tgz", + "integrity": "sha512-saE57nupxk6v3HY35+jzBwYa0rKSy0XR8JSxZPwgLr7ys0IBzhGviA1/TUGJLmSVqs8pb9AnvICXEuOHLprYTw==", + "dependencies": { + "tr46": "~0.0.3", + "webidl-conversions": "^3.0.0" + } + }, + "node_modules/which": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/which/-/which-2.0.2.tgz", + "integrity": "sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA==", + "dev": true, + "dependencies": { + "isexe": "^2.0.0" + }, + "bin": { + "node-which": "bin/node-which" + }, + "engines": { + "node": ">= 8" + } + }, + "node_modules/which-boxed-primitive": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/which-boxed-primitive/-/which-boxed-primitive-1.0.2.tgz", + "integrity": "sha512-bwZdv0AKLpplFY2KZRX6TvyuN7ojjr7lwkg6ml0roIy9YeuSr7JS372qlNW18UQYzgYK9ziGcerWqZOmEn9VNg==", + "dev": true, + "dependencies": { + "is-bigint": "^1.0.1", + "is-boolean-object": "^1.1.0", + "is-number-object": "^1.0.4", + "is-string": "^1.0.5", + "is-symbol": "^1.0.3" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/which-typed-array": { + "version": "1.1.9", + "resolved": "https://registry.npmjs.org/which-typed-array/-/which-typed-array-1.1.9.tgz", + "integrity": "sha512-w9c4xkx6mPidwp7180ckYWfMmvxpjlZuIudNtDf4N/tTAUB8VJbX25qZoAsrtGuYNnGw3pa0AXgbGKRB8/EceA==", + "dev": true, + "dependencies": { + "available-typed-arrays": "^1.0.5", + "call-bind": "^1.0.2", + "for-each": "^0.3.3", + "gopd": "^1.0.1", + "has-tostringtag": "^1.0.0", + "is-typed-array": "^1.1.10" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/wide-align": { + "version": "1.1.5", + "resolved": "https://registry.npmjs.org/wide-align/-/wide-align-1.1.5.tgz", + "integrity": "sha512-eDMORYaPNZ4sQIuuYPDHdQvf4gyCF9rEEV/yPxGfwPkRodwEgiMUUXTx/dex+Me0wxx53S+NgUHaP7y3MGlDmg==", + "dependencies": { + "string-width": "^1.0.2 || 2 || 3 || 4" + } + }, + "node_modules/word-wrap": { + "version": "1.2.3", + "resolved": "https://registry.npmjs.org/word-wrap/-/word-wrap-1.2.3.tgz", + "integrity": "sha512-Hz/mrNwitNRh/HUAtM/VT/5VH+ygD6DV7mYKZAtHOrbs8U7lvPS6xf7EJKMF0uW1KJCl0H701g3ZGus+muE5vQ==", + "dev": true, + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/wordwrap": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/wordwrap/-/wordwrap-1.0.0.tgz", + "integrity": "sha512-gvVzJFlPycKc5dZN4yPkP8w7Dc37BtP1yczEneOb4uq34pXZcvrtRTmWV8W+Ume+XCxKgbjM+nevkyFPMybd4Q==", + "dev": true + }, + "node_modules/wrap-ansi": { + "version": "7.0.0", + "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-7.0.0.tgz", + "integrity": "sha512-YVGIj2kamLSTxw6NsZjoBxfSwsn0ycdesmc4p+Q21c5zPuZ1pl+NfxVdxPtdHvmNVOQ6XSYG4AUtyt/Fi7D16Q==", + "dev": true, + "dependencies": { + "ansi-styles": "^4.0.0", + "string-width": "^4.1.0", + "strip-ansi": "^6.0.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/chalk/wrap-ansi?sponsor=1" + } + }, + "node_modules/wrappy": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/wrappy/-/wrappy-1.0.2.tgz", + "integrity": "sha512-l4Sp/DRseor9wL6EvV2+TuQn63dMkPjZ/sp9XkghTEbV9KlPS1xUsZ3u7/IQO4wxtcFB4bgpQPRcR3QCvezPcQ==" + }, + "node_modules/write-file-atomic": { + "version": "4.0.2", + "resolved": "https://registry.npmjs.org/write-file-atomic/-/write-file-atomic-4.0.2.tgz", + "integrity": "sha512-7KxauUdBmSdWnmpaGFg+ppNjKF8uNLry8LyzjauQDOVONfFLNKrKvQOxZ/VuTIcS/gge/YNahf5RIIQWTSarlg==", + "dev": true, + "dependencies": { + "imurmurhash": "^0.1.4", + "signal-exit": "^3.0.7" + }, + "engines": { + "node": "^12.13.0 || ^14.15.0 || >=16.0.0" + } + }, + "node_modules/xml": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/xml/-/xml-1.0.1.tgz", + "integrity": "sha512-huCv9IH9Tcf95zuYCsQraZtWnJvBtLVE0QHMOs8bWyZAFZNDcYjsPq1nEx8jKA9y+Beo9v+7OBPRisQTjinQMw==", + "dev": true + }, + "node_modules/y18n": { + "version": "5.0.8", + "resolved": "https://registry.npmjs.org/y18n/-/y18n-5.0.8.tgz", + "integrity": "sha512-0pfFzegeDWJHJIAmTLRP2DwHjdF5s7jo9tuztdQxAhINCdvS+3nGINqPd00AphqJR/0LhANUS6/+7SCb98YOfA==", + "dev": true, + "engines": { + "node": ">=10" + } + }, + "node_modules/yallist": { + "version": "3.1.1", + "resolved": "https://registry.npmjs.org/yallist/-/yallist-3.1.1.tgz", + "integrity": "sha512-a4UGQaWPH59mOXUYnAG2ewncQS4i4F43Tv3JoAM+s2VDAmS9NsK8GpDMLrCHPksFT7h3K6TOoUNn2pb7RoXx4g==", + "dev": true + }, + "node_modules/yargs": { + "version": "17.7.1", + "resolved": "https://registry.npmjs.org/yargs/-/yargs-17.7.1.tgz", + "integrity": "sha512-cwiTb08Xuv5fqF4AovYacTFNxk62th7LKJ6BL9IGUpTJrWoU7/7WdQGTP2SjKf1dUNBGzDd28p/Yfs/GI6JrLw==", + "dev": true, + "dependencies": { + "cliui": "^8.0.1", + "escalade": "^3.1.1", + "get-caller-file": "^2.0.5", + "require-directory": "^2.1.1", + "string-width": "^4.2.3", + "y18n": "^5.0.5", + "yargs-parser": "^21.1.1" + }, + "engines": { + "node": ">=12" + } + }, + "node_modules/yargs-parser": { + "version": "21.1.1", + "resolved": "https://registry.npmjs.org/yargs-parser/-/yargs-parser-21.1.1.tgz", + "integrity": "sha512-tVpsJW7DdjecAiFpbIB1e3qxIQsE6NoPc5/eTdrbbIC4h0LVsWhnoa3g+m2HclBIujHzsxZ4VJVA+GUuc2/LBw==", + "dev": true, + "engines": { + "node": ">=12" + } + }, + "node_modules/yocto-queue": { + "version": "0.1.0", + "resolved": "https://registry.npmjs.org/yocto-queue/-/yocto-queue-0.1.0.tgz", + "integrity": "sha512-rVksvsnNCdJ/ohGc6xgPwyN8eheCxsiLM8mxuE/t/mOVqJewPuO1miLpTHQiRgTKCLexL4MeAFVagts7HmNZ2Q==", + "dev": true, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + } + }, + "dependencies": { + "@actions/core": { + "version": "1.10.0", + "resolved": "https://registry.npmjs.org/@actions/core/-/core-1.10.0.tgz", + "integrity": "sha512-2aZDDa3zrrZbP5ZYg159sNoLRb61nQ7awl5pSvIq5Qpj81vwDzdMRKzkWJGJuwVvWpvZKx7vspJALyvaaIQyug==", + "requires": { + "@actions/http-client": "^2.0.1", + "uuid": "^8.3.2" + } + }, + "@actions/github": { + "version": "5.1.1", + "resolved": "https://registry.npmjs.org/@actions/github/-/github-5.1.1.tgz", + "integrity": "sha512-Nk59rMDoJaV+mHCOJPXuvB1zIbomlKS0dmSIqPGxd0enAXBnOfn4VWF+CGtRCwXZG9Epa54tZA7VIRlJDS8A6g==", + "requires": { + "@actions/http-client": "^2.0.1", + "@octokit/core": "^3.6.0", + "@octokit/plugin-paginate-rest": "^2.17.0", + "@octokit/plugin-rest-endpoint-methods": "^5.13.0" + }, + "dependencies": { + "@octokit/auth-token": { + "version": "2.5.0", + "resolved": "https://registry.npmjs.org/@octokit/auth-token/-/auth-token-2.5.0.tgz", + "integrity": "sha512-r5FVUJCOLl19AxiuZD2VRZ/ORjp/4IN98Of6YJoJOkY75CIBuYfmiNHGrDwXr+aLGG55igl9QrxX3hbiXlLb+g==", + "requires": { + "@octokit/types": "^6.0.3" + } + }, + "@octokit/core": { + "version": "3.6.0", + "resolved": "https://registry.npmjs.org/@octokit/core/-/core-3.6.0.tgz", + "integrity": "sha512-7RKRKuA4xTjMhY+eG3jthb3hlZCsOwg3rztWh75Xc+ShDWOfDDATWbeZpAHBNRpm4Tv9WgBMOy1zEJYXG6NJ7Q==", + "requires": { + "@octokit/auth-token": "^2.4.4", + "@octokit/graphql": "^4.5.8", + "@octokit/request": "^5.6.3", + "@octokit/request-error": "^2.0.5", + "@octokit/types": "^6.0.3", + "before-after-hook": "^2.2.0", + "universal-user-agent": "^6.0.0" + } + }, + "@octokit/endpoint": { + "version": "6.0.12", + "resolved": "https://registry.npmjs.org/@octokit/endpoint/-/endpoint-6.0.12.tgz", + "integrity": "sha512-lF3puPwkQWGfkMClXb4k/eUT/nZKQfxinRWJrdZaJO85Dqwo/G0yOC434Jr2ojwafWJMYqFGFa5ms4jJUgujdA==", + "requires": { + "@octokit/types": "^6.0.3", + "is-plain-object": "^5.0.0", + "universal-user-agent": "^6.0.0" + } + }, + "@octokit/graphql": { + "version": "4.8.0", + "resolved": "https://registry.npmjs.org/@octokit/graphql/-/graphql-4.8.0.tgz", + "integrity": "sha512-0gv+qLSBLKF0z8TKaSKTsS39scVKF9dbMxJpj3U0vC7wjNWFuIpL/z76Qe2fiuCbDRcJSavkXsVtMS6/dtQQsg==", + "requires": { + "@octokit/request": "^5.6.0", + "@octokit/types": "^6.0.3", + "universal-user-agent": "^6.0.0" + } + }, + "@octokit/openapi-types": { + "version": "12.11.0", + "resolved": "https://registry.npmjs.org/@octokit/openapi-types/-/openapi-types-12.11.0.tgz", + "integrity": "sha512-VsXyi8peyRq9PqIz/tpqiL2w3w80OgVMwBHltTml3LmVvXiphgeqmY9mvBw9Wu7e0QWk/fqD37ux8yP5uVekyQ==" + }, + "@octokit/request": { + "version": "5.6.3", + "resolved": "https://registry.npmjs.org/@octokit/request/-/request-5.6.3.tgz", + "integrity": "sha512-bFJl0I1KVc9jYTe9tdGGpAMPy32dLBXXo1dS/YwSCTL/2nd9XeHsY616RE3HPXDVk+a+dBuzyz5YdlXwcDTr2A==", + "requires": { + "@octokit/endpoint": "^6.0.1", + "@octokit/request-error": "^2.1.0", + "@octokit/types": "^6.16.1", + "is-plain-object": "^5.0.0", + "node-fetch": "^2.6.7", + "universal-user-agent": "^6.0.0" + } + }, + "@octokit/request-error": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/@octokit/request-error/-/request-error-2.1.0.tgz", + "integrity": "sha512-1VIvgXxs9WHSjicsRwq8PlR2LR2x6DwsJAaFgzdi0JfJoGSO8mYI/cHJQ+9FbN21aa+DrgNLnwObmyeSC8Rmpg==", + "requires": { + "@octokit/types": "^6.0.3", + "deprecation": "^2.0.0", + "once": "^1.4.0" + } + }, + "@octokit/types": { + "version": "6.41.0", + "resolved": "https://registry.npmjs.org/@octokit/types/-/types-6.41.0.tgz", + "integrity": "sha512-eJ2jbzjdijiL3B4PrSQaSjuF2sPEQPVCPzBvTHJD9Nz+9dw2SGH4K4xeQJ77YfTq5bRQ+bD8wT11JbeDPmxmGg==", + "requires": { + "@octokit/openapi-types": "^12.11.0" + } + } + } + }, + "@actions/glob": { + "version": "0.4.0", + "resolved": "https://registry.npmjs.org/@actions/glob/-/glob-0.4.0.tgz", + "integrity": "sha512-+eKIGFhsFa4EBwaf/GMyzCdWrXWymGXfFmZU3FHQvYS8mPcHtTtZONbkcqqUMzw9mJ/pImEBFET1JNifhqGsAQ==", + "requires": { + "@actions/core": "^1.9.1", + "minimatch": "^3.0.4" + } + }, + "@actions/http-client": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/@actions/http-client/-/http-client-2.1.0.tgz", + "integrity": "sha512-BonhODnXr3amchh4qkmjPMUO8mFi/zLaaCeCAJZqch8iQqyDnVIkySjB38VHAC8IJ+bnlgfOqlhpyCUZHlQsqw==", + "requires": { + "tunnel": "^0.0.6" + } + }, + "@ampproject/remapping": { + "version": "2.2.0", + "resolved": "https://registry.npmjs.org/@ampproject/remapping/-/remapping-2.2.0.tgz", + "integrity": "sha512-qRmjj8nj9qmLTQXXmaR1cck3UXSRMPrbsLJAasZpF+t3riI71BXed5ebIOYwQntykeZuhjsdweEc9BxH5Jc26w==", + "dev": true, + "requires": { + "@jridgewell/gen-mapping": "^0.1.0", + "@jridgewell/trace-mapping": "^0.3.9" + } + }, + "@babel/code-frame": { + "version": "7.18.6", + "resolved": "https://registry.npmjs.org/@babel/code-frame/-/code-frame-7.18.6.tgz", + "integrity": "sha512-TDCmlK5eOvH+eH7cdAFlNXeVJqWIQ7gW9tY1GJIpUtFb6CmjVyq2VM3u71bOyR8CRihcCgMUYoDNyLXao3+70Q==", + "dev": true, + "requires": { + "@babel/highlight": "^7.18.6" + } + }, + "@babel/compat-data": { + "version": "7.21.0", + "resolved": "https://registry.npmjs.org/@babel/compat-data/-/compat-data-7.21.0.tgz", + "integrity": "sha512-gMuZsmsgxk/ENC3O/fRw5QY8A9/uxQbbCEypnLIiYYc/qVJtEV7ouxC3EllIIwNzMqAQee5tanFabWsUOutS7g==", + "dev": true + }, + "@babel/core": { + "version": "7.21.0", + "resolved": "https://registry.npmjs.org/@babel/core/-/core-7.21.0.tgz", + "integrity": "sha512-PuxUbxcW6ZYe656yL3EAhpy7qXKq0DmYsrJLpbB8XrsCP9Nm+XCg9XFMb5vIDliPD7+U/+M+QJlH17XOcB7eXA==", + "dev": true, + "requires": { + "@ampproject/remapping": "^2.2.0", + "@babel/code-frame": "^7.18.6", + "@babel/generator": "^7.21.0", + "@babel/helper-compilation-targets": "^7.20.7", + "@babel/helper-module-transforms": "^7.21.0", + "@babel/helpers": "^7.21.0", + "@babel/parser": "^7.21.0", + "@babel/template": "^7.20.7", + "@babel/traverse": "^7.21.0", + "@babel/types": "^7.21.0", + "convert-source-map": "^1.7.0", + "debug": "^4.1.0", + "gensync": "^1.0.0-beta.2", + "json5": "^2.2.2", + "semver": "^6.3.0" + }, + "dependencies": { + "convert-source-map": { + "version": "1.9.0", + "resolved": "https://registry.npmjs.org/convert-source-map/-/convert-source-map-1.9.0.tgz", + "integrity": "sha512-ASFBup0Mz1uyiIjANan1jzLQami9z1PoYSZCiiYW2FczPbenXc45FZdBZLzOT+r6+iciuEModtmCti+hjaAk0A==", + "dev": true + } + } + }, + "@babel/generator": { + "version": "7.21.1", + "resolved": "https://registry.npmjs.org/@babel/generator/-/generator-7.21.1.tgz", + "integrity": "sha512-1lT45bAYlQhFn/BHivJs43AiW2rg3/UbLyShGfF3C0KmHvO5fSghWd5kBJy30kpRRucGzXStvnnCFniCR2kXAA==", + "dev": true, + "requires": { + "@babel/types": "^7.21.0", + "@jridgewell/gen-mapping": "^0.3.2", + "@jridgewell/trace-mapping": "^0.3.17", + "jsesc": "^2.5.1" + }, + "dependencies": { + "@jridgewell/gen-mapping": { + "version": "0.3.2", + "resolved": "https://registry.npmjs.org/@jridgewell/gen-mapping/-/gen-mapping-0.3.2.tgz", + "integrity": "sha512-mh65xKQAzI6iBcFzwv28KVWSmCkdRBWoOh+bYQGW3+6OZvbbN3TqMGo5hqYxQniRcH9F2VZIoJCm4pa3BPDK/A==", + "dev": true, + "requires": { + "@jridgewell/set-array": "^1.0.1", + "@jridgewell/sourcemap-codec": "^1.4.10", + "@jridgewell/trace-mapping": "^0.3.9" + } + } + } + }, + "@babel/helper-compilation-targets": { + "version": "7.20.7", + "resolved": "https://registry.npmjs.org/@babel/helper-compilation-targets/-/helper-compilation-targets-7.20.7.tgz", + "integrity": "sha512-4tGORmfQcrc+bvrjb5y3dG9Mx1IOZjsHqQVUz7XCNHO+iTmqxWnVg3KRygjGmpRLJGdQSKuvFinbIb0CnZwHAQ==", + "dev": true, + "requires": { + "@babel/compat-data": "^7.20.5", + "@babel/helper-validator-option": "^7.18.6", + "browserslist": "^4.21.3", + "lru-cache": "^5.1.1", + "semver": "^6.3.0" + } + }, + "@babel/helper-environment-visitor": { + "version": "7.18.9", + "resolved": "https://registry.npmjs.org/@babel/helper-environment-visitor/-/helper-environment-visitor-7.18.9.tgz", + "integrity": "sha512-3r/aACDJ3fhQ/EVgFy0hpj8oHyHpQc+LPtJoY9SzTThAsStm4Ptegq92vqKoE3vD706ZVFWITnMnxucw+S9Ipg==", + "dev": true + }, + "@babel/helper-function-name": { + "version": "7.21.0", + "resolved": "https://registry.npmjs.org/@babel/helper-function-name/-/helper-function-name-7.21.0.tgz", + "integrity": "sha512-HfK1aMRanKHpxemaY2gqBmL04iAPOPRj7DxtNbiDOrJK+gdwkiNRVpCpUJYbUT+aZyemKN8brqTOxzCaG6ExRg==", + "dev": true, + "requires": { + "@babel/template": "^7.20.7", + "@babel/types": "^7.21.0" + } + }, + "@babel/helper-hoist-variables": { + "version": "7.18.6", + "resolved": "https://registry.npmjs.org/@babel/helper-hoist-variables/-/helper-hoist-variables-7.18.6.tgz", + "integrity": "sha512-UlJQPkFqFULIcyW5sbzgbkxn2FKRgwWiRexcuaR8RNJRy8+LLveqPjwZV/bwrLZCN0eUHD/x8D0heK1ozuoo6Q==", + "dev": true, + "requires": { + "@babel/types": "^7.18.6" + } + }, + "@babel/helper-module-imports": { + "version": "7.18.6", + "resolved": "https://registry.npmjs.org/@babel/helper-module-imports/-/helper-module-imports-7.18.6.tgz", + "integrity": "sha512-0NFvs3VkuSYbFi1x2Vd6tKrywq+z/cLeYC/RJNFrIX/30Bf5aiGYbtvGXolEktzJH8o5E5KJ3tT+nkxuuZFVlA==", + "dev": true, + "requires": { + "@babel/types": "^7.18.6" + } + }, + "@babel/helper-module-transforms": { + "version": "7.21.2", + "resolved": "https://registry.npmjs.org/@babel/helper-module-transforms/-/helper-module-transforms-7.21.2.tgz", + "integrity": "sha512-79yj2AR4U/Oqq/WOV7Lx6hUjau1Zfo4cI+JLAVYeMV5XIlbOhmjEk5ulbTc9fMpmlojzZHkUUxAiK+UKn+hNQQ==", + "dev": true, + "requires": { + "@babel/helper-environment-visitor": "^7.18.9", + "@babel/helper-module-imports": "^7.18.6", + "@babel/helper-simple-access": "^7.20.2", + "@babel/helper-split-export-declaration": "^7.18.6", + "@babel/helper-validator-identifier": "^7.19.1", + "@babel/template": "^7.20.7", + "@babel/traverse": "^7.21.2", + "@babel/types": "^7.21.2" + } + }, + "@babel/helper-plugin-utils": { + "version": "7.20.2", + "resolved": "https://registry.npmjs.org/@babel/helper-plugin-utils/-/helper-plugin-utils-7.20.2.tgz", + "integrity": "sha512-8RvlJG2mj4huQ4pZ+rU9lqKi9ZKiRmuvGuM2HlWmkmgOhbs6zEAw6IEiJ5cQqGbDzGZOhwuOQNtZMi/ENLjZoQ==", + "dev": true + }, + "@babel/helper-simple-access": { + "version": "7.20.2", + "resolved": "https://registry.npmjs.org/@babel/helper-simple-access/-/helper-simple-access-7.20.2.tgz", + "integrity": "sha512-+0woI/WPq59IrqDYbVGfshjT5Dmk/nnbdpcF8SnMhhXObpTq2KNBdLFRFrkVdbDOyUmHBCxzm5FHV1rACIkIbA==", + "dev": true, + "requires": { + "@babel/types": "^7.20.2" + } + }, + "@babel/helper-split-export-declaration": { + "version": "7.18.6", + "resolved": "https://registry.npmjs.org/@babel/helper-split-export-declaration/-/helper-split-export-declaration-7.18.6.tgz", + "integrity": "sha512-bde1etTx6ZyTmobl9LLMMQsaizFVZrquTEHOqKeQESMKo4PlObf+8+JA25ZsIpZhT/WEd39+vOdLXAFG/nELpA==", + "dev": true, + "requires": { + "@babel/types": "^7.18.6" + } + }, + "@babel/helper-string-parser": { + "version": "7.19.4", + "resolved": "https://registry.npmjs.org/@babel/helper-string-parser/-/helper-string-parser-7.19.4.tgz", + "integrity": "sha512-nHtDoQcuqFmwYNYPz3Rah5ph2p8PFeFCsZk9A/48dPc/rGocJ5J3hAAZ7pb76VWX3fZKu+uEr/FhH5jLx7umrw==", + "dev": true + }, + "@babel/helper-validator-identifier": { + "version": "7.19.1", + "resolved": "https://registry.npmjs.org/@babel/helper-validator-identifier/-/helper-validator-identifier-7.19.1.tgz", + "integrity": "sha512-awrNfaMtnHUr653GgGEs++LlAvW6w+DcPrOliSMXWCKo597CwL5Acf/wWdNkf/tfEQE3mjkeD1YOVZOUV/od1w==", + "dev": true + }, + "@babel/helper-validator-option": { + "version": "7.21.0", + "resolved": "https://registry.npmjs.org/@babel/helper-validator-option/-/helper-validator-option-7.21.0.tgz", + "integrity": "sha512-rmL/B8/f0mKS2baE9ZpyTcTavvEuWhTTW8amjzXNvYG4AwBsqTLikfXsEofsJEfKHf+HQVQbFOHy6o+4cnC/fQ==", + "dev": true + }, + "@babel/helpers": { + "version": "7.21.0", + "resolved": "https://registry.npmjs.org/@babel/helpers/-/helpers-7.21.0.tgz", + "integrity": "sha512-XXve0CBtOW0pd7MRzzmoyuSj0e3SEzj8pgyFxnTT1NJZL38BD1MK7yYrm8yefRPIDvNNe14xR4FdbHwpInD4rA==", + "dev": true, + "requires": { + "@babel/template": "^7.20.7", + "@babel/traverse": "^7.21.0", + "@babel/types": "^7.21.0" + } + }, + "@babel/highlight": { + "version": "7.18.6", + "resolved": "https://registry.npmjs.org/@babel/highlight/-/highlight-7.18.6.tgz", + "integrity": "sha512-u7stbOuYjaPezCuLj29hNW1v64M2Md2qupEKP1fHc7WdOA3DgLh37suiSrZYY7haUB7iBeQZ9P1uiRF359do3g==", + "dev": true, + "requires": { + "@babel/helper-validator-identifier": "^7.18.6", + "chalk": "^2.0.0", + "js-tokens": "^4.0.0" + }, + "dependencies": { + "ansi-styles": { + "version": "3.2.1", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-3.2.1.tgz", + "integrity": "sha512-VT0ZI6kZRdTh8YyJw3SMbYm/u+NqfsAxEpWO0Pf9sq8/e94WxxOpPKx9FR1FlyCtOVDNOQ+8ntlqFxiRc+r5qA==", + "dev": true, + "requires": { + "color-convert": "^1.9.0" + } + }, + "chalk": { + "version": "2.4.2", + "resolved": "https://registry.npmjs.org/chalk/-/chalk-2.4.2.tgz", + "integrity": "sha512-Mti+f9lpJNcwF4tWV8/OrTTtF1gZi+f8FqlyAdouralcFWFQWF2+NgCHShjkCb+IFBLq9buZwE1xckQU4peSuQ==", + "dev": true, + "requires": { + "ansi-styles": "^3.2.1", + "escape-string-regexp": "^1.0.5", + "supports-color": "^5.3.0" + } + }, + "color-convert": { + "version": "1.9.3", + "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-1.9.3.tgz", + "integrity": "sha512-QfAUtd+vFdAtFQcC8CCyYt1fYWxSqAiK2cSD6zDB8N3cpsEBAvRxp9zOGg6G/SHHJYAT88/az/IuDGALsNVbGg==", + "dev": true, + "requires": { + "color-name": "1.1.3" + } + }, + "color-name": { + "version": "1.1.3", + "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.3.tgz", + "integrity": "sha512-72fSenhMw2HZMTVHeCA9KCmpEIbzWiQsjN+BHcBbS9vr1mtt+vJjPdksIBNUmKAW8TFUDPJK5SUU3QhE9NEXDw==", + "dev": true + }, + "escape-string-regexp": { + "version": "1.0.5", + "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-1.0.5.tgz", + "integrity": "sha512-vbRorB5FUQWvla16U8R/qgaFIya2qGzwDrNmCZuYKrbdSUMG6I1ZCGQRefkRVhuOkIGVne7BQ35DSfo1qvJqFg==", + "dev": true + }, + "has-flag": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-3.0.0.tgz", + "integrity": "sha512-sKJf1+ceQBr4SMkvQnBDNDtf4TXpVhVGateu0t918bl30FnbE2m4vNLX+VWe/dpjlb+HugGYzW7uQXH98HPEYw==", + "dev": true + }, + "supports-color": { + "version": "5.5.0", + "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-5.5.0.tgz", + "integrity": "sha512-QjVjwdXIt408MIiAqCX4oUKsgU2EqAGzs2Ppkm4aQYbjm+ZEWEcW4SfFNTr4uMNZma0ey4f5lgLrkB0aX0QMow==", + "dev": true, + "requires": { + "has-flag": "^3.0.0" + } + } + } + }, + "@babel/parser": { + "version": "7.21.2", + "resolved": "https://registry.npmjs.org/@babel/parser/-/parser-7.21.2.tgz", + "integrity": "sha512-URpaIJQwEkEC2T9Kn+Ai6Xe/02iNaVCuT/PtoRz3GPVJVDpPd7mLo+VddTbhCRU9TXqW5mSrQfXZyi8kDKOVpQ==", + "dev": true + }, + "@babel/plugin-syntax-async-generators": { + "version": "7.8.4", + "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-async-generators/-/plugin-syntax-async-generators-7.8.4.tgz", + "integrity": "sha512-tycmZxkGfZaxhMRbXlPXuVFpdWlXpir2W4AMhSJgRKzk/eDlIXOhb2LHWoLpDF7TEHylV5zNhykX6KAgHJmTNw==", + "dev": true, + "requires": { + "@babel/helper-plugin-utils": "^7.8.0" + } + }, + "@babel/plugin-syntax-bigint": { + "version": "7.8.3", + "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-bigint/-/plugin-syntax-bigint-7.8.3.tgz", + "integrity": "sha512-wnTnFlG+YxQm3vDxpGE57Pj0srRU4sHE/mDkt1qv2YJJSeUAec2ma4WLUnUPeKjyrfntVwe/N6dCXpU+zL3Npg==", + "dev": true, + "requires": { + "@babel/helper-plugin-utils": "^7.8.0" + } + }, + "@babel/plugin-syntax-class-properties": { + "version": "7.12.13", + "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-class-properties/-/plugin-syntax-class-properties-7.12.13.tgz", + "integrity": "sha512-fm4idjKla0YahUNgFNLCB0qySdsoPiZP3iQE3rky0mBUtMZ23yDJ9SJdg6dXTSDnulOVqiF3Hgr9nbXvXTQZYA==", + "dev": true, + "requires": { + "@babel/helper-plugin-utils": "^7.12.13" + } + }, + "@babel/plugin-syntax-import-meta": { + "version": "7.10.4", + "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-import-meta/-/plugin-syntax-import-meta-7.10.4.tgz", + "integrity": "sha512-Yqfm+XDx0+Prh3VSeEQCPU81yC+JWZ2pDPFSS4ZdpfZhp4MkFMaDC1UqseovEKwSUpnIL7+vK+Clp7bfh0iD7g==", + "dev": true, + "requires": { + "@babel/helper-plugin-utils": "^7.10.4" + } + }, + "@babel/plugin-syntax-json-strings": { + "version": "7.8.3", + "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-json-strings/-/plugin-syntax-json-strings-7.8.3.tgz", + "integrity": "sha512-lY6kdGpWHvjoe2vk4WrAapEuBR69EMxZl+RoGRhrFGNYVK8mOPAW8VfbT/ZgrFbXlDNiiaxQnAtgVCZ6jv30EA==", + "dev": true, + "requires": { + "@babel/helper-plugin-utils": "^7.8.0" + } + }, + "@babel/plugin-syntax-jsx": { + "version": "7.18.6", + "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-jsx/-/plugin-syntax-jsx-7.18.6.tgz", + "integrity": "sha512-6mmljtAedFGTWu2p/8WIORGwy+61PLgOMPOdazc7YoJ9ZCWUyFy3A6CpPkRKLKD1ToAesxX8KGEViAiLo9N+7Q==", + "dev": true, + "requires": { + "@babel/helper-plugin-utils": "^7.18.6" + } + }, + "@babel/plugin-syntax-logical-assignment-operators": { + "version": "7.10.4", + "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-logical-assignment-operators/-/plugin-syntax-logical-assignment-operators-7.10.4.tgz", + "integrity": "sha512-d8waShlpFDinQ5MtvGU9xDAOzKH47+FFoney2baFIoMr952hKOLp1HR7VszoZvOsV/4+RRszNY7D17ba0te0ig==", + "dev": true, + "requires": { + "@babel/helper-plugin-utils": "^7.10.4" + } + }, + "@babel/plugin-syntax-nullish-coalescing-operator": { + "version": "7.8.3", + "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-nullish-coalescing-operator/-/plugin-syntax-nullish-coalescing-operator-7.8.3.tgz", + "integrity": "sha512-aSff4zPII1u2QD7y+F8oDsz19ew4IGEJg9SVW+bqwpwtfFleiQDMdzA/R+UlWDzfnHFCxxleFT0PMIrR36XLNQ==", + "dev": true, + "requires": { + "@babel/helper-plugin-utils": "^7.8.0" + } + }, + "@babel/plugin-syntax-numeric-separator": { + "version": "7.10.4", + "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-numeric-separator/-/plugin-syntax-numeric-separator-7.10.4.tgz", + "integrity": "sha512-9H6YdfkcK/uOnY/K7/aA2xpzaAgkQn37yzWUMRK7OaPOqOpGS1+n0H5hxT9AUw9EsSjPW8SVyMJwYRtWs3X3ug==", + "dev": true, + "requires": { + "@babel/helper-plugin-utils": "^7.10.4" + } + }, + "@babel/plugin-syntax-object-rest-spread": { + "version": "7.8.3", + "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-object-rest-spread/-/plugin-syntax-object-rest-spread-7.8.3.tgz", + "integrity": "sha512-XoqMijGZb9y3y2XskN+P1wUGiVwWZ5JmoDRwx5+3GmEplNyVM2s2Dg8ILFQm8rWM48orGy5YpI5Bl8U1y7ydlA==", + "dev": true, + "requires": { + "@babel/helper-plugin-utils": "^7.8.0" + } + }, + "@babel/plugin-syntax-optional-catch-binding": { + "version": "7.8.3", + "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-optional-catch-binding/-/plugin-syntax-optional-catch-binding-7.8.3.tgz", + "integrity": "sha512-6VPD0Pc1lpTqw0aKoeRTMiB+kWhAoT24PA+ksWSBrFtl5SIRVpZlwN3NNPQjehA2E/91FV3RjLWoVTglWcSV3Q==", + "dev": true, + "requires": { + "@babel/helper-plugin-utils": "^7.8.0" + } + }, + "@babel/plugin-syntax-optional-chaining": { + "version": "7.8.3", + "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-optional-chaining/-/plugin-syntax-optional-chaining-7.8.3.tgz", + "integrity": "sha512-KoK9ErH1MBlCPxV0VANkXW2/dw4vlbGDrFgz8bmUsBGYkFRcbRwMh6cIJubdPrkxRwuGdtCk0v/wPTKbQgBjkg==", + "dev": true, + "requires": { + "@babel/helper-plugin-utils": "^7.8.0" + } + }, + "@babel/plugin-syntax-top-level-await": { + "version": "7.14.5", + "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-top-level-await/-/plugin-syntax-top-level-await-7.14.5.tgz", + "integrity": "sha512-hx++upLv5U1rgYfwe1xBQUhRmU41NEvpUvrp8jkrSCdvGSnM5/qdRMtylJ6PG5OFkBaHkbTAKTnd3/YyESRHFw==", + "dev": true, + "requires": { + "@babel/helper-plugin-utils": "^7.14.5" + } + }, + "@babel/plugin-syntax-typescript": { + "version": "7.20.0", + "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-typescript/-/plugin-syntax-typescript-7.20.0.tgz", + "integrity": "sha512-rd9TkG+u1CExzS4SM1BlMEhMXwFLKVjOAFFCDx9PbX5ycJWDoWMcwdJH9RhkPu1dOgn5TrxLot/Gx6lWFuAUNQ==", + "dev": true, + "requires": { + "@babel/helper-plugin-utils": "^7.19.0" + } + }, + "@babel/template": { + "version": "7.20.7", + "resolved": "https://registry.npmjs.org/@babel/template/-/template-7.20.7.tgz", + "integrity": "sha512-8SegXApWe6VoNw0r9JHpSteLKTpTiLZ4rMlGIm9JQ18KiCtyQiAMEazujAHrUS5flrcqYZa75ukev3P6QmUwUw==", + "dev": true, + "requires": { + "@babel/code-frame": "^7.18.6", + "@babel/parser": "^7.20.7", + "@babel/types": "^7.20.7" + } + }, + "@babel/traverse": { + "version": "7.21.2", + "resolved": "https://registry.npmjs.org/@babel/traverse/-/traverse-7.21.2.tgz", + "integrity": "sha512-ts5FFU/dSUPS13tv8XiEObDu9K+iagEKME9kAbaP7r0Y9KtZJZ+NGndDvWoRAYNpeWafbpFeki3q9QoMD6gxyw==", + "dev": true, + "requires": { + "@babel/code-frame": "^7.18.6", + "@babel/generator": "^7.21.1", + "@babel/helper-environment-visitor": "^7.18.9", + "@babel/helper-function-name": "^7.21.0", + "@babel/helper-hoist-variables": "^7.18.6", + "@babel/helper-split-export-declaration": "^7.18.6", + "@babel/parser": "^7.21.2", + "@babel/types": "^7.21.2", + "debug": "^4.1.0", + "globals": "^11.1.0" + }, + "dependencies": { + "globals": { + "version": "11.12.0", + "resolved": "https://registry.npmjs.org/globals/-/globals-11.12.0.tgz", + "integrity": "sha512-WOBp/EEGUiIsJSp7wcv/y6MO+lV9UoncWqxuFfm8eBwzWNgyfBd6Gz+IeKQ9jCmyhoH99g15M3T+QaVHFjizVA==", + "dev": true + } + } + }, + "@babel/types": { + "version": "7.21.2", + "resolved": "https://registry.npmjs.org/@babel/types/-/types-7.21.2.tgz", + "integrity": "sha512-3wRZSs7jiFaB8AjxiiD+VqN5DTG2iRvJGQ+qYFrs/654lg6kGTQWIOFjlBo5RaXuAZjBmP3+OQH4dmhqiiyYxw==", + "dev": true, + "requires": { + "@babel/helper-string-parser": "^7.19.4", + "@babel/helper-validator-identifier": "^7.19.1", + "to-fast-properties": "^2.0.0" + } + }, + "@bcoe/v8-coverage": { + "version": "0.2.3", + "resolved": "https://registry.npmjs.org/@bcoe/v8-coverage/-/v8-coverage-0.2.3.tgz", + "integrity": "sha512-0hYQ8SB4Db5zvZB4axdMHGwEaQjkZzFjQiN9LVYvIFB2nSUHW9tYpxWriPrWDASIxiaXax83REcLxuSdnGPZtw==", + "dev": true + }, + "@eslint/eslintrc": { + "version": "1.4.1", + "resolved": "https://registry.npmjs.org/@eslint/eslintrc/-/eslintrc-1.4.1.tgz", + "integrity": "sha512-XXrH9Uarn0stsyldqDYq8r++mROmWRI1xKMXa640Bb//SY1+ECYX6VzT6Lcx5frD0V30XieqJ0oX9I2Xj5aoMA==", + "dev": true, + "requires": { + "ajv": "^6.12.4", + "debug": "^4.3.2", + "espree": "^9.4.0", + "globals": "^13.19.0", + "ignore": "^5.2.0", + "import-fresh": "^3.2.1", + "js-yaml": "^4.1.0", + "minimatch": "^3.1.2", + "strip-json-comments": "^3.1.1" + } + }, + "@ewoudenberg/difflib": { + "version": "0.1.0", + "resolved": "https://registry.npmjs.org/@ewoudenberg/difflib/-/difflib-0.1.0.tgz", + "integrity": "sha512-OU5P5mJyD3OoWYMWY+yIgwvgNS9cFAU10f+DDuvtogcWQOoJIsQ4Hy2McSfUfhKjq8L0FuWVb4Rt7kgA+XK86A==", + "dev": true, + "requires": { + "heap": ">= 0.2.0" + } + }, + "@humanwhocodes/config-array": { + "version": "0.11.8", + "resolved": "https://registry.npmjs.org/@humanwhocodes/config-array/-/config-array-0.11.8.tgz", + "integrity": "sha512-UybHIJzJnR5Qc/MsD9Kr+RpO2h+/P1GhOwdiLPXK5TWk5sgTdu88bTD9UP+CKbPPh5Rni1u0GjAdYQLemG8g+g==", + "dev": true, + "requires": { + "@humanwhocodes/object-schema": "^1.2.1", + "debug": "^4.1.1", + "minimatch": "^3.0.5" + } + }, + "@humanwhocodes/module-importer": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/@humanwhocodes/module-importer/-/module-importer-1.0.1.tgz", + "integrity": "sha512-bxveV4V8v5Yb4ncFTT3rPSgZBOpCkjfK0y4oVVVJwIuDVBRMDXrPyXRL988i5ap9m9bnyEEjWfm5WkBmtffLfA==", + "dev": true + }, + "@humanwhocodes/object-schema": { + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/@humanwhocodes/object-schema/-/object-schema-1.2.1.tgz", + "integrity": "sha512-ZnQMnLV4e7hDlUvw8H+U8ASL02SS2Gn6+9Ac3wGGLIe7+je2AeAOxPY+izIPJDfFDb7eDjev0Us8MO1iFRN8hA==", + "dev": true + }, + "@istanbuljs/load-nyc-config": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/@istanbuljs/load-nyc-config/-/load-nyc-config-1.1.0.tgz", + "integrity": "sha512-VjeHSlIzpv/NyD3N0YuHfXOPDIixcA1q2ZV98wsMqcYlPmv2n3Yb2lYP9XMElnaFVXg5A7YLTeLu6V84uQDjmQ==", + "dev": true, + "requires": { + "camelcase": "^5.3.1", + "find-up": "^4.1.0", + "get-package-type": "^0.1.0", + "js-yaml": "^3.13.1", + "resolve-from": "^5.0.0" + }, + "dependencies": { + "argparse": { + "version": "1.0.10", + "resolved": "https://registry.npmjs.org/argparse/-/argparse-1.0.10.tgz", + "integrity": "sha512-o5Roy6tNG4SL/FOkCAN6RzjiakZS25RLYFrcMttJqbdd8BWrnA+fGz57iN5Pb06pvBGvl5gQ0B48dJlslXvoTg==", + "dev": true, + "requires": { + "sprintf-js": "~1.0.2" + } + }, + "find-up": { + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/find-up/-/find-up-4.1.0.tgz", + "integrity": "sha512-PpOwAdQ/YlXQ2vj8a3h8IipDuYRi3wceVQQGYWxNINccq40Anw7BlsEXCMbt1Zt+OLA6Fq9suIpIWD0OsnISlw==", + "dev": true, + "requires": { + "locate-path": "^5.0.0", + "path-exists": "^4.0.0" + } + }, + "js-yaml": { + "version": "3.14.1", + "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-3.14.1.tgz", + "integrity": "sha512-okMH7OXXJ7YrN9Ok3/SXrnu4iX9yOk+25nqX4imS2npuvTYDmo/QEZoqwZkYaIDk3jVvBOTOIEgEhaLOynBS9g==", + "dev": true, + "requires": { + "argparse": "^1.0.7", + "esprima": "^4.0.0" + } + }, + "locate-path": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/locate-path/-/locate-path-5.0.0.tgz", + "integrity": "sha512-t7hw9pI+WvuwNJXwk5zVHpyhIqzg2qTlklJOf0mVxGSbe3Fp2VieZcduNYjaLDoy6p9uGpQEGWG87WpMKlNq8g==", + "dev": true, + "requires": { + "p-locate": "^4.1.0" + } + }, + "p-limit": { + "version": "2.3.0", + "resolved": "https://registry.npmjs.org/p-limit/-/p-limit-2.3.0.tgz", + "integrity": "sha512-//88mFWSJx8lxCzwdAABTJL2MyWB12+eIY7MDL2SqLmAkeKU9qxRvWuSyTjm3FUmpBEMuFfckAIqEaVGUDxb6w==", + "dev": true, + "requires": { + "p-try": "^2.0.0" + } + }, + "p-locate": { + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/p-locate/-/p-locate-4.1.0.tgz", + "integrity": "sha512-R79ZZ/0wAxKGu3oYMlz8jy/kbhsNrS7SKZ7PxEHBgJ5+F2mtFW2fK2cOtBh1cHYkQsbzFV7I+EoRKe6Yt0oK7A==", + "dev": true, + "requires": { + "p-limit": "^2.2.0" + } + }, + "resolve-from": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/resolve-from/-/resolve-from-5.0.0.tgz", + "integrity": "sha512-qYg9KP24dD5qka9J47d0aVky0N+b4fTU89LN9iDnjB5waksiC49rvMB0PrUJQGoTmH50XPiqOvAjDfaijGxYZw==", + "dev": true + } + } + }, + "@istanbuljs/schema": { + "version": "0.1.3", + "resolved": "https://registry.npmjs.org/@istanbuljs/schema/-/schema-0.1.3.tgz", + "integrity": "sha512-ZXRY4jNvVgSVQ8DL3LTcakaAtXwTVUxE81hslsyD2AtoXW/wVob10HkOJ1X/pAlcI7D+2YoZKg5do8G/w6RYgA==", + "dev": true + }, + "@jest/console": { + "version": "29.5.0", + "resolved": "https://registry.npmjs.org/@jest/console/-/console-29.5.0.tgz", + "integrity": "sha512-NEpkObxPwyw/XxZVLPmAGKE89IQRp4puc6IQRPru6JKd1M3fW9v1xM1AnzIJE65hbCkzQAdnL8P47e9hzhiYLQ==", + "dev": true, + "requires": { + "@jest/types": "^29.5.0", + "@types/node": "*", + "chalk": "^4.0.0", + "jest-message-util": "^29.5.0", + "jest-util": "^29.5.0", + "slash": "^3.0.0" + } + }, + "@jest/core": { + "version": "29.5.0", + "resolved": "https://registry.npmjs.org/@jest/core/-/core-29.5.0.tgz", + "integrity": "sha512-28UzQc7ulUrOQw1IsN/kv1QES3q2kkbl/wGslyhAclqZ/8cMdB5M68BffkIdSJgKBUt50d3hbwJ92XESlE7LiQ==", + "dev": true, + "requires": { + "@jest/console": "^29.5.0", + "@jest/reporters": "^29.5.0", + "@jest/test-result": "^29.5.0", + "@jest/transform": "^29.5.0", + "@jest/types": "^29.5.0", + "@types/node": "*", + "ansi-escapes": "^4.2.1", + "chalk": "^4.0.0", + "ci-info": "^3.2.0", + "exit": "^0.1.2", + "graceful-fs": "^4.2.9", + "jest-changed-files": "^29.5.0", + "jest-config": "^29.5.0", + "jest-haste-map": "^29.5.0", + "jest-message-util": "^29.5.0", + "jest-regex-util": "^29.4.3", + "jest-resolve": "^29.5.0", + "jest-resolve-dependencies": "^29.5.0", + "jest-runner": "^29.5.0", + "jest-runtime": "^29.5.0", + "jest-snapshot": "^29.5.0", + "jest-util": "^29.5.0", + "jest-validate": "^29.5.0", + "jest-watcher": "^29.5.0", + "micromatch": "^4.0.4", + "pretty-format": "^29.5.0", + "slash": "^3.0.0", + "strip-ansi": "^6.0.0" + } + }, + "@jest/environment": { + "version": "29.5.0", + "resolved": "https://registry.npmjs.org/@jest/environment/-/environment-29.5.0.tgz", + "integrity": "sha512-5FXw2+wD29YU1d4I2htpRX7jYnAyTRjP2CsXQdo9SAM8g3ifxWPSV0HnClSn71xwctr0U3oZIIH+dtbfmnbXVQ==", + "dev": true, + "requires": { + "@jest/fake-timers": "^29.5.0", + "@jest/types": "^29.5.0", + "@types/node": "*", + "jest-mock": "^29.5.0" + } + }, + "@jest/expect": { + "version": "29.5.0", + "resolved": "https://registry.npmjs.org/@jest/expect/-/expect-29.5.0.tgz", + "integrity": "sha512-PueDR2HGihN3ciUNGr4uelropW7rqUfTiOn+8u0leg/42UhblPxHkfoh0Ruu3I9Y1962P3u2DY4+h7GVTSVU6g==", + "dev": true, + "requires": { + "expect": "^29.5.0", + "jest-snapshot": "^29.5.0" + } + }, + "@jest/expect-utils": { + "version": "29.5.0", + "resolved": "https://registry.npmjs.org/@jest/expect-utils/-/expect-utils-29.5.0.tgz", + "integrity": "sha512-fmKzsidoXQT2KwnrwE0SQq3uj8Z763vzR8LnLBwC2qYWEFpjX8daRsk6rHUM1QvNlEW/UJXNXm59ztmJJWs2Mg==", + "dev": true, + "requires": { + "jest-get-type": "^29.4.3" + } + }, + "@jest/fake-timers": { + "version": "29.5.0", + "resolved": "https://registry.npmjs.org/@jest/fake-timers/-/fake-timers-29.5.0.tgz", + "integrity": "sha512-9ARvuAAQcBwDAqOnglWq2zwNIRUDtk/SCkp/ToGEhFv5r86K21l+VEs0qNTaXtyiY0lEePl3kylijSYJQqdbDg==", + "dev": true, + "requires": { + "@jest/types": "^29.5.0", + "@sinonjs/fake-timers": "^10.0.2", + "@types/node": "*", + "jest-message-util": "^29.5.0", + "jest-mock": "^29.5.0", + "jest-util": "^29.5.0" + } + }, + "@jest/globals": { + "version": "29.5.0", + "resolved": "https://registry.npmjs.org/@jest/globals/-/globals-29.5.0.tgz", + "integrity": "sha512-S02y0qMWGihdzNbUiqSAiKSpSozSuHX5UYc7QbnHP+D9Lyw8DgGGCinrN9uSuHPeKgSSzvPom2q1nAtBvUsvPQ==", + "dev": true, + "requires": { + "@jest/environment": "^29.5.0", + "@jest/expect": "^29.5.0", + "@jest/types": "^29.5.0", + "jest-mock": "^29.5.0" + } + }, + "@jest/reporters": { + "version": "29.5.0", + "resolved": "https://registry.npmjs.org/@jest/reporters/-/reporters-29.5.0.tgz", + "integrity": "sha512-D05STXqj/M8bP9hQNSICtPqz97u7ffGzZu+9XLucXhkOFBqKcXe04JLZOgIekOxdb73MAoBUFnqvf7MCpKk5OA==", + "dev": true, + "requires": { + "@bcoe/v8-coverage": "^0.2.3", + "@jest/console": "^29.5.0", + "@jest/test-result": "^29.5.0", + "@jest/transform": "^29.5.0", + "@jest/types": "^29.5.0", + "@jridgewell/trace-mapping": "^0.3.15", + "@types/node": "*", + "chalk": "^4.0.0", + "collect-v8-coverage": "^1.0.0", + "exit": "^0.1.2", + "glob": "^7.1.3", + "graceful-fs": "^4.2.9", + "istanbul-lib-coverage": "^3.0.0", + "istanbul-lib-instrument": "^5.1.0", + "istanbul-lib-report": "^3.0.0", + "istanbul-lib-source-maps": "^4.0.0", + "istanbul-reports": "^3.1.3", + "jest-message-util": "^29.5.0", + "jest-util": "^29.5.0", + "jest-worker": "^29.5.0", + "slash": "^3.0.0", + "string-length": "^4.0.1", + "strip-ansi": "^6.0.0", + "v8-to-istanbul": "^9.0.1" + } + }, + "@jest/schemas": { + "version": "29.4.3", + "resolved": "https://registry.npmjs.org/@jest/schemas/-/schemas-29.4.3.tgz", + "integrity": "sha512-VLYKXQmtmuEz6IxJsrZwzG9NvtkQsWNnWMsKxqWNu3+CnfzJQhp0WDDKWLVV9hLKr0l3SLLFRqcYHjhtyuDVxg==", + "dev": true, + "requires": { + "@sinclair/typebox": "^0.25.16" + } + }, + "@jest/source-map": { + "version": "29.4.3", + "resolved": "https://registry.npmjs.org/@jest/source-map/-/source-map-29.4.3.tgz", + "integrity": "sha512-qyt/mb6rLyd9j1jUts4EQncvS6Yy3PM9HghnNv86QBlV+zdL2inCdK1tuVlL+J+lpiw2BI67qXOrX3UurBqQ1w==", + "dev": true, + "requires": { + "@jridgewell/trace-mapping": "^0.3.15", + "callsites": "^3.0.0", + "graceful-fs": "^4.2.9" + } + }, + "@jest/test-result": { + "version": "29.5.0", + "resolved": "https://registry.npmjs.org/@jest/test-result/-/test-result-29.5.0.tgz", + "integrity": "sha512-fGl4rfitnbfLsrfx1uUpDEESS7zM8JdgZgOCQuxQvL1Sn/I6ijeAVQWGfXI9zb1i9Mzo495cIpVZhA0yr60PkQ==", + "dev": true, + "requires": { + "@jest/console": "^29.5.0", + "@jest/types": "^29.5.0", + "@types/istanbul-lib-coverage": "^2.0.0", + "collect-v8-coverage": "^1.0.0" + } + }, + "@jest/test-sequencer": { + "version": "29.5.0", + "resolved": "https://registry.npmjs.org/@jest/test-sequencer/-/test-sequencer-29.5.0.tgz", + "integrity": "sha512-yPafQEcKjkSfDXyvtgiV4pevSeyuA6MQr6ZIdVkWJly9vkqjnFfcfhRQqpD5whjoU8EORki752xQmjaqoFjzMQ==", + "dev": true, + "requires": { + "@jest/test-result": "^29.5.0", + "graceful-fs": "^4.2.9", + "jest-haste-map": "^29.5.0", + "slash": "^3.0.0" + } + }, + "@jest/transform": { + "version": "29.5.0", + "resolved": "https://registry.npmjs.org/@jest/transform/-/transform-29.5.0.tgz", + "integrity": "sha512-8vbeZWqLJOvHaDfeMuoHITGKSz5qWc9u04lnWrQE3VyuSw604PzQM824ZeX9XSjUCeDiE3GuxZe5UKa8J61NQw==", + "dev": true, + "requires": { + "@babel/core": "^7.11.6", + "@jest/types": "^29.5.0", + "@jridgewell/trace-mapping": "^0.3.15", + "babel-plugin-istanbul": "^6.1.1", + "chalk": "^4.0.0", + "convert-source-map": "^2.0.0", + "fast-json-stable-stringify": "^2.1.0", + "graceful-fs": "^4.2.9", + "jest-haste-map": "^29.5.0", + "jest-regex-util": "^29.4.3", + "jest-util": "^29.5.0", + "micromatch": "^4.0.4", + "pirates": "^4.0.4", + "slash": "^3.0.0", + "write-file-atomic": "^4.0.2" + } + }, + "@jest/types": { + "version": "29.5.0", + "resolved": "https://registry.npmjs.org/@jest/types/-/types-29.5.0.tgz", + "integrity": "sha512-qbu7kN6czmVRc3xWFQcAN03RAUamgppVUdXrvl1Wr3jlNF93o9mJbGcDWrwGB6ht44u7efB1qCFgVQmca24Uog==", + "dev": true, + "requires": { + "@jest/schemas": "^29.4.3", + "@types/istanbul-lib-coverage": "^2.0.0", + "@types/istanbul-reports": "^3.0.0", + "@types/node": "*", + "@types/yargs": "^17.0.8", + "chalk": "^4.0.0" + } + }, + "@jridgewell/gen-mapping": { + "version": "0.1.1", + "resolved": "https://registry.npmjs.org/@jridgewell/gen-mapping/-/gen-mapping-0.1.1.tgz", + "integrity": "sha512-sQXCasFk+U8lWYEe66WxRDOE9PjVz4vSM51fTu3Hw+ClTpUSQb718772vH3pyS5pShp6lvQM7SxgIDXXXmOX7w==", + "dev": true, + "requires": { + "@jridgewell/set-array": "^1.0.0", + "@jridgewell/sourcemap-codec": "^1.4.10" + } + }, + "@jridgewell/resolve-uri": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/@jridgewell/resolve-uri/-/resolve-uri-3.1.0.tgz", + "integrity": "sha512-F2msla3tad+Mfht5cJq7LSXcdudKTWCVYUgw6pLFOOHSTtZlj6SWNYAp+AhuqLmWdBO2X5hPrLcu8cVP8fy28w==", + "dev": true + }, + "@jridgewell/set-array": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/@jridgewell/set-array/-/set-array-1.1.2.tgz", + "integrity": "sha512-xnkseuNADM0gt2bs+BvhO0p78Mk762YnZdsuzFV018NoG1Sj1SCQvpSqa7XUaTam5vAGasABV9qXASMKnFMwMw==", + "dev": true + }, + "@jridgewell/sourcemap-codec": { + "version": "1.4.14", + "resolved": "https://registry.npmjs.org/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.4.14.tgz", + "integrity": "sha512-XPSJHWmi394fuUuzDnGz1wiKqWfo1yXecHQMRf2l6hztTO+nPru658AyDngaBe7isIxEkRsPR3FZh+s7iVa4Uw==", + "dev": true + }, + "@jridgewell/trace-mapping": { + "version": "0.3.17", + "resolved": "https://registry.npmjs.org/@jridgewell/trace-mapping/-/trace-mapping-0.3.17.tgz", + "integrity": "sha512-MCNzAp77qzKca9+W/+I0+sEpaUnZoeasnghNeVc41VZCEKaCH73Vq3BZZ/SzWIgrqE4H4ceI+p+b6C0mHf9T4g==", + "dev": true, + "requires": { + "@jridgewell/resolve-uri": "3.1.0", + "@jridgewell/sourcemap-codec": "1.4.14" + } + }, + "@mapbox/node-pre-gyp": { + "version": "1.0.10", + "resolved": "https://registry.npmjs.org/@mapbox/node-pre-gyp/-/node-pre-gyp-1.0.10.tgz", + "integrity": "sha512-4ySo4CjzStuprMwk35H5pPbkymjv1SF3jGLj6rAHp/xT/RF7TL7bd9CTm1xDY49K2qF7jmR/g7k+SkLETP6opA==", + "requires": { + "detect-libc": "^2.0.0", + "https-proxy-agent": "^5.0.0", + "make-dir": "^3.1.0", + "node-fetch": "^2.6.7", + "nopt": "^5.0.0", + "npmlog": "^5.0.1", + "rimraf": "^3.0.2", + "semver": "^7.3.5", + "tar": "^6.1.11" + }, + "dependencies": { + "lru-cache": { + "version": "6.0.0", + "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-6.0.0.tgz", + "integrity": "sha512-Jo6dJ04CmSjuznwJSS3pUeWmd/H0ffTlkXXgwZi+eq1UCmqQwCh+eLsYOYCwY991i2Fah4h1BEMCx4qThGbsiA==", + "requires": { + "yallist": "^4.0.0" + } + }, + "semver": { + "version": "7.3.8", + "resolved": "https://registry.npmjs.org/semver/-/semver-7.3.8.tgz", + "integrity": "sha512-NB1ctGL5rlHrPJtFDVIVzTyQylMLu9N9VICA6HSFJo8MCGVTMW6gfpicwKmmK/dAjTOrqu5l63JJOpDSrAis3A==", + "requires": { + "lru-cache": "^6.0.0" + } + }, + "yallist": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/yallist/-/yallist-4.0.0.tgz", + "integrity": "sha512-3wdGidZyq5PB084XLES5TpOSRA3wjXAlIWMhum2kRcv/41Sn2emQ0dycQW4uZXLejwKvg6EsvbdlVL+FYEct7A==" + } + } + }, + "@nodelib/fs.scandir": { + "version": "2.1.5", + "resolved": "https://registry.npmjs.org/@nodelib/fs.scandir/-/fs.scandir-2.1.5.tgz", + "integrity": "sha512-vq24Bq3ym5HEQm2NKCr3yXDwjc7vTsEThRDnkp2DK9p1uqLR+DHurm/NOTo0KG7HYHU7eppKZj3MyqYuMBf62g==", + "dev": true, + "requires": { + "@nodelib/fs.stat": "2.0.5", + "run-parallel": "^1.1.9" + } + }, + "@nodelib/fs.stat": { + "version": "2.0.5", + "resolved": "https://registry.npmjs.org/@nodelib/fs.stat/-/fs.stat-2.0.5.tgz", + "integrity": "sha512-RkhPPp2zrqDAQA/2jNhnztcPAlv64XdhIp7a7454A5ovI7Bukxgt7MX7udwAu3zg1DcpPU0rz3VV1SeaqvY4+A==", + "dev": true + }, + "@nodelib/fs.walk": { + "version": "1.2.8", + "resolved": "https://registry.npmjs.org/@nodelib/fs.walk/-/fs.walk-1.2.8.tgz", + "integrity": "sha512-oGB+UxlgWcgQkgwo8GcEGwemoTFt3FIO9ababBmaGwXIoBKZ+GTy0pP185beGg7Llih/NSHSV2XAs1lnznocSg==", + "dev": true, + "requires": { + "@nodelib/fs.scandir": "2.1.5", + "fastq": "^1.6.0" + } + }, + "@octokit/auth-token": { + "version": "3.0.3", + "resolved": "https://registry.npmjs.org/@octokit/auth-token/-/auth-token-3.0.3.tgz", + "integrity": "sha512-/aFM2M4HVDBT/jjDBa84sJniv1t9Gm/rLkalaz9htOm+L+8JMj1k9w0CkUdcxNyNxZPlTxKPVko+m1VlM58ZVA==", + "requires": { + "@octokit/types": "^9.0.0" + } + }, + "@octokit/core": { + "version": "4.2.0", + "resolved": "https://registry.npmjs.org/@octokit/core/-/core-4.2.0.tgz", + "integrity": "sha512-AgvDRUg3COpR82P7PBdGZF/NNqGmtMq2NiPqeSsDIeCfYFOZ9gddqWNQHnFdEUf+YwOj4aZYmJnlPp7OXmDIDg==", + "requires": { + "@octokit/auth-token": "^3.0.0", + "@octokit/graphql": "^5.0.0", + "@octokit/request": "^6.0.0", + "@octokit/request-error": "^3.0.0", + "@octokit/types": "^9.0.0", + "before-after-hook": "^2.2.0", + "universal-user-agent": "^6.0.0" + } + }, + "@octokit/endpoint": { + "version": "7.0.5", + "resolved": "https://registry.npmjs.org/@octokit/endpoint/-/endpoint-7.0.5.tgz", + "integrity": "sha512-LG4o4HMY1Xoaec87IqQ41TQ+glvIeTKqfjkCEmt5AIwDZJwQeVZFIEYXrYY6yLwK+pAScb9Gj4q+Nz2qSw1roA==", + "requires": { + "@octokit/types": "^9.0.0", + "is-plain-object": "^5.0.0", + "universal-user-agent": "^6.0.0" + } + }, + "@octokit/fixtures": { + "version": "22.0.6", + "resolved": "https://registry.npmjs.org/@octokit/fixtures/-/fixtures-22.0.6.tgz", + "integrity": "sha512-fSxpinPEC+6pIm47A3tC7Ur5gguJSIDHNVapUZMvIK5GqTauvdkr0Q5MbXmzXstlyJLWmXTK8jOlHVU1YJ0NcA==", + "dev": true, + "requires": { + "json-diff": "^1.0.0", + "lodash": "^4.17.11", + "nock": "^13.0.0", + "url-template": "^3.0.0" + } + }, + "@octokit/graphql": { + "version": "5.0.5", + "resolved": "https://registry.npmjs.org/@octokit/graphql/-/graphql-5.0.5.tgz", + "integrity": "sha512-Qwfvh3xdqKtIznjX9lz2D458r7dJPP8l6r4GQkIdWQouZwHQK0mVT88uwiU2bdTU2OtT1uOlKpRciUWldpG0yQ==", + "requires": { + "@octokit/request": "^6.0.0", + "@octokit/types": "^9.0.0", + "universal-user-agent": "^6.0.0" + } + }, + "@octokit/openapi-types": { + "version": "16.0.0", + "resolved": "https://registry.npmjs.org/@octokit/openapi-types/-/openapi-types-16.0.0.tgz", + "integrity": "sha512-JbFWOqTJVLHZSUUoF4FzAZKYtqdxWu9Z5m2QQnOyEa04fOFljvyh7D3GYKbfuaSWisqehImiVIMG4eyJeP5VEA==" + }, + "@octokit/plugin-paginate-rest": { + "version": "2.21.3", + "resolved": "https://registry.npmjs.org/@octokit/plugin-paginate-rest/-/plugin-paginate-rest-2.21.3.tgz", + "integrity": "sha512-aCZTEf0y2h3OLbrgKkrfFdjRL6eSOo8komneVQJnYecAxIej7Bafor2xhuDJOIFau4pk0i/P28/XgtbyPF0ZHw==", + "requires": { + "@octokit/types": "^6.40.0" + }, + "dependencies": { + "@octokit/openapi-types": { + "version": "12.11.0", + "resolved": "https://registry.npmjs.org/@octokit/openapi-types/-/openapi-types-12.11.0.tgz", + "integrity": "sha512-VsXyi8peyRq9PqIz/tpqiL2w3w80OgVMwBHltTml3LmVvXiphgeqmY9mvBw9Wu7e0QWk/fqD37ux8yP5uVekyQ==" + }, + "@octokit/types": { + "version": "6.41.0", + "resolved": "https://registry.npmjs.org/@octokit/types/-/types-6.41.0.tgz", + "integrity": "sha512-eJ2jbzjdijiL3B4PrSQaSjuF2sPEQPVCPzBvTHJD9Nz+9dw2SGH4K4xeQJ77YfTq5bRQ+bD8wT11JbeDPmxmGg==", + "requires": { + "@octokit/openapi-types": "^12.11.0" + } + } + } + }, + "@octokit/plugin-request-log": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/@octokit/plugin-request-log/-/plugin-request-log-1.0.4.tgz", + "integrity": "sha512-mLUsMkgP7K/cnFEw07kWqXGF5LKrOkD+lhCrKvPHXWDywAwuDUeDwWBpc69XK3pNX0uKiVt8g5z96PJ6z9xCFA==", + "requires": {} + }, + "@octokit/plugin-rest-endpoint-methods": { + "version": "5.16.2", + "resolved": "https://registry.npmjs.org/@octokit/plugin-rest-endpoint-methods/-/plugin-rest-endpoint-methods-5.16.2.tgz", + "integrity": "sha512-8QFz29Fg5jDuTPXVtey05BLm7OB+M8fnvE64RNegzX7U+5NUXcOcnpTIK0YfSHBg8gYd0oxIq3IZTe9SfPZiRw==", + "requires": { + "@octokit/types": "^6.39.0", + "deprecation": "^2.3.1" + }, + "dependencies": { + "@octokit/openapi-types": { + "version": "12.11.0", + "resolved": "https://registry.npmjs.org/@octokit/openapi-types/-/openapi-types-12.11.0.tgz", + "integrity": "sha512-VsXyi8peyRq9PqIz/tpqiL2w3w80OgVMwBHltTml3LmVvXiphgeqmY9mvBw9Wu7e0QWk/fqD37ux8yP5uVekyQ==" + }, + "@octokit/types": { + "version": "6.41.0", + "resolved": "https://registry.npmjs.org/@octokit/types/-/types-6.41.0.tgz", + "integrity": "sha512-eJ2jbzjdijiL3B4PrSQaSjuF2sPEQPVCPzBvTHJD9Nz+9dw2SGH4K4xeQJ77YfTq5bRQ+bD8wT11JbeDPmxmGg==", + "requires": { + "@octokit/openapi-types": "^12.11.0" + } + } + } + }, + "@octokit/plugin-retry": { + "version": "4.1.1", + "resolved": "https://registry.npmjs.org/@octokit/plugin-retry/-/plugin-retry-4.1.1.tgz", + "integrity": "sha512-iR7rg5KRSl6L6RELTQQ3CYeNgeBJyuAmP95odzcQ/zyefnRT/Peo8rWeky4z7V/+/oPWqOL4I5Z+V8KtjpHCJw==", + "requires": { + "@octokit/types": "^9.0.0", + "bottleneck": "^2.15.3" + } + }, + "@octokit/request": { + "version": "6.2.3", + "resolved": "https://registry.npmjs.org/@octokit/request/-/request-6.2.3.tgz", + "integrity": "sha512-TNAodj5yNzrrZ/VxP+H5HiYaZep0H3GU0O7PaF+fhDrt8FPrnkei9Aal/txsN/1P7V3CPiThG0tIvpPDYUsyAA==", + "requires": { + "@octokit/endpoint": "^7.0.0", + "@octokit/request-error": "^3.0.0", + "@octokit/types": "^9.0.0", + "is-plain-object": "^5.0.0", + "node-fetch": "^2.6.7", + "universal-user-agent": "^6.0.0" + } + }, + "@octokit/request-error": { + "version": "3.0.3", + "resolved": "https://registry.npmjs.org/@octokit/request-error/-/request-error-3.0.3.tgz", + "integrity": "sha512-crqw3V5Iy2uOU5Np+8M/YexTlT8zxCfI+qu+LxUB7SZpje4Qmx3mub5DfEKSO8Ylyk0aogi6TYdf6kxzh2BguQ==", + "requires": { + "@octokit/types": "^9.0.0", + "deprecation": "^2.0.0", + "once": "^1.4.0" + } + }, + "@octokit/rest": { + "version": "19.0.7", + "resolved": "https://registry.npmjs.org/@octokit/rest/-/rest-19.0.7.tgz", + "integrity": "sha512-HRtSfjrWmWVNp2uAkEpQnuGMJsu/+dBr47dRc5QVgsCbnIc1+GFEaoKBWkYG+zjrsHpSqcAElMio+n10c0b5JA==", + "requires": { + "@octokit/core": "^4.1.0", + "@octokit/plugin-paginate-rest": "^6.0.0", + "@octokit/plugin-request-log": "^1.0.4", + "@octokit/plugin-rest-endpoint-methods": "^7.0.0" + }, + "dependencies": { + "@octokit/plugin-paginate-rest": { + "version": "6.0.0", + "resolved": "https://registry.npmjs.org/@octokit/plugin-paginate-rest/-/plugin-paginate-rest-6.0.0.tgz", + "integrity": "sha512-Sq5VU1PfT6/JyuXPyt04KZNVsFOSBaYOAq2QRZUwzVlI10KFvcbUo8lR258AAQL1Et60b0WuVik+zOWKLuDZxw==", + "requires": { + "@octokit/types": "^9.0.0" + } + }, + "@octokit/plugin-rest-endpoint-methods": { + "version": "7.0.1", + "resolved": "https://registry.npmjs.org/@octokit/plugin-rest-endpoint-methods/-/plugin-rest-endpoint-methods-7.0.1.tgz", + "integrity": "sha512-pnCaLwZBudK5xCdrR823xHGNgqOzRnJ/mpC/76YPpNP7DybdsJtP7mdOwh+wYZxK5jqeQuhu59ogMI4NRlBUvA==", + "requires": { + "@octokit/types": "^9.0.0", + "deprecation": "^2.3.1" + } + } + } + }, + "@octokit/types": { + "version": "9.0.0", + "resolved": "https://registry.npmjs.org/@octokit/types/-/types-9.0.0.tgz", + "integrity": "sha512-LUewfj94xCMH2rbD5YJ+6AQ4AVjFYTgpp6rboWM5T7N3IsIF65SBEOVcYMGAEzO/kKNiNaW4LoWtoThOhH06gw==", + "requires": { + "@octokit/openapi-types": "^16.0.0" + } + }, + "@sinclair/typebox": { + "version": "0.25.24", + "resolved": "https://registry.npmjs.org/@sinclair/typebox/-/typebox-0.25.24.tgz", + "integrity": "sha512-XJfwUVUKDHF5ugKwIcxEgc9k8b7HbznCp6eUfWgu710hMPNIO4aw4/zB5RogDQz8nd6gyCDpU9O/m6qYEWY6yQ==", + "dev": true + }, + "@sinonjs/commons": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/@sinonjs/commons/-/commons-2.0.0.tgz", + "integrity": "sha512-uLa0j859mMrg2slwQYdO/AkrOfmH+X6LTVmNTS9CqexuE2IvVORIkSpJLqePAbEnKJ77aMmCwr1NUZ57120Xcg==", + "dev": true, + "requires": { + "type-detect": "4.0.8" + } + }, + "@sinonjs/fake-timers": { + "version": "10.0.2", + "resolved": "https://registry.npmjs.org/@sinonjs/fake-timers/-/fake-timers-10.0.2.tgz", + "integrity": "sha512-SwUDyjWnah1AaNl7kxsa7cfLhlTYoiyhDAIgyh+El30YvXs/o7OLXpYH88Zdhyx9JExKrmHDJ+10bwIcY80Jmw==", + "dev": true, + "requires": { + "@sinonjs/commons": "^2.0.0" + } + }, + "@types/babel__core": { + "version": "7.20.0", + "resolved": "https://registry.npmjs.org/@types/babel__core/-/babel__core-7.20.0.tgz", + "integrity": "sha512-+n8dL/9GWblDO0iU6eZAwEIJVr5DWigtle+Q6HLOrh/pdbXOhOtqzq8VPPE2zvNJzSKY4vH/z3iT3tn0A3ypiQ==", + "dev": true, + "requires": { + "@babel/parser": "^7.20.7", + "@babel/types": "^7.20.7", + "@types/babel__generator": "*", + "@types/babel__template": "*", + "@types/babel__traverse": "*" + } + }, + "@types/babel__generator": { + "version": "7.6.4", + "resolved": "https://registry.npmjs.org/@types/babel__generator/-/babel__generator-7.6.4.tgz", + "integrity": "sha512-tFkciB9j2K755yrTALxD44McOrk+gfpIpvC3sxHjRawj6PfnQxrse4Clq5y/Rq+G3mrBurMax/lG8Qn2t9mSsg==", + "dev": true, + "requires": { + "@babel/types": "^7.0.0" + } + }, + "@types/babel__template": { + "version": "7.4.1", + "resolved": "https://registry.npmjs.org/@types/babel__template/-/babel__template-7.4.1.tgz", + "integrity": "sha512-azBFKemX6kMg5Io+/rdGT0dkGreboUVR0Cdm3fz9QJWpaQGJRQXl7C+6hOTCZcMll7KFyEQpgbYI2lHdsS4U7g==", + "dev": true, + "requires": { + "@babel/parser": "^7.1.0", + "@babel/types": "^7.0.0" + } + }, + "@types/babel__traverse": { + "version": "7.18.3", + "resolved": "https://registry.npmjs.org/@types/babel__traverse/-/babel__traverse-7.18.3.tgz", + "integrity": "sha512-1kbcJ40lLB7MHsj39U4Sh1uTd2E7rLEa79kmDpI6cy+XiXsteB3POdQomoq4FxszMrO3ZYchkhYJw7A2862b3w==", + "dev": true, + "requires": { + "@babel/types": "^7.3.0" + } + }, + "@types/graceful-fs": { + "version": "4.1.6", + "resolved": "https://registry.npmjs.org/@types/graceful-fs/-/graceful-fs-4.1.6.tgz", + "integrity": "sha512-Sig0SNORX9fdW+bQuTEovKj3uHcUL6LQKbCrrqb1X7J6/ReAbhCXRAhc+SMejhLELFj2QcyuxmUooZ4bt5ReSw==", + "dev": true, + "requires": { + "@types/node": "*" + } + }, + "@types/istanbul-lib-coverage": { + "version": "2.0.4", + "resolved": "https://registry.npmjs.org/@types/istanbul-lib-coverage/-/istanbul-lib-coverage-2.0.4.tgz", + "integrity": "sha512-z/QT1XN4K4KYuslS23k62yDIDLwLFkzxOuMplDtObz0+y7VqJCaO2o+SPwHCvLFZh7xazvvoor2tA/hPz9ee7g==", + "dev": true + }, + "@types/istanbul-lib-report": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/@types/istanbul-lib-report/-/istanbul-lib-report-3.0.0.tgz", + "integrity": "sha512-plGgXAPfVKFoYfa9NpYDAkseG+g6Jr294RqeqcqDixSbU34MZVJRi/P+7Y8GDpzkEwLaGZZOpKIEmeVZNtKsrg==", + "dev": true, + "requires": { + "@types/istanbul-lib-coverage": "*" + } + }, + "@types/istanbul-reports": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/@types/istanbul-reports/-/istanbul-reports-3.0.1.tgz", + "integrity": "sha512-c3mAZEuK0lvBp8tmuL74XRKn1+y2dcwOUpH7x4WrF6gk1GIgiluDRgMYQtw2OFcBvAJWlt6ASU3tSqxp0Uu0Aw==", + "dev": true, + "requires": { + "@types/istanbul-lib-report": "*" + } + }, + "@types/node": { + "version": "18.14.6", + "resolved": "https://registry.npmjs.org/@types/node/-/node-18.14.6.tgz", + "integrity": "sha512-93+VvleD3mXwlLI/xASjw0FzKcwzl3OdTCzm1LaRfqgS21gfFtK3zDXM5Op9TeeMsJVOaJ2VRDpT9q4Y3d0AvA==", + "dev": true + }, + "@types/prettier": { + "version": "2.7.2", + "resolved": "https://registry.npmjs.org/@types/prettier/-/prettier-2.7.2.tgz", + "integrity": "sha512-KufADq8uQqo1pYKVIYzfKbJfBAc0sOeXqGbFaSpv8MRmC/zXgowNZmFcbngndGk922QDmOASEXUZCaY48gs4cg==", + "dev": true + }, + "@types/stack-utils": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/@types/stack-utils/-/stack-utils-2.0.1.tgz", + "integrity": "sha512-Hl219/BT5fLAaz6NDkSuhzasy49dwQS/DSdu4MdggFB8zcXv7vflBI3xp7FEmkmdDkBUI2bPUNeMttp2knYdxw==", + "dev": true + }, + "@types/yargs": { + "version": "17.0.22", + "resolved": "https://registry.npmjs.org/@types/yargs/-/yargs-17.0.22.tgz", + "integrity": "sha512-pet5WJ9U8yPVRhkwuEIp5ktAeAqRZOq4UdAyWLWzxbtpyXnzbtLdKiXAjJzi/KLmPGS9wk86lUFWZFN6sISo4g==", + "dev": true, + "requires": { + "@types/yargs-parser": "*" + } + }, + "@types/yargs-parser": { + "version": "21.0.0", + "resolved": "https://registry.npmjs.org/@types/yargs-parser/-/yargs-parser-21.0.0.tgz", + "integrity": "sha512-iO9ZQHkZxHn4mSakYV0vFHAVDyEOIJQrV2uZ06HxEPcx+mt8swXoZHIbaaJ2crJYFfErySgktuTZ3BeLz+XmFA==", + "dev": true + }, + "@vercel/ncc": { + "version": "0.36.1", + "resolved": "https://registry.npmjs.org/@vercel/ncc/-/ncc-0.36.1.tgz", + "integrity": "sha512-S4cL7Taa9yb5qbv+6wLgiKVZ03Qfkc4jGRuiUQMQ8HGBD5pcNRnHeYM33zBvJE4/zJGjJJ8GScB+WmTsn9mORw==", + "dev": true + }, + "abbrev": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/abbrev/-/abbrev-1.1.1.tgz", + "integrity": "sha512-nne9/IiQ/hzIhY6pdDnbBtz7DjPTKrY00P/zvPSm5pOFkl6xuGrGnXn/VtTNNfNtAfZ9/1RtehkszU9qcTii0Q==" + }, + "acorn": { + "version": "8.8.2", + "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.8.2.tgz", + "integrity": "sha512-xjIYgE8HBrkpd/sJqOGNspf8uHG+NOHGOw6a/Urj8taM2EXfdNAH2oFcPeIFfsv3+kz/mJrS5VuMqbNLjCa2vw==", + "dev": true + }, + "acorn-jsx": { + "version": "5.3.2", + "resolved": "https://registry.npmjs.org/acorn-jsx/-/acorn-jsx-5.3.2.tgz", + "integrity": "sha512-rq9s+JNhf0IChjtDXxllJ7g41oZk5SlXtp0LHwyA5cejwn7vKmKp4pPri6YEePv2PU65sAsegbXtIinmDFDXgQ==", + "dev": true, + "requires": {} + }, + "agent-base": { + "version": "6.0.2", + "resolved": "https://registry.npmjs.org/agent-base/-/agent-base-6.0.2.tgz", + "integrity": "sha512-RZNwNclF7+MS/8bDg70amg32dyeZGZxiDuQmZxKLAlQjr3jGyLx+4Kkk58UO7D2QdgFIQCovuSuZESne6RG6XQ==", + "requires": { + "debug": "4" + } + }, + "ajv": { + "version": "6.12.6", + "resolved": "https://registry.npmjs.org/ajv/-/ajv-6.12.6.tgz", + "integrity": "sha512-j3fVLgvTo527anyYyJOGTYJbG+vnnQYvE0m5mmkc1TK+nxAppkCLMIL0aZ4dblVCNoGShhm+kzE4ZUykBoMg4g==", + "dev": true, + "requires": { + "fast-deep-equal": "^3.1.1", + "fast-json-stable-stringify": "^2.0.0", + "json-schema-traverse": "^0.4.1", + "uri-js": "^4.2.2" + } + }, + "ansi-escapes": { + "version": "4.3.2", + "resolved": "https://registry.npmjs.org/ansi-escapes/-/ansi-escapes-4.3.2.tgz", + "integrity": "sha512-gKXj5ALrKWQLsYG9jlTRmR/xKluxHV+Z9QEwNIgCfM1/uwPMCuzVVnh5mwTd+OuBZcwSIMbqssNWRm1lE51QaQ==", + "dev": true, + "requires": { + "type-fest": "^0.21.3" + }, + "dependencies": { + "type-fest": { + "version": "0.21.3", + "resolved": "https://registry.npmjs.org/type-fest/-/type-fest-0.21.3.tgz", + "integrity": "sha512-t0rzBq87m3fVcduHDUFhKmyyX+9eo6WQjZvf51Ea/M0Q7+T374Jp1aUiyUl0GKxp8M/OETVHSDvmkyPgvX+X2w==", + "dev": true + } + } + }, + "ansi-regex": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.1.tgz", + "integrity": "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==" + }, + "ansi-styles": { + "version": "4.3.0", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz", + "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==", + "dev": true, + "requires": { + "color-convert": "^2.0.1" + } + }, + "anymatch": { + "version": "3.1.3", + "resolved": "https://registry.npmjs.org/anymatch/-/anymatch-3.1.3.tgz", + "integrity": "sha512-KMReFUr0B4t+D+OBkjR3KYqvocp2XaSzO55UcB6mgQMd3KbcE+mWTyvVV7D/zsdEbNnV6acZUutkiHQXvTr1Rw==", + "dev": true, + "requires": { + "normalize-path": "^3.0.0", + "picomatch": "^2.0.4" + } + }, + "aproba": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/aproba/-/aproba-2.0.0.tgz", + "integrity": "sha512-lYe4Gx7QT+MKGbDsA+Z+he/Wtef0BiwDOlK/XkBrdfsh9J/jPPXbX0tE9x9cl27Tmu5gg3QUbUrQYa/y+KOHPQ==" + }, + "are-we-there-yet": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/are-we-there-yet/-/are-we-there-yet-2.0.0.tgz", + "integrity": "sha512-Ci/qENmwHnsYo9xKIcUJN5LeDKdJ6R1Z1j9V/J5wyq8nh/mYPEpIKJbBZXtZjG04HiK7zV/p6Vs9952MrMeUIw==", + "requires": { + "delegates": "^1.0.0", + "readable-stream": "^3.6.0" + } + }, + "argparse": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/argparse/-/argparse-2.0.1.tgz", + "integrity": "sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q==", + "dev": true + }, + "array.prototype.filter": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/array.prototype.filter/-/array.prototype.filter-1.0.2.tgz", + "integrity": "sha512-us+UrmGOilqttSOgoWZTpOvHu68vZT2YCjc/H4vhu56vzZpaDFBhB+Se2UwqWzMKbDv7Myq5M5pcZLAtUvTQdQ==", + "dev": true, + "requires": { + "call-bind": "^1.0.2", + "define-properties": "^1.1.4", + "es-abstract": "^1.20.4", + "es-array-method-boxes-properly": "^1.0.0", + "is-string": "^1.0.7" + } + }, + "array.prototype.flat": { + "version": "1.3.1", + "resolved": "https://registry.npmjs.org/array.prototype.flat/-/array.prototype.flat-1.3.1.tgz", + "integrity": "sha512-roTU0KWIOmJ4DRLmwKd19Otg0/mT3qPNt0Qb3GWW8iObuZXxrjB/pzn0R3hqpRSWg4HCwqx+0vwOnWnvlOyeIA==", + "dev": true, + "requires": { + "call-bind": "^1.0.2", + "define-properties": "^1.1.4", + "es-abstract": "^1.20.4", + "es-shim-unscopables": "^1.0.0" + } + }, + "available-typed-arrays": { + "version": "1.0.5", + "resolved": "https://registry.npmjs.org/available-typed-arrays/-/available-typed-arrays-1.0.5.tgz", + "integrity": "sha512-DMD0KiN46eipeziST1LPP/STfDU0sufISXmjSgvVsoU2tqxctQeASejWcfNtxYKqETM1UxQ8sp2OrSBWpHY6sw==", + "dev": true + }, + "babel-jest": { + "version": "29.5.0", + "resolved": "https://registry.npmjs.org/babel-jest/-/babel-jest-29.5.0.tgz", + "integrity": "sha512-mA4eCDh5mSo2EcA9xQjVTpmbbNk32Zb3Q3QFQsNhaK56Q+yoXowzFodLux30HRgyOho5rsQ6B0P9QpMkvvnJ0Q==", + "dev": true, + "requires": { + "@jest/transform": "^29.5.0", + "@types/babel__core": "^7.1.14", + "babel-plugin-istanbul": "^6.1.1", + "babel-preset-jest": "^29.5.0", + "chalk": "^4.0.0", + "graceful-fs": "^4.2.9", + "slash": "^3.0.0" + } + }, + "babel-plugin-istanbul": { + "version": "6.1.1", + "resolved": "https://registry.npmjs.org/babel-plugin-istanbul/-/babel-plugin-istanbul-6.1.1.tgz", + "integrity": "sha512-Y1IQok9821cC9onCx5otgFfRm7Lm+I+wwxOx738M/WLPZ9Q42m4IG5W0FNX8WLL2gYMZo3JkuXIH2DOpWM+qwA==", + "dev": true, + "requires": { + "@babel/helper-plugin-utils": "^7.0.0", + "@istanbuljs/load-nyc-config": "^1.0.0", + "@istanbuljs/schema": "^0.1.2", + "istanbul-lib-instrument": "^5.0.4", + "test-exclude": "^6.0.0" + } + }, + "babel-plugin-jest-hoist": { + "version": "29.5.0", + "resolved": "https://registry.npmjs.org/babel-plugin-jest-hoist/-/babel-plugin-jest-hoist-29.5.0.tgz", + "integrity": "sha512-zSuuuAlTMT4mzLj2nPnUm6fsE6270vdOfnpbJ+RmruU75UhLFvL0N2NgI7xpeS7NaB6hGqmd5pVpGTDYvi4Q3w==", + "dev": true, + "requires": { + "@babel/template": "^7.3.3", + "@babel/types": "^7.3.3", + "@types/babel__core": "^7.1.14", + "@types/babel__traverse": "^7.0.6" + } + }, + "babel-preset-current-node-syntax": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/babel-preset-current-node-syntax/-/babel-preset-current-node-syntax-1.0.1.tgz", + "integrity": "sha512-M7LQ0bxarkxQoN+vz5aJPsLBn77n8QgTFmo8WK0/44auK2xlCXrYcUxHFxgU7qW5Yzw/CjmLRK2uJzaCd7LvqQ==", + "dev": true, + "requires": { + "@babel/plugin-syntax-async-generators": "^7.8.4", + "@babel/plugin-syntax-bigint": "^7.8.3", + "@babel/plugin-syntax-class-properties": "^7.8.3", + "@babel/plugin-syntax-import-meta": "^7.8.3", + "@babel/plugin-syntax-json-strings": "^7.8.3", + "@babel/plugin-syntax-logical-assignment-operators": "^7.8.3", + "@babel/plugin-syntax-nullish-coalescing-operator": "^7.8.3", + "@babel/plugin-syntax-numeric-separator": "^7.8.3", + "@babel/plugin-syntax-object-rest-spread": "^7.8.3", + "@babel/plugin-syntax-optional-catch-binding": "^7.8.3", + "@babel/plugin-syntax-optional-chaining": "^7.8.3", + "@babel/plugin-syntax-top-level-await": "^7.8.3" + } + }, + "babel-preset-jest": { + "version": "29.5.0", + "resolved": "https://registry.npmjs.org/babel-preset-jest/-/babel-preset-jest-29.5.0.tgz", + "integrity": "sha512-JOMloxOqdiBSxMAzjRaH023/vvcaSaec49zvg+2LmNsktC7ei39LTJGw02J+9uUtTZUq6xbLyJ4dxe9sSmIuAg==", + "dev": true, + "requires": { + "babel-plugin-jest-hoist": "^29.5.0", + "babel-preset-current-node-syntax": "^1.0.0" + } + }, + "balanced-match": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.2.tgz", + "integrity": "sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==" + }, + "before-after-hook": { + "version": "2.2.3", + "resolved": "https://registry.npmjs.org/before-after-hook/-/before-after-hook-2.2.3.tgz", + "integrity": "sha512-NzUnlZexiaH/46WDhANlyR2bXRopNg4F/zuSA3OpZnllCUgRaOF2znDioDWrmbNVsuZk6l9pMquQB38cfBZwkQ==" + }, + "bindings": { + "version": "1.3.1", + "resolved": "https://registry.npmjs.org/bindings/-/bindings-1.3.1.tgz", + "integrity": "sha512-i47mqjF9UbjxJhxGf+pZ6kSxrnI3wBLlnGI2ArWJ4r0VrvDS7ZYXkprq/pLaBWYq4GM0r4zdHY+NNRqEMU7uew==" + }, + "boolbase": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/boolbase/-/boolbase-1.0.0.tgz", + "integrity": "sha512-JZOSA7Mo9sNGB8+UjSgzdLtokWAky1zbztM3WRLCbZ70/3cTANmQmOdR7y2g+J0e2WXywy1yS468tY+IruqEww==", + "dev": true + }, + "bottleneck": { + "version": "2.19.5", + "resolved": "https://registry.npmjs.org/bottleneck/-/bottleneck-2.19.5.tgz", + "integrity": "sha512-VHiNCbI1lKdl44tGrhNfU3lup0Tj/ZBMJB5/2ZbNXRCPuRCO7ed2mgcK4r17y+KB2EfuYuRaVlwNbAeaWGSpbw==" + }, + "brace-expansion": { + "version": "1.1.11", + "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.11.tgz", + "integrity": "sha512-iCuPHDFgrHX7H2vEI/5xpz07zSHB00TpugqhmYtVmMO6518mCuRMoOYFldEBl0g187ufozdaHgWKcYFb61qGiA==", + "requires": { + "balanced-match": "^1.0.0", + "concat-map": "0.0.1" + } + }, + "braces": { + "version": "3.0.2", + "resolved": "https://registry.npmjs.org/braces/-/braces-3.0.2.tgz", + "integrity": "sha512-b8um+L1RzM3WDSzvhm6gIz1yfTbBt6YTlcEKAvsmqCZZFw46z626lVj9j1yEPW33H5H+lBQpZMP1k8l+78Ha0A==", + "dev": true, + "requires": { + "fill-range": "^7.0.1" + } + }, + "browserslist": { + "version": "4.21.5", + "resolved": "https://registry.npmjs.org/browserslist/-/browserslist-4.21.5.tgz", + "integrity": "sha512-tUkiguQGW7S3IhB7N+c2MV/HZPSCPAAiYBZXLsBhFB/PCy6ZKKsZrmBayHV9fdGV/ARIfJ14NkxKzRDjvp7L6w==", + "dev": true, + "requires": { + "caniuse-lite": "^1.0.30001449", + "electron-to-chromium": "^1.4.284", + "node-releases": "^2.0.8", + "update-browserslist-db": "^1.0.10" + } + }, + "bser": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/bser/-/bser-2.1.1.tgz", + "integrity": "sha512-gQxTNE/GAfIIrmHLUE3oJyp5FO6HRBfhjnw4/wMmA63ZGDJnWBmgY/lyQBpnDUkGmAhbSe39tx2d/iTOAfglwQ==", + "dev": true, + "requires": { + "node-int64": "^0.4.0" + } + }, + "buffer-from": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/buffer-from/-/buffer-from-1.1.2.tgz", + "integrity": "sha512-E+XQCRwSbaaiChtv6k6Dwgc+bx+Bs6vuKJHHl5kox/BaKbhiXzqQOwK4cO22yElGp2OCmjwVhT3HmxgyPGnJfQ==", + "dev": true + }, + "call-bind": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/call-bind/-/call-bind-1.0.2.tgz", + "integrity": "sha512-7O+FbCihrB5WGbFYesctwmTKae6rOiIzmz1icreWJ+0aA7LJfuqhEso2T9ncpcFtzMQtzXf2QGGueWJGTYsqrA==", + "dev": true, + "requires": { + "function-bind": "^1.1.1", + "get-intrinsic": "^1.0.2" + } + }, + "callsites": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/callsites/-/callsites-3.1.0.tgz", + "integrity": "sha512-P8BjAsXvZS+VIDUI11hHCQEv74YT67YUi5JJFNWIqL235sBmjX4+qx9Muvls5ivyNENctx46xQLQ3aTuE7ssaQ==", + "dev": true + }, + "camelcase": { + "version": "5.3.1", + "resolved": "https://registry.npmjs.org/camelcase/-/camelcase-5.3.1.tgz", + "integrity": "sha512-L28STB170nwWS63UjtlEOE3dldQApaJXZkOI1uMFfzf3rRuPegHaHesyee+YxQ+W6SvRDQV6UrdOdRiR153wJg==", + "dev": true + }, + "caniuse-lite": { + "version": "1.0.30001462", + "resolved": "https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30001462.tgz", + "integrity": "sha512-PDd20WuOBPiasZ7KbFnmQRyuLE7cFXW2PVd7dmALzbkUXEP46upAuCDm9eY9vho8fgNMGmbAX92QBZHzcnWIqw==", + "dev": true + }, + "chalk": { + "version": "4.1.2", + "resolved": "https://registry.npmjs.org/chalk/-/chalk-4.1.2.tgz", + "integrity": "sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==", + "dev": true, + "requires": { + "ansi-styles": "^4.1.0", + "supports-color": "^7.1.0" + } + }, + "char-regex": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/char-regex/-/char-regex-1.0.2.tgz", + "integrity": "sha512-kWWXztvZ5SBQV+eRgKFeh8q5sLuZY2+8WUIzlxWVTg+oGwY14qylx1KbKzHd8P6ZYkAg0xyIDU9JMHhyJMZ1jw==", + "dev": true + }, + "cheerio": { + "version": "1.0.0-rc.12", + "resolved": "https://registry.npmjs.org/cheerio/-/cheerio-1.0.0-rc.12.tgz", + "integrity": "sha512-VqR8m68vM46BNnuZ5NtnGBKIE/DfN0cRIzg9n40EIq9NOv90ayxLBXA8fXC5gquFRGJSTRqBq25Jt2ECLR431Q==", + "dev": true, + "requires": { + "cheerio-select": "^2.1.0", + "dom-serializer": "^2.0.0", + "domhandler": "^5.0.3", + "domutils": "^3.0.1", + "htmlparser2": "^8.0.1", + "parse5": "^7.0.0", + "parse5-htmlparser2-tree-adapter": "^7.0.0" + } + }, + "cheerio-select": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/cheerio-select/-/cheerio-select-2.1.0.tgz", + "integrity": "sha512-9v9kG0LvzrlcungtnJtpGNxY+fzECQKhK4EGJX2vByejiMX84MFNQw4UxPJl3bFbTMw+Dfs37XaIkCwTZfLh4g==", + "dev": true, + "requires": { + "boolbase": "^1.0.0", + "css-select": "^5.1.0", + "css-what": "^6.1.0", + "domelementtype": "^2.3.0", + "domhandler": "^5.0.3", + "domutils": "^3.0.1" + } + }, + "chownr": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/chownr/-/chownr-2.0.0.tgz", + "integrity": "sha512-bIomtDF5KGpdogkLd9VspvFzk9KfpyyGlS8YFVZl7TGPBHL5snIOnxeshwVgPteQ9b4Eydl+pVbIyE1DcvCWgQ==" + }, + "ci-info": { + "version": "3.8.0", + "resolved": "https://registry.npmjs.org/ci-info/-/ci-info-3.8.0.tgz", + "integrity": "sha512-eXTggHWSooYhq49F2opQhuHWgzucfF2YgODK4e1566GQs5BIfP30B0oenwBJHfWxAs2fyPB1s7Mg949zLf61Yw==", + "dev": true + }, + "cjs-module-lexer": { + "version": "1.2.2", + "resolved": "https://registry.npmjs.org/cjs-module-lexer/-/cjs-module-lexer-1.2.2.tgz", + "integrity": "sha512-cOU9usZw8/dXIXKtwa8pM0OTJQuJkxMN6w30csNRUerHfeQ5R6U3kkU/FtJeIf3M202OHfY2U8ccInBG7/xogA==", + "dev": true + }, + "cliui": { + "version": "8.0.1", + "resolved": "https://registry.npmjs.org/cliui/-/cliui-8.0.1.tgz", + "integrity": "sha512-BSeNnyus75C4//NQ9gQt1/csTXyo/8Sb+afLAkzAptFuMsod9HFokGNudZpi/oQV73hnVK+sR+5PVRMd+Dr7YQ==", + "dev": true, + "requires": { + "string-width": "^4.2.0", + "strip-ansi": "^6.0.1", + "wrap-ansi": "^7.0.0" + } + }, + "co": { + "version": "4.6.0", + "resolved": "https://registry.npmjs.org/co/-/co-4.6.0.tgz", + "integrity": "sha512-QVb0dM5HvG+uaxitm8wONl7jltx8dqhfU33DcqtOZcLSVIKSDDLDi7+0LbAKiyI8hD9u42m2YxXSkMGWThaecQ==", + "dev": true + }, + "collect-v8-coverage": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/collect-v8-coverage/-/collect-v8-coverage-1.0.1.tgz", + "integrity": "sha512-iBPtljfCNcTKNAto0KEtDfZ3qzjJvqE3aTGZsbhjSBlorqpXJlaWWtPO35D+ZImoC3KWejX64o+yPGxhWSTzfg==", + "dev": true + }, + "color-convert": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz", + "integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==", + "dev": true, + "requires": { + "color-name": "~1.1.4" + } + }, + "color-name": { + "version": "1.1.4", + "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz", + "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==", + "dev": true + }, + "color-support": { + "version": "1.1.3", + "resolved": "https://registry.npmjs.org/color-support/-/color-support-1.1.3.tgz", + "integrity": "sha512-qiBjkpbMLO/HL68y+lh4q0/O1MZFj2RX6X/KmMa3+gJD3z+WwI1ZzDHysvqHGS3mP6mznPckpXmw1nI9cJjyRg==" + }, + "colors": { + "version": "1.4.0", + "resolved": "https://registry.npmjs.org/colors/-/colors-1.4.0.tgz", + "integrity": "sha512-a+UqTh4kgZg/SlGvfbzDHpgRu7AAQOmmqRHJnxhRZICKFUT91brVhNNt58CMWU9PsBbv3PDCZUHbVxuDiH2mtA==", + "dev": true + }, + "commander": { + "version": "2.20.3", + "resolved": "https://registry.npmjs.org/commander/-/commander-2.20.3.tgz", + "integrity": "sha512-GpVkmM8vF2vQUkj2LvZmD35JxeJOLCwJ9cUkugyk2nuhbv3+mJvpLYYt+0+USMxE+oj+ey/lJEnhZw75x/OMcQ==", + "dev": true + }, + "concat-map": { + "version": "0.0.1", + "resolved": "https://registry.npmjs.org/concat-map/-/concat-map-0.0.1.tgz", + "integrity": "sha512-/Srv4dswyQNBfohGpz9o6Yb3Gz3SrUDqBH5rTuhGR7ahtlbYKnVxw2bCFMRljaA7EXHaXZ8wsHdodFvbkhKmqg==" + }, + "console-control-strings": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/console-control-strings/-/console-control-strings-1.1.0.tgz", + "integrity": "sha512-ty/fTekppD2fIwRvnZAVdeOiGd1c7YXEixbgJTNzqcxJWKQnjJ/V1bNEEE6hygpM3WjwHFUVK6HTjWSzV4a8sQ==" + }, + "convert-source-map": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/convert-source-map/-/convert-source-map-2.0.0.tgz", + "integrity": "sha512-Kvp459HrV2FEJ1CAsi1Ku+MY3kasH19TFykTz2xWmMeq6bk2NU3XXvfJ+Q61m0xktWwt+1HSYf3JZsTms3aRJg==", + "dev": true + }, + "cross-spawn": { + "version": "7.0.3", + "resolved": "https://registry.npmjs.org/cross-spawn/-/cross-spawn-7.0.3.tgz", + "integrity": "sha512-iRDPJKUPVEND7dHPO8rkbOnPpyDygcDFtWjpeWNCgy8WP2rXcxXL8TskReQl6OrB2G7+UJrags1q15Fudc7G6w==", + "dev": true, + "requires": { + "path-key": "^3.1.0", + "shebang-command": "^2.0.0", + "which": "^2.0.1" + } + }, + "css-select": { + "version": "5.1.0", + "resolved": "https://registry.npmjs.org/css-select/-/css-select-5.1.0.tgz", + "integrity": "sha512-nwoRF1rvRRnnCqqY7updORDsuqKzqYJ28+oSMaJMMgOauh3fvwHqMS7EZpIPqK8GL+g9mKxF1vP/ZjSeNjEVHg==", + "dev": true, + "requires": { + "boolbase": "^1.0.0", + "css-what": "^6.1.0", + "domhandler": "^5.0.2", + "domutils": "^3.0.1", + "nth-check": "^2.0.1" + } + }, + "css-what": { + "version": "6.1.0", + "resolved": "https://registry.npmjs.org/css-what/-/css-what-6.1.0.tgz", + "integrity": "sha512-HTUrgRJ7r4dsZKU6GjmpfRK1O76h97Z8MfS1G0FozR+oF2kG6Vfe8JE6zwrkbxigziPHinCJ+gCPjA9EaBDtRw==", + "dev": true + }, + "debug": { + "version": "4.3.4", + "resolved": "https://registry.npmjs.org/debug/-/debug-4.3.4.tgz", + "integrity": "sha512-PRWFHuSU3eDtQJPvnNY7Jcket1j0t5OuOsFzPPzsekD52Zl8qUfFIPEiswXqIvHWGVHOgX+7G/vCNNhehwxfkQ==", + "requires": { + "ms": "2.1.2" + } + }, + "dedent": { + "version": "0.7.0", + "resolved": "https://registry.npmjs.org/dedent/-/dedent-0.7.0.tgz", + "integrity": "sha512-Q6fKUPqnAHAyhiUgFU7BUzLiv0kd8saH9al7tnu5Q/okj6dnupxyTgFIBjVzJATdfIAm9NAsvXNzjaKa+bxVyA==", + "dev": true + }, + "deep-is": { + "version": "0.1.4", + "resolved": "https://registry.npmjs.org/deep-is/-/deep-is-0.1.4.tgz", + "integrity": "sha512-oIPzksmTg4/MriiaYGO+okXDT7ztn/w3Eptv/+gSIdMdKsJo0u4CfYNFJPy+4SKMuCqGw2wxnA+URMg3t8a/bQ==", + "dev": true + }, + "deepmerge": { + "version": "4.3.0", + "resolved": "https://registry.npmjs.org/deepmerge/-/deepmerge-4.3.0.tgz", + "integrity": "sha512-z2wJZXrmeHdvYJp/Ux55wIjqo81G5Bp4c+oELTW+7ar6SogWHajt5a9gO3s3IDaGSAXjDk0vlQKN3rms8ab3og==", + "dev": true + }, + "define-properties": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/define-properties/-/define-properties-1.2.0.tgz", + "integrity": "sha512-xvqAVKGfT1+UAvPwKTVw/njhdQ8ZhXK4lI0bCIuCMrp2up9nPnaDftrLtmpTazqd1o+UY4zgzU+avtMbDP+ldA==", + "dev": true, + "requires": { + "has-property-descriptors": "^1.0.0", + "object-keys": "^1.1.1" + } + }, + "delegates": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/delegates/-/delegates-1.0.0.tgz", + "integrity": "sha512-bd2L678uiWATM6m5Z1VzNCErI3jiGzt6HGY8OVICs40JQq/HALfbyNJmp0UDakEY4pMMaN0Ly5om/B1VI/+xfQ==" + }, + "deprecation": { + "version": "2.3.1", + "resolved": "https://registry.npmjs.org/deprecation/-/deprecation-2.3.1.tgz", + "integrity": "sha512-xmHIy4F3scKVwMsQ4WnVaS8bHOx0DmVwRywosKhaILI0ywMDWPtBSku2HNxRvF7jtwDRsoEwYQSfbxj8b7RlJQ==" + }, + "detect-libc": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/detect-libc/-/detect-libc-2.0.1.tgz", + "integrity": "sha512-463v3ZeIrcWtdgIg6vI6XUncguvr2TnGl4SzDXinkt9mSLpBJKXT3mW6xT3VQdDN11+WVs29pgvivTc4Lp8v+w==" + }, + "detect-newline": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/detect-newline/-/detect-newline-3.1.0.tgz", + "integrity": "sha512-TLz+x/vEXm/Y7P7wn1EJFNLxYpUD4TgMosxY6fAVJUnJMbupHBOncxyWUG9OpTaH9EBD7uFI5LfEgmMOc54DsA==", + "dev": true + }, + "diff-sequences": { + "version": "29.4.3", + "resolved": "https://registry.npmjs.org/diff-sequences/-/diff-sequences-29.4.3.tgz", + "integrity": "sha512-ofrBgwpPhCD85kMKtE9RYFFq6OC1A89oW2vvgWZNCwxrUpRUILopY7lsYyMDSjc8g6U6aiO0Qubg6r4Wgt5ZnA==", + "dev": true + }, + "discontinuous-range": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/discontinuous-range/-/discontinuous-range-1.0.0.tgz", + "integrity": "sha512-c68LpLbO+7kP/b1Hr1qs8/BJ09F5khZGTxqxZuhzxpmwJKOgRFHJWIb9/KmqnqHhLdO55aOxFH/EGBvUQbL/RQ==", + "dev": true + }, + "doctrine": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/doctrine/-/doctrine-3.0.0.tgz", + "integrity": "sha512-yS+Q5i3hBf7GBkd4KG8a7eBNNWNGLTaEwwYWUijIYM7zrlYDM0BFXHjjPWlWZ1Rg7UaddZeIDmi9jF3HmqiQ2w==", + "dev": true, + "requires": { + "esutils": "^2.0.2" + } + }, + "dom-serializer": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/dom-serializer/-/dom-serializer-2.0.0.tgz", + "integrity": "sha512-wIkAryiqt/nV5EQKqQpo3SToSOV9J0DnbJqwK7Wv/Trc92zIAYZ4FlMu+JPFW1DfGFt81ZTCGgDEabffXeLyJg==", + "dev": true, + "requires": { + "domelementtype": "^2.3.0", + "domhandler": "^5.0.2", + "entities": "^4.2.0" + } + }, + "domelementtype": { + "version": "2.3.0", + "resolved": "https://registry.npmjs.org/domelementtype/-/domelementtype-2.3.0.tgz", + "integrity": "sha512-OLETBj6w0OsagBwdXnPdN0cnMfF9opN69co+7ZrbfPGrdpPVNBUj02spi6B1N7wChLQiPn4CSH/zJvXw56gmHw==", + "dev": true + }, + "domhandler": { + "version": "5.0.3", + "resolved": "https://registry.npmjs.org/domhandler/-/domhandler-5.0.3.tgz", + "integrity": "sha512-cgwlv/1iFQiFnU96XXgROh8xTeetsnJiDsTc7TYCLFd9+/WNkIqPTxiM/8pSd8VIrhXGTf1Ny1q1hquVqDJB5w==", + "dev": true, + "requires": { + "domelementtype": "^2.3.0" + } + }, + "domutils": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/domutils/-/domutils-3.0.1.tgz", + "integrity": "sha512-z08c1l761iKhDFtfXO04C7kTdPBLi41zwOZl00WS8b5eiaebNpY00HKbztwBq+e3vyqWNwWF3mP9YLUeqIrF+Q==", + "dev": true, + "requires": { + "dom-serializer": "^2.0.0", + "domelementtype": "^2.3.0", + "domhandler": "^5.0.1" + } + }, + "dreamopt": { + "version": "0.8.0", + "resolved": "https://registry.npmjs.org/dreamopt/-/dreamopt-0.8.0.tgz", + "integrity": "sha512-vyJTp8+mC+G+5dfgsY+r3ckxlz+QMX40VjPQsZc5gxVAxLmi64TBoVkP54A/pRAXMXsbu2GMMBrZPxNv23waMg==", + "dev": true, + "requires": { + "wordwrap": ">=0.0.2" + } + }, + "electron-to-chromium": { + "version": "1.4.322", + "resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.4.322.tgz", + "integrity": "sha512-KovjizNC9XB7dno/2GjxX8VS0SlfPpCjtyoKft+bCO+UfD8bFy16hY4Sh9s0h9BDxbRH2U0zX5VBjpM1LTcNlg==", + "dev": true + }, + "emittery": { + "version": "0.13.1", + "resolved": "https://registry.npmjs.org/emittery/-/emittery-0.13.1.tgz", + "integrity": "sha512-DeWwawk6r5yR9jFgnDKYt4sLS0LmHJJi3ZOnb5/JdbYwj3nW+FxQnHIjhBKz8YLC7oRNPVM9NQ47I3CVx34eqQ==", + "dev": true + }, + "emoji-regex": { + "version": "8.0.0", + "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz", + "integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==" + }, + "entities": { + "version": "4.4.0", + "resolved": "https://registry.npmjs.org/entities/-/entities-4.4.0.tgz", + "integrity": "sha512-oYp7156SP8LkeGD0GF85ad1X9Ai79WtRsZ2gxJqtBuzH+98YUV6jkHEKlZkMbcrjJjIVJNIDP/3WL9wQkoPbWA==", + "dev": true + }, + "enzyme": { + "version": "3.11.0", + "resolved": "https://registry.npmjs.org/enzyme/-/enzyme-3.11.0.tgz", + "integrity": "sha512-Dw8/Gs4vRjxY6/6i9wU0V+utmQO9kvh9XLnz3LIudviOnVYDEe2ec+0k+NQoMamn1VrjKgCUOWj5jG/5M5M0Qw==", + "dev": true, + "requires": { + "array.prototype.flat": "^1.2.3", + "cheerio": "^1.0.0-rc.3", + "enzyme-shallow-equal": "^1.0.1", + "function.prototype.name": "^1.1.2", + "has": "^1.0.3", + "html-element-map": "^1.2.0", + "is-boolean-object": "^1.0.1", + "is-callable": "^1.1.5", + "is-number-object": "^1.0.4", + "is-regex": "^1.0.5", + "is-string": "^1.0.5", + "is-subset": "^0.1.1", + "lodash.escape": "^4.0.1", + "lodash.isequal": "^4.5.0", + "object-inspect": "^1.7.0", + "object-is": "^1.0.2", + "object.assign": "^4.1.0", + "object.entries": "^1.1.1", + "object.values": "^1.1.1", + "raf": "^3.4.1", + "rst-selector-parser": "^2.2.3", + "string.prototype.trim": "^1.2.1" + } + }, + "enzyme-shallow-equal": { + "version": "1.0.5", + "resolved": "https://registry.npmjs.org/enzyme-shallow-equal/-/enzyme-shallow-equal-1.0.5.tgz", + "integrity": "sha512-i6cwm7hN630JXenxxJFBKzgLC3hMTafFQXflvzHgPmDhOBhxUWDe8AeRv1qp2/uWJ2Y8z5yLWMzmAfkTOiOCZg==", + "dev": true, + "requires": { + "has": "^1.0.3", + "object-is": "^1.1.5" + } + }, + "error-ex": { + "version": "1.3.2", + "resolved": "https://registry.npmjs.org/error-ex/-/error-ex-1.3.2.tgz", + "integrity": "sha512-7dFHNmqeFSEt2ZBsCriorKnn3Z2pj+fd9kmI6QoWw4//DL+icEBfc0U7qJCisqrTsKTjw4fNFy2pW9OqStD84g==", + "dev": true, + "requires": { + "is-arrayish": "^0.2.1" + } + }, + "es-abstract": { + "version": "1.21.1", + "resolved": "https://registry.npmjs.org/es-abstract/-/es-abstract-1.21.1.tgz", + "integrity": "sha512-QudMsPOz86xYz/1dG1OuGBKOELjCh99IIWHLzy5znUB6j8xG2yMA7bfTV86VSqKF+Y/H08vQPR+9jyXpuC6hfg==", + "dev": true, + "requires": { + "available-typed-arrays": "^1.0.5", + "call-bind": "^1.0.2", + "es-set-tostringtag": "^2.0.1", + "es-to-primitive": "^1.2.1", + "function-bind": "^1.1.1", + "function.prototype.name": "^1.1.5", + "get-intrinsic": "^1.1.3", + "get-symbol-description": "^1.0.0", + "globalthis": "^1.0.3", + "gopd": "^1.0.1", + "has": "^1.0.3", + "has-property-descriptors": "^1.0.0", + "has-proto": "^1.0.1", + "has-symbols": "^1.0.3", + "internal-slot": "^1.0.4", + "is-array-buffer": "^3.0.1", + "is-callable": "^1.2.7", + "is-negative-zero": "^2.0.2", + "is-regex": "^1.1.4", + "is-shared-array-buffer": "^1.0.2", + "is-string": "^1.0.7", + "is-typed-array": "^1.1.10", + "is-weakref": "^1.0.2", + "object-inspect": "^1.12.2", + "object-keys": "^1.1.1", + "object.assign": "^4.1.4", + "regexp.prototype.flags": "^1.4.3", + "safe-regex-test": "^1.0.0", + "string.prototype.trimend": "^1.0.6", + "string.prototype.trimstart": "^1.0.6", + "typed-array-length": "^1.0.4", + "unbox-primitive": "^1.0.2", + "which-typed-array": "^1.1.9" + } + }, + "es-array-method-boxes-properly": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/es-array-method-boxes-properly/-/es-array-method-boxes-properly-1.0.0.tgz", + "integrity": "sha512-wd6JXUmyHmt8T5a2xreUwKcGPq6f1f+WwIJkijUqiGcJz1qqnZgP6XIK+QyIWU5lT7imeNxUll48bziG+TSYcA==", + "dev": true + }, + "es-set-tostringtag": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/es-set-tostringtag/-/es-set-tostringtag-2.0.1.tgz", + "integrity": "sha512-g3OMbtlwY3QewlqAiMLI47KywjWZoEytKr8pf6iTC8uJq5bIAH52Z9pnQ8pVL6whrCto53JZDuUIsifGeLorTg==", + "dev": true, + "requires": { + "get-intrinsic": "^1.1.3", + "has": "^1.0.3", + "has-tostringtag": "^1.0.0" + } + }, + "es-shim-unscopables": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/es-shim-unscopables/-/es-shim-unscopables-1.0.0.tgz", + "integrity": "sha512-Jm6GPcCdC30eMLbZ2x8z2WuRwAws3zTBBKuusffYVUrNj/GVSUAZ+xKMaUpfNDR5IbyNA5LJbaecoUVbmUcB1w==", + "dev": true, + "requires": { + "has": "^1.0.3" + } + }, + "es-to-primitive": { + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/es-to-primitive/-/es-to-primitive-1.2.1.tgz", + "integrity": "sha512-QCOllgZJtaUo9miYBcLChTUaHNjJF3PYs1VidD7AwiEj1kYxKeQTctLAezAOH5ZKRH0g2IgPn6KwB4IT8iRpvA==", + "dev": true, + "requires": { + "is-callable": "^1.1.4", + "is-date-object": "^1.0.1", + "is-symbol": "^1.0.2" + } + }, + "escalade": { + "version": "3.1.1", + "resolved": "https://registry.npmjs.org/escalade/-/escalade-3.1.1.tgz", + "integrity": "sha512-k0er2gUkLf8O0zKJiAhmkTnJlTvINGv7ygDNPbeIsX/TJjGJZHuh9B2UxbsaEkmlEo9MfhrSzmhIlhRlI2GXnw==", + "dev": true + }, + "escape-string-regexp": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-4.0.0.tgz", + "integrity": "sha512-TtpcNJ3XAzx3Gq8sWRzJaVajRs0uVxA2YAkdb1jm2YkPz4G6egUFAyA3n5vtEIZefPk5Wa4UXbKuS5fKkJWdgA==", + "dev": true + }, + "eslint": { + "version": "8.33.0", + "resolved": "https://registry.npmjs.org/eslint/-/eslint-8.33.0.tgz", + "integrity": "sha512-WjOpFQgKK8VrCnAtl8We0SUOy/oVZ5NHykyMiagV1M9r8IFpIJX7DduK6n1mpfhlG7T1NLWm2SuD8QB7KFySaA==", + "dev": true, + "requires": { + "@eslint/eslintrc": "^1.4.1", + "@humanwhocodes/config-array": "^0.11.8", + "@humanwhocodes/module-importer": "^1.0.1", + "@nodelib/fs.walk": "^1.2.8", + "ajv": "^6.10.0", + "chalk": "^4.0.0", + "cross-spawn": "^7.0.2", + "debug": "^4.3.2", + "doctrine": "^3.0.0", + "escape-string-regexp": "^4.0.0", + "eslint-scope": "^7.1.1", + "eslint-utils": "^3.0.0", + "eslint-visitor-keys": "^3.3.0", + "espree": "^9.4.0", + "esquery": "^1.4.0", + "esutils": "^2.0.2", + "fast-deep-equal": "^3.1.3", + "file-entry-cache": "^6.0.1", + "find-up": "^5.0.0", + "glob-parent": "^6.0.2", + "globals": "^13.19.0", + "grapheme-splitter": "^1.0.4", + "ignore": "^5.2.0", + "import-fresh": "^3.0.0", + "imurmurhash": "^0.1.4", + "is-glob": "^4.0.0", + "is-path-inside": "^3.0.3", + "js-sdsl": "^4.1.4", + "js-yaml": "^4.1.0", + "json-stable-stringify-without-jsonify": "^1.0.1", + "levn": "^0.4.1", + "lodash.merge": "^4.6.2", + "minimatch": "^3.1.2", + "natural-compare": "^1.4.0", + "optionator": "^0.9.1", + "regexpp": "^3.2.0", + "strip-ansi": "^6.0.1", + "strip-json-comments": "^3.1.0", + "text-table": "^0.2.0" + } + }, + "eslint-scope": { + "version": "7.1.1", + "resolved": "https://registry.npmjs.org/eslint-scope/-/eslint-scope-7.1.1.tgz", + "integrity": "sha512-QKQM/UXpIiHcLqJ5AOyIW7XZmzjkzQXYE54n1++wb0u9V/abW3l9uQnxX8Z5Xd18xyKIMTUAyQ0k1e8pz6LUrw==", + "dev": true, + "requires": { + "esrecurse": "^4.3.0", + "estraverse": "^5.2.0" + } + }, + "eslint-utils": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/eslint-utils/-/eslint-utils-3.0.0.tgz", + "integrity": "sha512-uuQC43IGctw68pJA1RgbQS8/NP7rch6Cwd4j3ZBtgo4/8Flj4eGE7ZYSZRN3iq5pVUv6GPdW5Z1RFleo84uLDA==", + "dev": true, + "requires": { + "eslint-visitor-keys": "^2.0.0" + }, + "dependencies": { + "eslint-visitor-keys": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/eslint-visitor-keys/-/eslint-visitor-keys-2.1.0.tgz", + "integrity": "sha512-0rSmRBzXgDzIsD6mGdJgevzgezI534Cer5L/vyMX0kHzT/jiB43jRhd9YUlMGYLQy2zprNmoT8qasCGtY+QaKw==", + "dev": true + } + } + }, + "eslint-visitor-keys": { + "version": "3.3.0", + "resolved": "https://registry.npmjs.org/eslint-visitor-keys/-/eslint-visitor-keys-3.3.0.tgz", + "integrity": "sha512-mQ+suqKJVyeuwGYHAdjMFqjCyfl8+Ldnxuyp3ldiMBFKkvytrXUZWaiPCEav8qDHKty44bD+qV1IP4T+w+xXRA==", + "dev": true + }, + "espree": { + "version": "9.4.1", + "resolved": "https://registry.npmjs.org/espree/-/espree-9.4.1.tgz", + "integrity": "sha512-XwctdmTO6SIvCzd9810yyNzIrOrqNYV9Koizx4C/mRhf9uq0o4yHoCEU/670pOxOL/MSraektvSAji79kX90Vg==", + "dev": true, + "requires": { + "acorn": "^8.8.0", + "acorn-jsx": "^5.3.2", + "eslint-visitor-keys": "^3.3.0" + } + }, + "esprima": { + "version": "4.0.1", + "resolved": "https://registry.npmjs.org/esprima/-/esprima-4.0.1.tgz", + "integrity": "sha512-eGuFFw7Upda+g4p+QHvnW0RyTX/SVeJBDM/gCtMARO0cLuT2HcEKnTPvhjV6aGeqrCB/sbNop0Kszm0jsaWU4A==", + "dev": true + }, + "esquery": { + "version": "1.5.0", + "resolved": "https://registry.npmjs.org/esquery/-/esquery-1.5.0.tgz", + "integrity": "sha512-YQLXUplAwJgCydQ78IMJywZCceoqk1oH01OERdSAJc/7U2AylwjhSCLDEtqwg811idIS/9fIU5GjG73IgjKMVg==", + "dev": true, + "requires": { + "estraverse": "^5.1.0" + } + }, + "esrecurse": { + "version": "4.3.0", + "resolved": "https://registry.npmjs.org/esrecurse/-/esrecurse-4.3.0.tgz", + "integrity": "sha512-KmfKL3b6G+RXvP8N1vr3Tq1kL/oCFgn2NYXEtqP8/L3pKapUA4G8cFVaoF3SU323CD4XypR/ffioHmkti6/Tag==", + "dev": true, + "requires": { + "estraverse": "^5.2.0" + } + }, + "estraverse": { + "version": "5.3.0", + "resolved": "https://registry.npmjs.org/estraverse/-/estraverse-5.3.0.tgz", + "integrity": "sha512-MMdARuVEQziNTeJD8DgMqmhwR11BRQ/cBP+pLtYdSTnf3MIO8fFeiINEbX36ZdNlfU/7A9f3gUw49B3oQsvwBA==", + "dev": true + }, + "esutils": { + "version": "2.0.3", + "resolved": "https://registry.npmjs.org/esutils/-/esutils-2.0.3.tgz", + "integrity": "sha512-kVscqXk4OCp68SZ0dkgEKVi6/8ij300KBWTJq32P/dYeWTSwK41WyTxalN1eRmA5Z9UU/LX9D7FWSmV9SAYx6g==", + "dev": true + }, + "execa": { + "version": "5.1.1", + "resolved": "https://registry.npmjs.org/execa/-/execa-5.1.1.tgz", + "integrity": "sha512-8uSpZZocAZRBAPIEINJj3Lo9HyGitllczc27Eh5YYojjMFMn8yHMDMaUHE2Jqfq05D/wucwI4JGURyXt1vchyg==", + "dev": true, + "requires": { + "cross-spawn": "^7.0.3", + "get-stream": "^6.0.0", + "human-signals": "^2.1.0", + "is-stream": "^2.0.0", + "merge-stream": "^2.0.0", + "npm-run-path": "^4.0.1", + "onetime": "^5.1.2", + "signal-exit": "^3.0.3", + "strip-final-newline": "^2.0.0" + } + }, + "exit": { + "version": "0.1.2", + "resolved": "https://registry.npmjs.org/exit/-/exit-0.1.2.tgz", + "integrity": "sha512-Zk/eNKV2zbjpKzrsQ+n1G6poVbErQxJ0LBOJXaKZ1EViLzH+hrLu9cdXI4zw9dBQJslwBEpbQ2P1oS7nDxs6jQ==", + "dev": true + }, + "expect": { + "version": "29.5.0", + "resolved": "https://registry.npmjs.org/expect/-/expect-29.5.0.tgz", + "integrity": "sha512-yM7xqUrCO2JdpFo4XpM82t+PJBFybdqoQuJLDGeDX2ij8NZzqRHyu3Hp188/JX7SWqud+7t4MUdvcgGBICMHZg==", + "dev": true, + "requires": { + "@jest/expect-utils": "^29.5.0", + "jest-get-type": "^29.4.3", + "jest-matcher-utils": "^29.5.0", + "jest-message-util": "^29.5.0", + "jest-util": "^29.5.0" + } + }, + "fast-deep-equal": { + "version": "3.1.3", + "resolved": "https://registry.npmjs.org/fast-deep-equal/-/fast-deep-equal-3.1.3.tgz", + "integrity": "sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q==", + "dev": true + }, + "fast-json-stable-stringify": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/fast-json-stable-stringify/-/fast-json-stable-stringify-2.1.0.tgz", + "integrity": "sha512-lhd/wF+Lk98HZoTCtlVraHtfh5XYijIjalXck7saUtuanSDyLMxnHhSXEDJqHxD7msR8D0uCmqlkwjCV8xvwHw==", + "dev": true + }, + "fast-levenshtein": { + "version": "2.0.6", + "resolved": "https://registry.npmjs.org/fast-levenshtein/-/fast-levenshtein-2.0.6.tgz", + "integrity": "sha512-DCXu6Ifhqcks7TZKY3Hxp3y6qphY5SJZmrWMDrKcERSOXWQdMhU9Ig/PYrzyw/ul9jOIyh0N4M0tbC5hodg8dw==", + "dev": true + }, + "fastq": { + "version": "1.15.0", + "resolved": "https://registry.npmjs.org/fastq/-/fastq-1.15.0.tgz", + "integrity": "sha512-wBrocU2LCXXa+lWBt8RoIRD89Fi8OdABODa/kEnyeyjS5aZO5/GNvI5sEINADqP/h8M29UHTHUb53sUu5Ihqdw==", + "dev": true, + "requires": { + "reusify": "^1.0.4" + } + }, + "fb-watchman": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/fb-watchman/-/fb-watchman-2.0.2.tgz", + "integrity": "sha512-p5161BqbuCaSnB8jIbzQHOlpgsPmK5rJVDfDKO91Axs5NC1uu3HRQm6wt9cd9/+GtQQIO53JdGXXoyDpTAsgYA==", + "dev": true, + "requires": { + "bser": "2.1.1" + } + }, + "file-entry-cache": { + "version": "6.0.1", + "resolved": "https://registry.npmjs.org/file-entry-cache/-/file-entry-cache-6.0.1.tgz", + "integrity": "sha512-7Gps/XWymbLk2QLYK4NzpMOrYjMhdIxXuIvy2QBsLE6ljuodKvdkWs/cpyJJ3CVIVpH0Oi1Hvg1ovbMzLdFBBg==", + "dev": true, + "requires": { + "flat-cache": "^3.0.4" + } + }, + "fill-range": { + "version": "7.0.1", + "resolved": "https://registry.npmjs.org/fill-range/-/fill-range-7.0.1.tgz", + "integrity": "sha512-qOo9F+dMUmC2Lcb4BbVvnKJxTPjCm+RRpe4gDuGrzkL7mEVl/djYSu2OdQ2Pa302N4oqkSg9ir6jaLWJ2USVpQ==", + "dev": true, + "requires": { + "to-regex-range": "^5.0.1" + } + }, + "find-up": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/find-up/-/find-up-5.0.0.tgz", + "integrity": "sha512-78/PXT1wlLLDgTzDs7sjq9hzz0vXD+zn+7wypEe4fXQxCmdmqfGsEPQxmiCSQI3ajFV91bVSsvNtrJRiW6nGng==", + "dev": true, + "requires": { + "locate-path": "^6.0.0", + "path-exists": "^4.0.0" + } + }, + "flat-cache": { + "version": "3.0.4", + "resolved": "https://registry.npmjs.org/flat-cache/-/flat-cache-3.0.4.tgz", + "integrity": "sha512-dm9s5Pw7Jc0GvMYbshN6zchCA9RgQlzzEZX3vylR9IqFfS8XciblUXOKfW6SiuJ0e13eDYZoZV5wdrev7P3Nwg==", + "dev": true, + "requires": { + "flatted": "^3.1.0", + "rimraf": "^3.0.2" + } + }, + "flatted": { + "version": "3.2.7", + "resolved": "https://registry.npmjs.org/flatted/-/flatted-3.2.7.tgz", + "integrity": "sha512-5nqDSxl8nn5BSNxyR3n4I6eDmbolI6WT+QqR547RwxQapgjQBmtktdP+HTBb/a/zLsbzERTONyUB5pefh5TtjQ==", + "dev": true + }, + "for-each": { + "version": "0.3.3", + "resolved": "https://registry.npmjs.org/for-each/-/for-each-0.3.3.tgz", + "integrity": "sha512-jqYfLp7mo9vIyQf8ykW2v7A+2N4QjeCeI5+Dz9XraiO1ign81wjiH7Fb9vSOWvQfNtmSa4H2RoQTrrXivdUZmw==", + "dev": true, + "requires": { + "is-callable": "^1.1.3" + } + }, + "fs-minipass": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/fs-minipass/-/fs-minipass-2.1.0.tgz", + "integrity": "sha512-V/JgOLFCS+R6Vcq0slCuaeWEdNC3ouDlJMNIsacH2VtALiu9mV4LPrHc5cDl8k5aw6J8jwgWWpiTo5RYhmIzvg==", + "requires": { + "minipass": "^3.0.0" + }, + "dependencies": { + "minipass": { + "version": "3.3.6", + "resolved": "https://registry.npmjs.org/minipass/-/minipass-3.3.6.tgz", + "integrity": "sha512-DxiNidxSEK+tHG6zOIklvNOwm3hvCrbUrdtzY74U6HKTJxvIDfOUL5W5P2Ghd3DTkhhKPYGqeNUIh5qcM4YBfw==", + "requires": { + "yallist": "^4.0.0" + } + }, + "yallist": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/yallist/-/yallist-4.0.0.tgz", + "integrity": "sha512-3wdGidZyq5PB084XLES5TpOSRA3wjXAlIWMhum2kRcv/41Sn2emQ0dycQW4uZXLejwKvg6EsvbdlVL+FYEct7A==" + } + } + }, + "fs.realpath": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/fs.realpath/-/fs.realpath-1.0.0.tgz", + "integrity": "sha512-OO0pH2lK6a0hZnAdau5ItzHPI6pUlvI7jMVnxUQRtw4owF2wk8lOSabtGDCTP4Ggrg2MbGnWO9X8K1t4+fGMDw==" + }, + "fsevents": { + "version": "2.3.2", + "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.2.tgz", + "integrity": "sha512-xiqMQR4xAeHTuB9uWm+fFRcIOgKBMiOBP+eXiyT7jsgVCq1bkVygt00oASowB7EdtpOHaaPgKt812P9ab+DDKA==", + "dev": true, + "optional": true + }, + "function-bind": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/function-bind/-/function-bind-1.1.1.tgz", + "integrity": "sha512-yIovAzMX49sF8Yl58fSCWJ5svSLuaibPxXQJFLmBObTuCr0Mf1KiPopGM9NiFjiYBCbfaa2Fh6breQ6ANVTI0A==", + "dev": true + }, + "function.prototype.name": { + "version": "1.1.5", + "resolved": "https://registry.npmjs.org/function.prototype.name/-/function.prototype.name-1.1.5.tgz", + "integrity": "sha512-uN7m/BzVKQnCUF/iW8jYea67v++2u7m5UgENbHRtdDVclOUP+FMPlCNdmk0h/ysGyo2tavMJEDqJAkJdRa1vMA==", + "dev": true, + "requires": { + "call-bind": "^1.0.2", + "define-properties": "^1.1.3", + "es-abstract": "^1.19.0", + "functions-have-names": "^1.2.2" + } + }, + "functions-have-names": { + "version": "1.2.3", + "resolved": "https://registry.npmjs.org/functions-have-names/-/functions-have-names-1.2.3.tgz", + "integrity": "sha512-xckBUXyTIqT97tq2x2AMb+g163b5JFysYk0x4qxNFwbfQkmNZoiRHb6sPzI9/QV33WeuvVYBUIiD4NzNIyqaRQ==", + "dev": true + }, + "gauge": { + "version": "3.0.2", + "resolved": "https://registry.npmjs.org/gauge/-/gauge-3.0.2.tgz", + "integrity": "sha512-+5J6MS/5XksCuXq++uFRsnUd7Ovu1XenbeuIuNRJxYWjgQbPuFhT14lAvsWfqfAmnwluf1OwMjz39HjfLPci0Q==", + "requires": { + "aproba": "^1.0.3 || ^2.0.0", + "color-support": "^1.1.2", + "console-control-strings": "^1.0.0", + "has-unicode": "^2.0.1", + "object-assign": "^4.1.1", + "signal-exit": "^3.0.0", + "string-width": "^4.2.3", + "strip-ansi": "^6.0.1", + "wide-align": "^1.1.2" + } + }, + "gensync": { + "version": "1.0.0-beta.2", + "resolved": "https://registry.npmjs.org/gensync/-/gensync-1.0.0-beta.2.tgz", + "integrity": "sha512-3hN7NaskYvMDLQY55gnW3NQ+mesEAepTqlg+VEbj7zzqEMBVNhzcGYYeqFo/TlYz6eQiFcp1HcsCZO+nGgS8zg==", + "dev": true + }, + "get-caller-file": { + "version": "2.0.5", + "resolved": "https://registry.npmjs.org/get-caller-file/-/get-caller-file-2.0.5.tgz", + "integrity": "sha512-DyFP3BM/3YHTQOCUL/w0OZHR0lpKeGrxotcHWcqNEdnltqFwXVfhEBQ94eIo34AfQpo0rGki4cyIiftY06h2Fg==", + "dev": true + }, + "get-intrinsic": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/get-intrinsic/-/get-intrinsic-1.2.0.tgz", + "integrity": "sha512-L049y6nFOuom5wGyRc3/gdTLO94dySVKRACj1RmJZBQXlbTMhtNIgkWkUHq+jYmZvKf14EW1EoJnnjbmoHij0Q==", + "dev": true, + "requires": { + "function-bind": "^1.1.1", + "has": "^1.0.3", + "has-symbols": "^1.0.3" + } + }, + "get-package-type": { + "version": "0.1.0", + "resolved": "https://registry.npmjs.org/get-package-type/-/get-package-type-0.1.0.tgz", + "integrity": "sha512-pjzuKtY64GYfWizNAJ0fr9VqttZkNiK2iS430LtIHzjBEr6bX8Am2zm4sW4Ro5wjWW5cAlRL1qAMTcXbjNAO2Q==", + "dev": true + }, + "get-stream": { + "version": "6.0.1", + "resolved": "https://registry.npmjs.org/get-stream/-/get-stream-6.0.1.tgz", + "integrity": "sha512-ts6Wi+2j3jQjqi70w5AlN8DFnkSwC+MqmxEzdEALB2qXZYV3X/b1CTfgPLGJNMeAWxdPfU8FO1ms3NUfaHCPYg==", + "dev": true + }, + "get-symbol-description": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/get-symbol-description/-/get-symbol-description-1.0.0.tgz", + "integrity": "sha512-2EmdH1YvIQiZpltCNgkuiUnyukzxM/R6NDJX31Ke3BG1Nq5b0S2PhX59UKi9vZpPDQVdqn+1IcaAwnzTT5vCjw==", + "dev": true, + "requires": { + "call-bind": "^1.0.2", + "get-intrinsic": "^1.1.1" + } + }, + "glob": { + "version": "7.2.3", + "resolved": "https://registry.npmjs.org/glob/-/glob-7.2.3.tgz", + "integrity": "sha512-nFR0zLpU2YCaRxwoCJvL6UvCH2JFyFVIvwTLsIf21AuHlMskA1hhTdk+LlYJtOlYt9v6dvszD2BGRqBL+iQK9Q==", + "requires": { + "fs.realpath": "^1.0.0", + "inflight": "^1.0.4", + "inherits": "2", + "minimatch": "^3.1.1", + "once": "^1.3.0", + "path-is-absolute": "^1.0.0" + } + }, + "glob-parent": { + "version": "6.0.2", + "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-6.0.2.tgz", + "integrity": "sha512-XxwI8EOhVQgWp6iDL+3b0r86f4d6AX6zSU55HfB4ydCEuXLXc5FcYeOu+nnGftS4TEju/11rt4KJPTMgbfmv4A==", + "dev": true, + "requires": { + "is-glob": "^4.0.3" + } + }, + "globals": { + "version": "13.20.0", + "resolved": "https://registry.npmjs.org/globals/-/globals-13.20.0.tgz", + "integrity": "sha512-Qg5QtVkCy/kv3FUSlu4ukeZDVf9ee0iXLAUYX13gbR17bnejFTzr4iS9bY7kwCf1NztRNm1t91fjOiyx4CSwPQ==", + "dev": true, + "requires": { + "type-fest": "^0.20.2" + } + }, + "globalthis": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/globalthis/-/globalthis-1.0.3.tgz", + "integrity": "sha512-sFdI5LyBiNTHjRd7cGPWapiHWMOXKyuBNX/cWJ3NfzrZQVa8GI/8cofCl74AOVqq9W5kNmguTIzJ/1s2gyI9wA==", + "dev": true, + "requires": { + "define-properties": "^1.1.3" + } + }, + "gopd": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/gopd/-/gopd-1.0.1.tgz", + "integrity": "sha512-d65bNlIadxvpb/A2abVdlqKqV563juRnZ1Wtk6s1sIR8uNsXR70xqIzVqxVf1eTqDunwT2MkczEeaezCKTZhwA==", + "dev": true, + "requires": { + "get-intrinsic": "^1.1.3" + } + }, + "graceful-fs": { + "version": "4.2.10", + "resolved": "https://registry.npmjs.org/graceful-fs/-/graceful-fs-4.2.10.tgz", + "integrity": "sha512-9ByhssR2fPVsNZj478qUUbKfmL0+t5BDVyjShtyZZLiK7ZDAArFFfopyOTj0M05wE2tJPisA4iTnnXl2YoPvOA==", + "dev": true + }, + "grapheme-splitter": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/grapheme-splitter/-/grapheme-splitter-1.0.4.tgz", + "integrity": "sha512-bzh50DW9kTPM00T8y4o8vQg89Di9oLJVLW/KaOGIXJWP/iqCN6WKYkbNOF04vFLJhwcpYUh9ydh/+5vpOqV4YQ==", + "dev": true + }, + "has": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/has/-/has-1.0.3.tgz", + "integrity": "sha512-f2dvO0VU6Oej7RkWJGrehjbzMAjFp5/VKPp5tTpWIV4JHHZK1/BxbFRtf/siA2SWTe09caDmVtYYzWEIbBS4zw==", + "dev": true, + "requires": { + "function-bind": "^1.1.1" + } + }, + "has-bigints": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/has-bigints/-/has-bigints-1.0.2.tgz", + "integrity": "sha512-tSvCKtBr9lkF0Ex0aQiP9N+OpV4zi2r/Nee5VkRDbaqv35RLYMzbwQfFSZZH0kR+Rd6302UJZ2p/bJCEoR3VoQ==", + "dev": true + }, + "has-flag": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz", + "integrity": "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==", + "dev": true + }, + "has-property-descriptors": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/has-property-descriptors/-/has-property-descriptors-1.0.0.tgz", + "integrity": "sha512-62DVLZGoiEBDHQyqG4w9xCuZ7eJEwNmJRWw2VY84Oedb7WFcA27fiEVe8oUQx9hAUJ4ekurquucTGwsyO1XGdQ==", + "dev": true, + "requires": { + "get-intrinsic": "^1.1.1" + } + }, + "has-proto": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/has-proto/-/has-proto-1.0.1.tgz", + "integrity": "sha512-7qE+iP+O+bgF9clE5+UoBFzE65mlBiVj3tKCrlNQ0Ogwm0BjpT/gK4SlLYDMybDh5I3TCTKnPPa0oMG7JDYrhg==", + "dev": true + }, + "has-symbols": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/has-symbols/-/has-symbols-1.0.3.tgz", + "integrity": "sha512-l3LCuF6MgDNwTDKkdYGEihYjt5pRPbEg46rtlmnSPlUbgmB8LOIrKJbYYFBSbnPaJexMKtiPO8hmeRjRz2Td+A==", + "dev": true + }, + "has-tostringtag": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/has-tostringtag/-/has-tostringtag-1.0.0.tgz", + "integrity": "sha512-kFjcSNhnlGV1kyoGk7OXKSawH5JOb/LzUc5w9B02hOTO0dfFRjbHQKvg1d6cf3HbeUmtU9VbbV3qzZ2Teh97WQ==", + "dev": true, + "requires": { + "has-symbols": "^1.0.2" + } + }, + "has-unicode": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/has-unicode/-/has-unicode-2.0.1.tgz", + "integrity": "sha512-8Rf9Y83NBReMnx0gFzA8JImQACstCYWUplepDa9xprwwtmgEZUF0h/i5xSA625zB/I37EtrswSST6OXxwaaIJQ==" + }, + "heap": { + "version": "0.2.7", + "resolved": "https://registry.npmjs.org/heap/-/heap-0.2.7.tgz", + "integrity": "sha512-2bsegYkkHO+h/9MGbn6KWcE45cHZgPANo5LXF7EvWdT0yT2EguSVO1nDgU5c8+ZOPwp2vMNa7YFsJhVcDR9Sdg==", + "dev": true + }, + "html-element-map": { + "version": "1.3.1", + "resolved": "https://registry.npmjs.org/html-element-map/-/html-element-map-1.3.1.tgz", + "integrity": "sha512-6XMlxrAFX4UEEGxctfFnmrFaaZFNf9i5fNuV5wZ3WWQ4FVaNP1aX1LkX9j2mfEx1NpjeE/rL3nmgEn23GdFmrg==", + "dev": true, + "requires": { + "array.prototype.filter": "^1.0.0", + "call-bind": "^1.0.2" + } + }, + "html-escaper": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/html-escaper/-/html-escaper-2.0.2.tgz", + "integrity": "sha512-H2iMtd0I4Mt5eYiapRdIDjp+XzelXQ0tFE4JS7YFwFevXXMmOp9myNrUvCg0D6ws8iqkRPBfKHgbwig1SmlLfg==", + "dev": true + }, + "htmlparser2": { + "version": "8.0.1", + "resolved": "https://registry.npmjs.org/htmlparser2/-/htmlparser2-8.0.1.tgz", + "integrity": "sha512-4lVbmc1diZC7GUJQtRQ5yBAeUCL1exyMwmForWkRLnwyzWBFxN633SALPMGYaWZvKe9j1pRZJpauvmxENSp/EA==", + "dev": true, + "requires": { + "domelementtype": "^2.3.0", + "domhandler": "^5.0.2", + "domutils": "^3.0.1", + "entities": "^4.3.0" + } + }, + "https-proxy-agent": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/https-proxy-agent/-/https-proxy-agent-5.0.1.tgz", + "integrity": "sha512-dFcAjpTQFgoLMzC2VwU+C/CbS7uRL0lWmxDITmqm7C+7F0Odmj6s9l6alZc6AELXhrnggM2CeWSXHGOdX2YtwA==", + "requires": { + "agent-base": "6", + "debug": "4" + } + }, + "human-signals": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/human-signals/-/human-signals-2.1.0.tgz", + "integrity": "sha512-B4FFZ6q/T2jhhksgkbEW3HBvWIfDW85snkQgawt07S7J5QXTk6BkNV+0yAeZrM5QpMAdYlocGoljn0sJ/WQkFw==", + "dev": true + }, + "ignore": { + "version": "5.2.4", + "resolved": "https://registry.npmjs.org/ignore/-/ignore-5.2.4.tgz", + "integrity": "sha512-MAb38BcSbH0eHNBxn7ql2NH/kX33OkB3lZ1BNdh7ENeRChHTYsTvWrMubiIAMNS2llXEEgZ1MUOBtXChP3kaFQ==", + "dev": true + }, + "import-fresh": { + "version": "3.3.0", + "resolved": "https://registry.npmjs.org/import-fresh/-/import-fresh-3.3.0.tgz", + "integrity": "sha512-veYYhQa+D1QBKznvhUHxb8faxlrwUnxseDAbAp457E0wLNio2bOSKnjYDhMj+YiAq61xrMGhQk9iXVk5FzgQMw==", + "dev": true, + "requires": { + "parent-module": "^1.0.0", + "resolve-from": "^4.0.0" + } + }, + "import-local": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/import-local/-/import-local-3.1.0.tgz", + "integrity": "sha512-ASB07uLtnDs1o6EHjKpX34BKYDSqnFerfTOJL2HvMqF70LnxpjkzDB8J44oT9pu4AMPkQwf8jl6szgvNd2tRIg==", + "dev": true, + "requires": { + "pkg-dir": "^4.2.0", + "resolve-cwd": "^3.0.0" + } + }, + "imurmurhash": { + "version": "0.1.4", + "resolved": "https://registry.npmjs.org/imurmurhash/-/imurmurhash-0.1.4.tgz", + "integrity": "sha512-JmXMZ6wuvDmLiHEml9ykzqO6lwFbof0GG4IkcGaENdCRDDmMVnny7s5HsIgHCbaq0w2MyPhDqkhTUgS2LU2PHA==", + "dev": true + }, + "inflight": { + "version": "1.0.6", + "resolved": "https://registry.npmjs.org/inflight/-/inflight-1.0.6.tgz", + "integrity": "sha512-k92I/b08q4wvFscXCLvqfsHCrjrF7yiXsQuIVvVE7N82W3+aqpzuUdBbfhWcy/FZR3/4IgflMgKLOsvPDrGCJA==", + "requires": { + "once": "^1.3.0", + "wrappy": "1" + } + }, + "inherits": { + "version": "2.0.4", + "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.4.tgz", + "integrity": "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==" + }, + "internal-slot": { + "version": "1.0.5", + "resolved": "https://registry.npmjs.org/internal-slot/-/internal-slot-1.0.5.tgz", + "integrity": "sha512-Y+R5hJrzs52QCG2laLn4udYVnxsfny9CpOhNhUvk/SSSVyF6T27FzRbF0sroPidSu3X8oEAkOn2K804mjpt6UQ==", + "dev": true, + "requires": { + "get-intrinsic": "^1.2.0", + "has": "^1.0.3", + "side-channel": "^1.0.4" + } + }, + "is-array-buffer": { + "version": "3.0.2", + "resolved": "https://registry.npmjs.org/is-array-buffer/-/is-array-buffer-3.0.2.tgz", + "integrity": "sha512-y+FyyR/w8vfIRq4eQcM1EYgSTnmHXPqaF+IgzgraytCFq5Xh8lllDVmAZolPJiZttZLeFSINPYMaEJ7/vWUa1w==", + "dev": true, + "requires": { + "call-bind": "^1.0.2", + "get-intrinsic": "^1.2.0", + "is-typed-array": "^1.1.10" + } + }, + "is-arrayish": { + "version": "0.2.1", + "resolved": "https://registry.npmjs.org/is-arrayish/-/is-arrayish-0.2.1.tgz", + "integrity": "sha512-zz06S8t0ozoDXMG+ube26zeCTNXcKIPJZJi8hBrF4idCLms4CG9QtK7qBl1boi5ODzFpjswb5JPmHCbMpjaYzg==", + "dev": true + }, + "is-bigint": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/is-bigint/-/is-bigint-1.0.4.tgz", + "integrity": "sha512-zB9CruMamjym81i2JZ3UMn54PKGsQzsJeo6xvN3HJJ4CAsQNB6iRutp2To77OfCNuoxspsIhzaPoO1zyCEhFOg==", + "dev": true, + "requires": { + "has-bigints": "^1.0.1" + } + }, + "is-boolean-object": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/is-boolean-object/-/is-boolean-object-1.1.2.tgz", + "integrity": "sha512-gDYaKHJmnj4aWxyj6YHyXVpdQawtVLHU5cb+eztPGczf6cjuTdwve5ZIEfgXqH4e57An1D1AKf8CZ3kYrQRqYA==", + "dev": true, + "requires": { + "call-bind": "^1.0.2", + "has-tostringtag": "^1.0.0" + } + }, + "is-callable": { + "version": "1.2.7", + "resolved": "https://registry.npmjs.org/is-callable/-/is-callable-1.2.7.tgz", + "integrity": "sha512-1BC0BVFhS/p0qtw6enp8e+8OD0UrK0oFLztSjNzhcKA3WDuJxxAPXzPuPtKkjEY9UUoEWlX/8fgKeu2S8i9JTA==", + "dev": true + }, + "is-core-module": { + "version": "2.11.0", + "resolved": "https://registry.npmjs.org/is-core-module/-/is-core-module-2.11.0.tgz", + "integrity": "sha512-RRjxlvLDkD1YJwDbroBHMb+cukurkDWNyHx7D3oNB5x9rb5ogcksMC5wHCadcXoo67gVr/+3GFySh3134zi6rw==", + "dev": true, + "requires": { + "has": "^1.0.3" + } + }, + "is-date-object": { + "version": "1.0.5", + "resolved": "https://registry.npmjs.org/is-date-object/-/is-date-object-1.0.5.tgz", + "integrity": "sha512-9YQaSxsAiSwcvS33MBk3wTCVnWK+HhF8VZR2jRxehM16QcVOdHqPn4VPHmRK4lSr38n9JriurInLcP90xsYNfQ==", + "dev": true, + "requires": { + "has-tostringtag": "^1.0.0" + } + }, + "is-extglob": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/is-extglob/-/is-extglob-2.1.1.tgz", + "integrity": "sha512-SbKbANkN603Vi4jEZv49LeVJMn4yGwsbzZworEoyEiutsN3nJYdbO36zfhGJ6QEDpOZIFkDtnq5JRxmvl3jsoQ==", + "dev": true + }, + "is-fullwidth-code-point": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-3.0.0.tgz", + "integrity": "sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg==" + }, + "is-generator-fn": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/is-generator-fn/-/is-generator-fn-2.1.0.tgz", + "integrity": "sha512-cTIB4yPYL/Grw0EaSzASzg6bBy9gqCofvWN8okThAYIxKJZC+udlRAmGbM0XLeniEJSs8uEgHPGuHSe1XsOLSQ==", + "dev": true + }, + "is-glob": { + "version": "4.0.3", + "resolved": "https://registry.npmjs.org/is-glob/-/is-glob-4.0.3.tgz", + "integrity": "sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg==", + "dev": true, + "requires": { + "is-extglob": "^2.1.1" + } + }, + "is-negative-zero": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/is-negative-zero/-/is-negative-zero-2.0.2.tgz", + "integrity": "sha512-dqJvarLawXsFbNDeJW7zAz8ItJ9cd28YufuuFzh0G8pNHjJMnY08Dv7sYX2uF5UpQOwieAeOExEYAWWfu7ZZUA==", + "dev": true + }, + "is-number": { + "version": "7.0.0", + "resolved": "https://registry.npmjs.org/is-number/-/is-number-7.0.0.tgz", + "integrity": "sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng==", + "dev": true + }, + "is-number-object": { + "version": "1.0.7", + "resolved": "https://registry.npmjs.org/is-number-object/-/is-number-object-1.0.7.tgz", + "integrity": "sha512-k1U0IRzLMo7ZlYIfzRu23Oh6MiIFasgpb9X76eqfFZAqwH44UI4KTBvBYIZ1dSL9ZzChTB9ShHfLkR4pdW5krQ==", + "dev": true, + "requires": { + "has-tostringtag": "^1.0.0" + } + }, + "is-path-inside": { + "version": "3.0.3", + "resolved": "https://registry.npmjs.org/is-path-inside/-/is-path-inside-3.0.3.tgz", + "integrity": "sha512-Fd4gABb+ycGAmKou8eMftCupSir5lRxqf4aD/vd0cD2qc4HL07OjCeuHMr8Ro4CoMaeCKDB0/ECBOVWjTwUvPQ==", + "dev": true + }, + "is-plain-object": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/is-plain-object/-/is-plain-object-5.0.0.tgz", + "integrity": "sha512-VRSzKkbMm5jMDoKLbltAkFQ5Qr7VDiTFGXxYFXXowVj387GeGNOCsOH6Msy00SGZ3Fp84b1Naa1psqgcCIEP5Q==" + }, + "is-regex": { + "version": "1.1.4", + "resolved": "https://registry.npmjs.org/is-regex/-/is-regex-1.1.4.tgz", + "integrity": "sha512-kvRdxDsxZjhzUX07ZnLydzS1TU/TJlTUHHY4YLL87e37oUA49DfkLqgy+VjFocowy29cKvcSiu+kIv728jTTVg==", + "dev": true, + "requires": { + "call-bind": "^1.0.2", + "has-tostringtag": "^1.0.0" + } + }, + "is-shared-array-buffer": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/is-shared-array-buffer/-/is-shared-array-buffer-1.0.2.tgz", + "integrity": "sha512-sqN2UDu1/0y6uvXyStCOzyhAjCSlHceFoMKJW8W9EU9cvic/QdsZ0kEU93HEy3IUEFZIiH/3w+AH/UQbPHNdhA==", + "dev": true, + "requires": { + "call-bind": "^1.0.2" + } + }, + "is-stream": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/is-stream/-/is-stream-2.0.1.tgz", + "integrity": "sha512-hFoiJiTl63nn+kstHGBtewWSKnQLpyb155KHheA1l39uvtO9nWIop1p3udqPcUd/xbF1VLMO4n7OI6p7RbngDg==", + "dev": true + }, + "is-string": { + "version": "1.0.7", + "resolved": "https://registry.npmjs.org/is-string/-/is-string-1.0.7.tgz", + "integrity": "sha512-tE2UXzivje6ofPW7l23cjDOMa09gb7xlAqG6jG5ej6uPV32TlWP3NKPigtaGeHNu9fohccRYvIiZMfOOnOYUtg==", + "dev": true, + "requires": { + "has-tostringtag": "^1.0.0" + } + }, + "is-subset": { + "version": "0.1.1", + "resolved": "https://registry.npmjs.org/is-subset/-/is-subset-0.1.1.tgz", + "integrity": "sha512-6Ybun0IkarhmEqxXCNw/C0bna6Zb/TkfUX9UbwJtK6ObwAVCxmAP308WWTHviM/zAqXk05cdhYsUsZeGQh99iw==", + "dev": true + }, + "is-symbol": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/is-symbol/-/is-symbol-1.0.4.tgz", + "integrity": "sha512-C/CPBqKWnvdcxqIARxyOh4v1UUEOCHpgDa0WYgpKDFMszcrPcffg5uhwSgPCLD2WWxmq6isisz87tzT01tuGhg==", + "dev": true, + "requires": { + "has-symbols": "^1.0.2" + } + }, + "is-typed-array": { + "version": "1.1.10", + "resolved": "https://registry.npmjs.org/is-typed-array/-/is-typed-array-1.1.10.tgz", + "integrity": "sha512-PJqgEHiWZvMpaFZ3uTc8kHPM4+4ADTlDniuQL7cU/UDA0Ql7F70yGfHph3cLNe+c9toaigv+DFzTJKhc2CtO6A==", + "dev": true, + "requires": { + "available-typed-arrays": "^1.0.5", + "call-bind": "^1.0.2", + "for-each": "^0.3.3", + "gopd": "^1.0.1", + "has-tostringtag": "^1.0.0" + } + }, + "is-weakref": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/is-weakref/-/is-weakref-1.0.2.tgz", + "integrity": "sha512-qctsuLZmIQ0+vSSMfoVvyFe2+GSEvnmZ2ezTup1SBse9+twCCeial6EEi3Nc2KFcf6+qz2FBPnjXsk8xhKSaPQ==", + "dev": true, + "requires": { + "call-bind": "^1.0.2" + } + }, + "isexe": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/isexe/-/isexe-2.0.0.tgz", + "integrity": "sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw==", + "dev": true + }, + "istanbul-lib-coverage": { + "version": "3.2.0", + "resolved": "https://registry.npmjs.org/istanbul-lib-coverage/-/istanbul-lib-coverage-3.2.0.tgz", + "integrity": "sha512-eOeJ5BHCmHYvQK7xt9GkdHuzuCGS1Y6g9Gvnx3Ym33fz/HpLRYxiS0wHNr+m/MBC8B647Xt608vCDEvhl9c6Mw==", + "dev": true + }, + "istanbul-lib-instrument": { + "version": "5.2.1", + "resolved": "https://registry.npmjs.org/istanbul-lib-instrument/-/istanbul-lib-instrument-5.2.1.tgz", + "integrity": "sha512-pzqtp31nLv/XFOzXGuvhCb8qhjmTVo5vjVk19XE4CRlSWz0KoeJ3bw9XsA7nOp9YBf4qHjwBxkDzKcME/J29Yg==", + "dev": true, + "requires": { + "@babel/core": "^7.12.3", + "@babel/parser": "^7.14.7", + "@istanbuljs/schema": "^0.1.2", + "istanbul-lib-coverage": "^3.2.0", + "semver": "^6.3.0" + } + }, + "istanbul-lib-report": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/istanbul-lib-report/-/istanbul-lib-report-3.0.0.tgz", + "integrity": "sha512-wcdi+uAKzfiGT2abPpKZ0hSU1rGQjUQnLvtY5MpQ7QCTahD3VODhcu4wcfY1YtkGaDD5yuydOLINXsfbus9ROw==", + "dev": true, + "requires": { + "istanbul-lib-coverage": "^3.0.0", + "make-dir": "^3.0.0", + "supports-color": "^7.1.0" + } + }, + "istanbul-lib-source-maps": { + "version": "4.0.1", + "resolved": "https://registry.npmjs.org/istanbul-lib-source-maps/-/istanbul-lib-source-maps-4.0.1.tgz", + "integrity": "sha512-n3s8EwkdFIJCG3BPKBYvskgXGoy88ARzvegkitk60NxRdwltLOTaH7CUiMRXvwYorl0Q712iEjcWB+fK/MrWVw==", + "dev": true, + "requires": { + "debug": "^4.1.1", + "istanbul-lib-coverage": "^3.0.0", + "source-map": "^0.6.1" + } + }, + "istanbul-reports": { + "version": "3.1.5", + "resolved": "https://registry.npmjs.org/istanbul-reports/-/istanbul-reports-3.1.5.tgz", + "integrity": "sha512-nUsEMa9pBt/NOHqbcbeJEgqIlY/K7rVWUX6Lql2orY5e9roQOthbR3vtY4zzf2orPELg80fnxxk9zUyPlgwD1w==", + "dev": true, + "requires": { + "html-escaper": "^2.0.0", + "istanbul-lib-report": "^3.0.0" + } + }, + "jest": { + "version": "29.4.2", + "resolved": "https://registry.npmjs.org/jest/-/jest-29.4.2.tgz", + "integrity": "sha512-+5hLd260vNIHu+7ZgMIooSpKl7Jp5pHKb51e73AJU3owd5dEo/RfVwHbA/na3C/eozrt3hJOLGf96c7EWwIAzg==", + "dev": true, + "requires": { + "@jest/core": "^29.4.2", + "@jest/types": "^29.4.2", + "import-local": "^3.0.2", + "jest-cli": "^29.4.2" + } + }, + "jest-changed-files": { + "version": "29.5.0", + "resolved": "https://registry.npmjs.org/jest-changed-files/-/jest-changed-files-29.5.0.tgz", + "integrity": "sha512-IFG34IUMUaNBIxjQXF/iu7g6EcdMrGRRxaUSw92I/2g2YC6vCdTltl4nHvt7Ci5nSJwXIkCu8Ka1DKF+X7Z1Ag==", + "dev": true, + "requires": { + "execa": "^5.0.0", + "p-limit": "^3.1.0" + } + }, + "jest-circus": { + "version": "29.5.0", + "resolved": "https://registry.npmjs.org/jest-circus/-/jest-circus-29.5.0.tgz", + "integrity": "sha512-gq/ongqeQKAplVxqJmbeUOJJKkW3dDNPY8PjhJ5G0lBRvu0e3EWGxGy5cI4LAGA7gV2UHCtWBI4EMXK8c9nQKA==", + "dev": true, + "requires": { + "@jest/environment": "^29.5.0", + "@jest/expect": "^29.5.0", + "@jest/test-result": "^29.5.0", + "@jest/types": "^29.5.0", + "@types/node": "*", + "chalk": "^4.0.0", + "co": "^4.6.0", + "dedent": "^0.7.0", + "is-generator-fn": "^2.0.0", + "jest-each": "^29.5.0", + "jest-matcher-utils": "^29.5.0", + "jest-message-util": "^29.5.0", + "jest-runtime": "^29.5.0", + "jest-snapshot": "^29.5.0", + "jest-util": "^29.5.0", + "p-limit": "^3.1.0", + "pretty-format": "^29.5.0", + "pure-rand": "^6.0.0", + "slash": "^3.0.0", + "stack-utils": "^2.0.3" + } + }, + "jest-cli": { + "version": "29.5.0", + "resolved": "https://registry.npmjs.org/jest-cli/-/jest-cli-29.5.0.tgz", + "integrity": "sha512-L1KcP1l4HtfwdxXNFCL5bmUbLQiKrakMUriBEcc1Vfz6gx31ORKdreuWvmQVBit+1ss9NNR3yxjwfwzZNdQXJw==", + "dev": true, + "requires": { + "@jest/core": "^29.5.0", + "@jest/test-result": "^29.5.0", + "@jest/types": "^29.5.0", + "chalk": "^4.0.0", + "exit": "^0.1.2", + "graceful-fs": "^4.2.9", + "import-local": "^3.0.2", + "jest-config": "^29.5.0", + "jest-util": "^29.5.0", + "jest-validate": "^29.5.0", + "prompts": "^2.0.1", + "yargs": "^17.3.1" + } + }, + "jest-config": { + "version": "29.5.0", + "resolved": "https://registry.npmjs.org/jest-config/-/jest-config-29.5.0.tgz", + "integrity": "sha512-kvDUKBnNJPNBmFFOhDbm59iu1Fii1Q6SxyhXfvylq3UTHbg6o7j/g8k2dZyXWLvfdKB1vAPxNZnMgtKJcmu3kA==", + "dev": true, + "requires": { + "@babel/core": "^7.11.6", + "@jest/test-sequencer": "^29.5.0", + "@jest/types": "^29.5.0", + "babel-jest": "^29.5.0", + "chalk": "^4.0.0", + "ci-info": "^3.2.0", + "deepmerge": "^4.2.2", + "glob": "^7.1.3", + "graceful-fs": "^4.2.9", + "jest-circus": "^29.5.0", + "jest-environment-node": "^29.5.0", + "jest-get-type": "^29.4.3", + "jest-regex-util": "^29.4.3", + "jest-resolve": "^29.5.0", + "jest-runner": "^29.5.0", + "jest-util": "^29.5.0", + "jest-validate": "^29.5.0", + "micromatch": "^4.0.4", + "parse-json": "^5.2.0", + "pretty-format": "^29.5.0", + "slash": "^3.0.0", + "strip-json-comments": "^3.1.1" + } + }, + "jest-diff": { + "version": "29.5.0", + "resolved": "https://registry.npmjs.org/jest-diff/-/jest-diff-29.5.0.tgz", + "integrity": "sha512-LtxijLLZBduXnHSniy0WMdaHjmQnt3g5sa16W4p0HqukYTTsyTW3GD1q41TyGl5YFXj/5B2U6dlh5FM1LIMgxw==", + "dev": true, + "requires": { + "chalk": "^4.0.0", + "diff-sequences": "^29.4.3", + "jest-get-type": "^29.4.3", + "pretty-format": "^29.5.0" + } + }, + "jest-docblock": { + "version": "29.4.3", + "resolved": "https://registry.npmjs.org/jest-docblock/-/jest-docblock-29.4.3.tgz", + "integrity": "sha512-fzdTftThczeSD9nZ3fzA/4KkHtnmllawWrXO69vtI+L9WjEIuXWs4AmyME7lN5hU7dB0sHhuPfcKofRsUb/2Fg==", + "dev": true, + "requires": { + "detect-newline": "^3.0.0" + } + }, + "jest-each": { + "version": "29.5.0", + "resolved": "https://registry.npmjs.org/jest-each/-/jest-each-29.5.0.tgz", + "integrity": "sha512-HM5kIJ1BTnVt+DQZ2ALp3rzXEl+g726csObrW/jpEGl+CDSSQpOJJX2KE/vEg8cxcMXdyEPu6U4QX5eruQv5hA==", + "dev": true, + "requires": { + "@jest/types": "^29.5.0", + "chalk": "^4.0.0", + "jest-get-type": "^29.4.3", + "jest-util": "^29.5.0", + "pretty-format": "^29.5.0" + } + }, + "jest-environment-node": { + "version": "29.5.0", + "resolved": "https://registry.npmjs.org/jest-environment-node/-/jest-environment-node-29.5.0.tgz", + "integrity": "sha512-ExxuIK/+yQ+6PRGaHkKewYtg6hto2uGCgvKdb2nfJfKXgZ17DfXjvbZ+jA1Qt9A8EQSfPnt5FKIfnOO3u1h9qw==", + "dev": true, + "requires": { + "@jest/environment": "^29.5.0", + "@jest/fake-timers": "^29.5.0", + "@jest/types": "^29.5.0", + "@types/node": "*", + "jest-mock": "^29.5.0", + "jest-util": "^29.5.0" + } + }, + "jest-get-type": { + "version": "29.4.3", + "resolved": "https://registry.npmjs.org/jest-get-type/-/jest-get-type-29.4.3.tgz", + "integrity": "sha512-J5Xez4nRRMjk8emnTpWrlkyb9pfRQQanDrvWHhsR1+VUfbwxi30eVcZFlcdGInRibU4G5LwHXpI7IRHU0CY+gg==", + "dev": true + }, + "jest-haste-map": { + "version": "29.5.0", + "resolved": "https://registry.npmjs.org/jest-haste-map/-/jest-haste-map-29.5.0.tgz", + "integrity": "sha512-IspOPnnBro8YfVYSw6yDRKh/TiCdRngjxeacCps1cQ9cgVN6+10JUcuJ1EabrgYLOATsIAigxA0rLR9x/YlrSA==", + "dev": true, + "requires": { + "@jest/types": "^29.5.0", + "@types/graceful-fs": "^4.1.3", + "@types/node": "*", + "anymatch": "^3.0.3", + "fb-watchman": "^2.0.0", + "fsevents": "^2.3.2", + "graceful-fs": "^4.2.9", + "jest-regex-util": "^29.4.3", + "jest-util": "^29.5.0", + "jest-worker": "^29.5.0", + "micromatch": "^4.0.4", + "walker": "^1.0.8" + } + }, + "jest-junit": { + "version": "15.0.0", + "resolved": "https://registry.npmjs.org/jest-junit/-/jest-junit-15.0.0.tgz", + "integrity": "sha512-Z5sVX0Ag3HZdMUnD5DFlG+1gciIFSy7yIVPhOdGUi8YJaI9iLvvBb530gtQL2CHmv0JJeiwRZenr0VrSR7frvg==", + "dev": true, + "requires": { + "mkdirp": "^1.0.4", + "strip-ansi": "^6.0.1", + "uuid": "^8.3.2", + "xml": "^1.0.1" + } + }, + "jest-leak-detector": { + "version": "29.5.0", + "resolved": "https://registry.npmjs.org/jest-leak-detector/-/jest-leak-detector-29.5.0.tgz", + "integrity": "sha512-u9YdeeVnghBUtpN5mVxjID7KbkKE1QU4f6uUwuxiY0vYRi9BUCLKlPEZfDGR67ofdFmDz9oPAy2G92Ujrntmow==", + "dev": true, + "requires": { + "jest-get-type": "^29.4.3", + "pretty-format": "^29.5.0" + } + }, + "jest-matcher-utils": { + "version": "29.5.0", + "resolved": "https://registry.npmjs.org/jest-matcher-utils/-/jest-matcher-utils-29.5.0.tgz", + "integrity": "sha512-lecRtgm/rjIK0CQ7LPQwzCs2VwW6WAahA55YBuI+xqmhm7LAaxokSB8C97yJeYyT+HvQkH741StzpU41wohhWw==", + "dev": true, + "requires": { + "chalk": "^4.0.0", + "jest-diff": "^29.5.0", + "jest-get-type": "^29.4.3", + "pretty-format": "^29.5.0" + } + }, + "jest-message-util": { + "version": "29.5.0", + "resolved": "https://registry.npmjs.org/jest-message-util/-/jest-message-util-29.5.0.tgz", + "integrity": "sha512-Kijeg9Dag6CKtIDA7O21zNTACqD5MD/8HfIV8pdD94vFyFuer52SigdC3IQMhab3vACxXMiFk+yMHNdbqtyTGA==", + "dev": true, + "requires": { + "@babel/code-frame": "^7.12.13", + "@jest/types": "^29.5.0", + "@types/stack-utils": "^2.0.0", + "chalk": "^4.0.0", + "graceful-fs": "^4.2.9", + "micromatch": "^4.0.4", + "pretty-format": "^29.5.0", + "slash": "^3.0.0", + "stack-utils": "^2.0.3" + } + }, + "jest-mock": { + "version": "29.5.0", + "resolved": "https://registry.npmjs.org/jest-mock/-/jest-mock-29.5.0.tgz", + "integrity": "sha512-GqOzvdWDE4fAV2bWQLQCkujxYWL7RxjCnj71b5VhDAGOevB3qj3Ovg26A5NI84ZpODxyzaozXLOh2NCgkbvyaw==", + "dev": true, + "requires": { + "@jest/types": "^29.5.0", + "@types/node": "*", + "jest-util": "^29.5.0" + } + }, + "jest-pnp-resolver": { + "version": "1.2.3", + "resolved": "https://registry.npmjs.org/jest-pnp-resolver/-/jest-pnp-resolver-1.2.3.tgz", + "integrity": "sha512-+3NpwQEnRoIBtx4fyhblQDPgJI0H1IEIkX7ShLUjPGA7TtUTvI1oiKi3SR4oBR0hQhQR80l4WAe5RrXBwWMA8w==", + "dev": true, + "requires": {} + }, + "jest-regex-util": { + "version": "29.4.3", + "resolved": "https://registry.npmjs.org/jest-regex-util/-/jest-regex-util-29.4.3.tgz", + "integrity": "sha512-O4FglZaMmWXbGHSQInfXewIsd1LMn9p3ZXB/6r4FOkyhX2/iP/soMG98jGvk/A3HAN78+5VWcBGO0BJAPRh4kg==", + "dev": true + }, + "jest-resolve": { + "version": "29.5.0", + "resolved": "https://registry.npmjs.org/jest-resolve/-/jest-resolve-29.5.0.tgz", + "integrity": "sha512-1TzxJ37FQq7J10jPtQjcc+MkCkE3GBpBecsSUWJ0qZNJpmg6m0D9/7II03yJulm3H/fvVjgqLh/k2eYg+ui52w==", + "dev": true, + "requires": { + "chalk": "^4.0.0", + "graceful-fs": "^4.2.9", + "jest-haste-map": "^29.5.0", + "jest-pnp-resolver": "^1.2.2", + "jest-util": "^29.5.0", + "jest-validate": "^29.5.0", + "resolve": "^1.20.0", + "resolve.exports": "^2.0.0", + "slash": "^3.0.0" + } + }, + "jest-resolve-dependencies": { + "version": "29.5.0", + "resolved": "https://registry.npmjs.org/jest-resolve-dependencies/-/jest-resolve-dependencies-29.5.0.tgz", + "integrity": "sha512-sjV3GFr0hDJMBpYeUuGduP+YeCRbd7S/ck6IvL3kQ9cpySYKqcqhdLLC2rFwrcL7tz5vYibomBrsFYWkIGGjOg==", + "dev": true, + "requires": { + "jest-regex-util": "^29.4.3", + "jest-snapshot": "^29.5.0" + } + }, + "jest-runner": { + "version": "29.5.0", + "resolved": "https://registry.npmjs.org/jest-runner/-/jest-runner-29.5.0.tgz", + "integrity": "sha512-m7b6ypERhFghJsslMLhydaXBiLf7+jXy8FwGRHO3BGV1mcQpPbwiqiKUR2zU2NJuNeMenJmlFZCsIqzJCTeGLQ==", + "dev": true, + "requires": { + "@jest/console": "^29.5.0", + "@jest/environment": "^29.5.0", + "@jest/test-result": "^29.5.0", + "@jest/transform": "^29.5.0", + "@jest/types": "^29.5.0", + "@types/node": "*", + "chalk": "^4.0.0", + "emittery": "^0.13.1", + "graceful-fs": "^4.2.9", + "jest-docblock": "^29.4.3", + "jest-environment-node": "^29.5.0", + "jest-haste-map": "^29.5.0", + "jest-leak-detector": "^29.5.0", + "jest-message-util": "^29.5.0", + "jest-resolve": "^29.5.0", + "jest-runtime": "^29.5.0", + "jest-util": "^29.5.0", + "jest-watcher": "^29.5.0", + "jest-worker": "^29.5.0", + "p-limit": "^3.1.0", + "source-map-support": "0.5.13" + } + }, + "jest-runtime": { + "version": "29.5.0", + "resolved": "https://registry.npmjs.org/jest-runtime/-/jest-runtime-29.5.0.tgz", + "integrity": "sha512-1Hr6Hh7bAgXQP+pln3homOiEZtCDZFqwmle7Ew2j8OlbkIu6uE3Y/etJQG8MLQs3Zy90xrp2C0BRrtPHG4zryw==", + "dev": true, + "requires": { + "@jest/environment": "^29.5.0", + "@jest/fake-timers": "^29.5.0", + "@jest/globals": "^29.5.0", + "@jest/source-map": "^29.4.3", + "@jest/test-result": "^29.5.0", + "@jest/transform": "^29.5.0", + "@jest/types": "^29.5.0", + "@types/node": "*", + "chalk": "^4.0.0", + "cjs-module-lexer": "^1.0.0", + "collect-v8-coverage": "^1.0.0", + "glob": "^7.1.3", + "graceful-fs": "^4.2.9", + "jest-haste-map": "^29.5.0", + "jest-message-util": "^29.5.0", + "jest-mock": "^29.5.0", + "jest-regex-util": "^29.4.3", + "jest-resolve": "^29.5.0", + "jest-snapshot": "^29.5.0", + "jest-util": "^29.5.0", + "slash": "^3.0.0", + "strip-bom": "^4.0.0" + } + }, + "jest-snapshot": { + "version": "29.5.0", + "resolved": "https://registry.npmjs.org/jest-snapshot/-/jest-snapshot-29.5.0.tgz", + "integrity": "sha512-x7Wolra5V0tt3wRs3/ts3S6ciSQVypgGQlJpz2rsdQYoUKxMxPNaoHMGJN6qAuPJqS+2iQ1ZUn5kl7HCyls84g==", + "dev": true, + "requires": { + "@babel/core": "^7.11.6", + "@babel/generator": "^7.7.2", + "@babel/plugin-syntax-jsx": "^7.7.2", + "@babel/plugin-syntax-typescript": "^7.7.2", + "@babel/traverse": "^7.7.2", + "@babel/types": "^7.3.3", + "@jest/expect-utils": "^29.5.0", + "@jest/transform": "^29.5.0", + "@jest/types": "^29.5.0", + "@types/babel__traverse": "^7.0.6", + "@types/prettier": "^2.1.5", + "babel-preset-current-node-syntax": "^1.0.0", + "chalk": "^4.0.0", + "expect": "^29.5.0", + "graceful-fs": "^4.2.9", + "jest-diff": "^29.5.0", + "jest-get-type": "^29.4.3", + "jest-matcher-utils": "^29.5.0", + "jest-message-util": "^29.5.0", + "jest-util": "^29.5.0", + "natural-compare": "^1.4.0", + "pretty-format": "^29.5.0", + "semver": "^7.3.5" + }, + "dependencies": { + "lru-cache": { + "version": "6.0.0", + "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-6.0.0.tgz", + "integrity": "sha512-Jo6dJ04CmSjuznwJSS3pUeWmd/H0ffTlkXXgwZi+eq1UCmqQwCh+eLsYOYCwY991i2Fah4h1BEMCx4qThGbsiA==", + "dev": true, + "requires": { + "yallist": "^4.0.0" + } + }, + "semver": { + "version": "7.3.8", + "resolved": "https://registry.npmjs.org/semver/-/semver-7.3.8.tgz", + "integrity": "sha512-NB1ctGL5rlHrPJtFDVIVzTyQylMLu9N9VICA6HSFJo8MCGVTMW6gfpicwKmmK/dAjTOrqu5l63JJOpDSrAis3A==", + "dev": true, + "requires": { + "lru-cache": "^6.0.0" + } + }, + "yallist": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/yallist/-/yallist-4.0.0.tgz", + "integrity": "sha512-3wdGidZyq5PB084XLES5TpOSRA3wjXAlIWMhum2kRcv/41Sn2emQ0dycQW4uZXLejwKvg6EsvbdlVL+FYEct7A==", + "dev": true + } + } + }, + "jest-util": { + "version": "29.5.0", + "resolved": "https://registry.npmjs.org/jest-util/-/jest-util-29.5.0.tgz", + "integrity": "sha512-RYMgG/MTadOr5t8KdhejfvUU82MxsCu5MF6KuDUHl+NuwzUt+Sm6jJWxTJVrDR1j5M/gJVCPKQEpWXY+yIQ6lQ==", + "dev": true, + "requires": { + "@jest/types": "^29.5.0", + "@types/node": "*", + "chalk": "^4.0.0", + "ci-info": "^3.2.0", + "graceful-fs": "^4.2.9", + "picomatch": "^2.2.3" + } + }, + "jest-validate": { + "version": "29.5.0", + "resolved": "https://registry.npmjs.org/jest-validate/-/jest-validate-29.5.0.tgz", + "integrity": "sha512-pC26etNIi+y3HV8A+tUGr/lph9B18GnzSRAkPaaZJIE1eFdiYm6/CewuiJQ8/RlfHd1u/8Ioi8/sJ+CmbA+zAQ==", + "dev": true, + "requires": { + "@jest/types": "^29.5.0", + "camelcase": "^6.2.0", + "chalk": "^4.0.0", + "jest-get-type": "^29.4.3", + "leven": "^3.1.0", + "pretty-format": "^29.5.0" + }, + "dependencies": { + "camelcase": { + "version": "6.3.0", + "resolved": "https://registry.npmjs.org/camelcase/-/camelcase-6.3.0.tgz", + "integrity": "sha512-Gmy6FhYlCY7uOElZUSbxo2UCDH8owEk996gkbrpsgGtrJLM3J7jGxl9Ic7Qwwj4ivOE5AWZWRMecDdF7hqGjFA==", + "dev": true + } + } + }, + "jest-watcher": { + "version": "29.5.0", + "resolved": "https://registry.npmjs.org/jest-watcher/-/jest-watcher-29.5.0.tgz", + "integrity": "sha512-KmTojKcapuqYrKDpRwfqcQ3zjMlwu27SYext9pt4GlF5FUgB+7XE1mcCnSm6a4uUpFyQIkb6ZhzZvHl+jiBCiA==", + "dev": true, + "requires": { + "@jest/test-result": "^29.5.0", + "@jest/types": "^29.5.0", + "@types/node": "*", + "ansi-escapes": "^4.2.1", + "chalk": "^4.0.0", + "emittery": "^0.13.1", + "jest-util": "^29.5.0", + "string-length": "^4.0.1" + } + }, + "jest-worker": { + "version": "29.5.0", + "resolved": "https://registry.npmjs.org/jest-worker/-/jest-worker-29.5.0.tgz", + "integrity": "sha512-NcrQnevGoSp4b5kg+akIpthoAFHxPBcb5P6mYPY0fUNT+sSvmtu6jlkEle3anczUKIKEbMxFimk9oTP/tpIPgA==", + "dev": true, + "requires": { + "@types/node": "*", + "jest-util": "^29.5.0", + "merge-stream": "^2.0.0", + "supports-color": "^8.0.0" + }, + "dependencies": { + "supports-color": { + "version": "8.1.1", + "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-8.1.1.tgz", + "integrity": "sha512-MpUEN2OodtUzxvKQl72cUF7RQ5EiHsGvSsVG0ia9c5RbWGL2CI4C7EpPS8UTBIplnlzZiNuV56w+FuNxy3ty2Q==", + "dev": true, + "requires": { + "has-flag": "^4.0.0" + } + } + } + }, + "js-sdsl": { + "version": "4.3.0", + "resolved": "https://registry.npmjs.org/js-sdsl/-/js-sdsl-4.3.0.tgz", + "integrity": "sha512-mifzlm2+5nZ+lEcLJMoBK0/IH/bDg8XnJfd/Wq6IP+xoCjLZsTOnV2QpxlVbX9bMnkl5PdEjNtBJ9Cj1NjifhQ==", + "dev": true + }, + "js-tokens": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/js-tokens/-/js-tokens-4.0.0.tgz", + "integrity": "sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ==", + "dev": true + }, + "js-yaml": { + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-4.1.0.tgz", + "integrity": "sha512-wpxZs9NoxZaJESJGIZTyDEaYpl0FKSA+FB9aJiyemKhMwkxQg63h4T1KJgUGHpTqPDNRcmmYLugrRjJlBtWvRA==", + "dev": true, + "requires": { + "argparse": "^2.0.1" + } + }, + "jsesc": { + "version": "2.5.2", + "resolved": "https://registry.npmjs.org/jsesc/-/jsesc-2.5.2.tgz", + "integrity": "sha512-OYu7XEzjkCQ3C5Ps3QIZsQfNpqoJyZZA99wd9aWd05NCtC5pWOkShK2mkL6HXQR6/Cy2lbNdPlZBpuQHXE63gA==", + "dev": true + }, + "json-diff": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/json-diff/-/json-diff-1.0.3.tgz", + "integrity": "sha512-W0yk/xzjz7bag9v9eS4qthvPG4O07uxNeXwirhvcOqmX4w8HLtB/Pw76o5Z7Pblwvf4vpCi4+iHOlHDnmav/rA==", + "dev": true, + "requires": { + "@ewoudenberg/difflib": "0.1.0", + "colors": "^1.4.0", + "dreamopt": "~0.8.0" + } + }, + "json-parse-even-better-errors": { + "version": "2.3.1", + "resolved": "https://registry.npmjs.org/json-parse-even-better-errors/-/json-parse-even-better-errors-2.3.1.tgz", + "integrity": "sha512-xyFwyhro/JEof6Ghe2iz2NcXoj2sloNsWr/XsERDK/oiPCfaNhl5ONfp+jQdAZRQQ0IJWNzH9zIZF7li91kh2w==", + "dev": true + }, + "json-schema-traverse": { + "version": "0.4.1", + "resolved": "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-0.4.1.tgz", + "integrity": "sha512-xbbCH5dCYU5T8LcEhhuh7HJ88HXuW3qsI3Y0zOZFKfZEHcpWiHU/Jxzk629Brsab/mMiHQti9wMP+845RPe3Vg==", + "dev": true + }, + "json-stable-stringify-without-jsonify": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/json-stable-stringify-without-jsonify/-/json-stable-stringify-without-jsonify-1.0.1.tgz", + "integrity": "sha512-Bdboy+l7tA3OGW6FjyFHWkP5LuByj1Tk33Ljyq0axyzdk9//JSi2u3fP1QSmd1KNwq6VOKYGlAu87CisVir6Pw==", + "dev": true + }, + "json-stringify-safe": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/json-stringify-safe/-/json-stringify-safe-5.0.1.tgz", + "integrity": "sha512-ZClg6AaYvamvYEE82d3Iyd3vSSIjQ+odgjaTzRuO3s7toCdFKczob2i0zCh7JE8kWn17yvAWhUVxvqGwUalsRA==", + "dev": true + }, + "json5": { + "version": "2.2.3", + "resolved": "https://registry.npmjs.org/json5/-/json5-2.2.3.tgz", + "integrity": "sha512-XmOWe7eyHYH14cLdVPoyg+GOH3rYX++KpzrylJwSW98t3Nk+U8XOl8FWKOgwtzdb8lXGf6zYwDUzeHMWfxasyg==", + "dev": true + }, + "kleur": { + "version": "3.0.3", + "resolved": "https://registry.npmjs.org/kleur/-/kleur-3.0.3.tgz", + "integrity": "sha512-eTIzlVOSUR+JxdDFepEYcBMtZ9Qqdef+rnzWdRZuMbOywu5tO2w2N7rqjoANZ5k9vywhL6Br1VRjUIgTQx4E8w==", + "dev": true + }, + "leven": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/leven/-/leven-3.1.0.tgz", + "integrity": "sha512-qsda+H8jTaUaN/x5vzW2rzc+8Rw4TAQ/4KjB46IwK5VH+IlVeeeje/EoZRpiXvIqjFgK84QffqPztGI3VBLG1A==", + "dev": true + }, + "levn": { + "version": "0.4.1", + "resolved": "https://registry.npmjs.org/levn/-/levn-0.4.1.tgz", + "integrity": "sha512-+bT2uH4E5LGE7h/n3evcS/sQlJXCpIp6ym8OWJ5eV6+67Dsql/LaaT7qJBAt2rzfoa/5QBGBhxDix1dMt2kQKQ==", + "dev": true, + "requires": { + "prelude-ls": "^1.2.1", + "type-check": "~0.4.0" + } + }, + "libxmljs": { + "version": "0.19.10", + "resolved": "https://registry.npmjs.org/libxmljs/-/libxmljs-0.19.10.tgz", + "integrity": "sha512-RY5/MD8Po8sGVocbODbYcdrbP6pJyA171LjFyd7Bp9wwxhmA8C5bm/VmXfpdED07fdW0FeC3lopxhG7UbwGx+g==", + "requires": { + "@mapbox/node-pre-gyp": "^1.0.9", + "bindings": "~1.3.0", + "nan": "~2.14.0" + } + }, + "lines-and-columns": { + "version": "1.2.4", + "resolved": "https://registry.npmjs.org/lines-and-columns/-/lines-and-columns-1.2.4.tgz", + "integrity": "sha512-7ylylesZQ/PV29jhEDl3Ufjo6ZX7gCqJr5F7PKrqc93v7fzSymt1BpwEU8nAUXs8qzzvqhbjhK5QZg6Mt/HkBg==", + "dev": true + }, + "locate-path": { + "version": "6.0.0", + "resolved": "https://registry.npmjs.org/locate-path/-/locate-path-6.0.0.tgz", + "integrity": "sha512-iPZK6eYjbxRu3uB4/WZ3EsEIMJFMqAoopl3R+zuq0UjcAm/MO6KCweDgPfP3elTztoKP3KtnVHxTn2NHBSDVUw==", + "dev": true, + "requires": { + "p-locate": "^5.0.0" + } + }, + "lodash": { + "version": "4.17.21", + "resolved": "https://registry.npmjs.org/lodash/-/lodash-4.17.21.tgz", + "integrity": "sha512-v2kDEe57lecTulaDIuNTPy3Ry4gLGJ6Z1O3vE1krgXZNrsQ+LFTGHVxVjcXPs17LhbZVGedAJv8XZ1tvj5FvSg==", + "dev": true + }, + "lodash.escape": { + "version": "4.0.1", + "resolved": "https://registry.npmjs.org/lodash.escape/-/lodash.escape-4.0.1.tgz", + "integrity": "sha512-nXEOnb/jK9g0DYMr1/Xvq6l5xMD7GDG55+GSYIYmS0G4tBk/hURD4JR9WCavs04t33WmJx9kCyp9vJ+mr4BOUw==", + "dev": true + }, + "lodash.flattendeep": { + "version": "4.4.0", + "resolved": "https://registry.npmjs.org/lodash.flattendeep/-/lodash.flattendeep-4.4.0.tgz", + "integrity": "sha512-uHaJFihxmJcEX3kT4I23ABqKKalJ/zDrDg0lsFtc1h+3uw49SIJ5beyhx5ExVRti3AvKoOJngIj7xz3oylPdWQ==", + "dev": true + }, + "lodash.isequal": { + "version": "4.5.0", + "resolved": "https://registry.npmjs.org/lodash.isequal/-/lodash.isequal-4.5.0.tgz", + "integrity": "sha512-pDo3lu8Jhfjqls6GkMgpahsF9kCyayhgykjyLMNFTKWrpVdAQtYyB4muAMWozBB4ig/dtWAmsMxLEI8wuz+DYQ==", + "dev": true + }, + "lodash.merge": { + "version": "4.6.2", + "resolved": "https://registry.npmjs.org/lodash.merge/-/lodash.merge-4.6.2.tgz", + "integrity": "sha512-0KpjqXRVvrYyCsX1swR/XTK0va6VQkQM6MNo7PqW77ByjAhoARA8EfrP1N4+KlKj8YS0ZUCtRT/YUuhyYDujIQ==", + "dev": true + }, + "lru-cache": { + "version": "5.1.1", + "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-5.1.1.tgz", + "integrity": "sha512-KpNARQA3Iwv+jTA0utUVVbrh+Jlrr1Fv0e56GGzAFOXN7dk/FviaDW8LHmK52DlcH4WP2n6gI8vN1aesBFgo9w==", + "dev": true, + "requires": { + "yallist": "^3.0.2" + } + }, + "make-dir": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/make-dir/-/make-dir-3.1.0.tgz", + "integrity": "sha512-g3FeP20LNwhALb/6Cz6Dd4F2ngze0jz7tbzrD2wAV+o9FeNHe4rL+yK2md0J/fiSf1sa1ADhXqi5+oVwOM/eGw==", + "requires": { + "semver": "^6.0.0" + } + }, + "makeerror": { + "version": "1.0.12", + "resolved": "https://registry.npmjs.org/makeerror/-/makeerror-1.0.12.tgz", + "integrity": "sha512-JmqCvUhmt43madlpFzG4BQzG2Z3m6tvQDNKdClZnO3VbIudJYmxsT0FNJMeiB2+JTSlTQTSbU8QdesVmwJcmLg==", + "dev": true, + "requires": { + "tmpl": "1.0.5" + } + }, + "merge-stream": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/merge-stream/-/merge-stream-2.0.0.tgz", + "integrity": "sha512-abv/qOcuPfk3URPfDzmZU1LKmuw8kT+0nIHvKrKgFrwifol/doWcdA4ZqsWQ8ENrFKkd67Mfpo/LovbIUsbt3w==", + "dev": true + }, + "micromatch": { + "version": "4.0.5", + "resolved": "https://registry.npmjs.org/micromatch/-/micromatch-4.0.5.tgz", + "integrity": "sha512-DMy+ERcEW2q8Z2Po+WNXuw3c5YaUSFjAO5GsJqfEl7UjvtIuFKO6ZrKvcItdy98dwFI2N1tg3zNIdKaQT+aNdA==", + "dev": true, + "requires": { + "braces": "^3.0.2", + "picomatch": "^2.3.1" + } + }, + "mimic-fn": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/mimic-fn/-/mimic-fn-2.1.0.tgz", + "integrity": "sha512-OqbOk5oEQeAZ8WXWydlu9HJjz9WVdEIvamMCcXmuqUYjTknH/sqsWvhQ3vgwKFRR1HpjvNBKQ37nbJgYzGqGcg==", + "dev": true + }, + "minimatch": { + "version": "3.1.2", + "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.2.tgz", + "integrity": "sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==", + "requires": { + "brace-expansion": "^1.1.7" + } + }, + "minipass": { + "version": "4.2.4", + "resolved": "https://registry.npmjs.org/minipass/-/minipass-4.2.4.tgz", + "integrity": "sha512-lwycX3cBMTvcejsHITUgYj6Gy6A7Nh4Q6h9NP4sTHY1ccJlC7yKzDmiShEHsJ16Jf1nKGDEaiHxiltsJEvk0nQ==" + }, + "minizlib": { + "version": "2.1.2", + "resolved": "https://registry.npmjs.org/minizlib/-/minizlib-2.1.2.tgz", + "integrity": "sha512-bAxsR8BVfj60DWXHE3u30oHzfl4G7khkSuPW+qvpd7jFRHm7dLxOjUk1EHACJ/hxLY8phGJ0YhYHZo7jil7Qdg==", + "requires": { + "minipass": "^3.0.0", + "yallist": "^4.0.0" + }, + "dependencies": { + "minipass": { + "version": "3.3.6", + "resolved": "https://registry.npmjs.org/minipass/-/minipass-3.3.6.tgz", + "integrity": "sha512-DxiNidxSEK+tHG6zOIklvNOwm3hvCrbUrdtzY74U6HKTJxvIDfOUL5W5P2Ghd3DTkhhKPYGqeNUIh5qcM4YBfw==", + "requires": { + "yallist": "^4.0.0" + } + }, + "yallist": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/yallist/-/yallist-4.0.0.tgz", + "integrity": "sha512-3wdGidZyq5PB084XLES5TpOSRA3wjXAlIWMhum2kRcv/41Sn2emQ0dycQW4uZXLejwKvg6EsvbdlVL+FYEct7A==" + } + } + }, + "mkdirp": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/mkdirp/-/mkdirp-1.0.4.tgz", + "integrity": "sha512-vVqVZQyf3WLx2Shd0qJ9xuvqgAyKPLAiqITEtqW0oIUjzo3PePDd6fW9iFz30ef7Ysp/oiWqbhszeGWW2T6Gzw==" + }, + "moo": { + "version": "0.5.2", + "resolved": "https://registry.npmjs.org/moo/-/moo-0.5.2.tgz", + "integrity": "sha512-iSAJLHYKnX41mKcJKjqvnAN9sf0LMDTXDEvFv+ffuRR9a1MIuXLjMNL6EsnDHSkKLTWNqQQ5uo61P4EbU4NU+Q==", + "dev": true + }, + "ms": { + "version": "2.1.2", + "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.2.tgz", + "integrity": "sha512-sGkPx+VjMtmA6MX27oA4FBFELFCZZ4S4XqeGOXCv68tT+jb3vk/RyaKWP0PTKyWtmLSM0b+adUTEvbs1PEaH2w==" + }, + "nan": { + "version": "2.14.2", + "resolved": "https://registry.npmjs.org/nan/-/nan-2.14.2.tgz", + "integrity": "sha512-M2ufzIiINKCuDfBSAUr1vWQ+vuVcA9kqx8JJUsbQi6yf1uGRyb7HfpdfUr5qLXf3B/t8dPvcjhKMmlfnP47EzQ==" + }, + "natural-compare": { + "version": "1.4.0", + "resolved": "https://registry.npmjs.org/natural-compare/-/natural-compare-1.4.0.tgz", + "integrity": "sha512-OWND8ei3VtNC9h7V60qff3SVobHr996CTwgxubgyQYEpg290h9J0buyECNNJexkFm5sOajh5G116RYA1c8ZMSw==", + "dev": true + }, + "nearley": { + "version": "2.20.1", + "resolved": "https://registry.npmjs.org/nearley/-/nearley-2.20.1.tgz", + "integrity": "sha512-+Mc8UaAebFzgV+KpI5n7DasuuQCHA89dmwm7JXw3TV43ukfNQ9DnBH3Mdb2g/I4Fdxc26pwimBWvjIw0UAILSQ==", + "dev": true, + "requires": { + "commander": "^2.19.0", + "moo": "^0.5.0", + "railroad-diagrams": "^1.0.0", + "randexp": "0.4.6" + } + }, + "nock": { + "version": "13.3.0", + "resolved": "https://registry.npmjs.org/nock/-/nock-13.3.0.tgz", + "integrity": "sha512-HHqYQ6mBeiMc+N038w8LkMpDCRquCHWeNmN3v6645P3NhN2+qXOBqvPqo7Rt1VyCMzKhJ733wZqw5B7cQVFNPg==", + "dev": true, + "requires": { + "debug": "^4.1.0", + "json-stringify-safe": "^5.0.1", + "lodash": "^4.17.21", + "propagate": "^2.0.0" + } + }, + "node-fetch": { + "version": "2.6.9", + "resolved": "https://registry.npmjs.org/node-fetch/-/node-fetch-2.6.9.tgz", + "integrity": "sha512-DJm/CJkZkRjKKj4Zi4BsKVZh3ValV5IR5s7LVZnW+6YMh0W1BfNA8XSs6DLMGYlId5F3KnA70uu2qepcR08Qqg==", + "requires": { + "whatwg-url": "^5.0.0" + } + }, + "node-int64": { + "version": "0.4.0", + "resolved": "https://registry.npmjs.org/node-int64/-/node-int64-0.4.0.tgz", + "integrity": "sha512-O5lz91xSOeoXP6DulyHfllpq+Eg00MWitZIbtPfoSEvqIHdl5gfcY6hYzDWnj0qD5tz52PI08u9qUvSVeUBeHw==", + "dev": true + }, + "node-releases": { + "version": "2.0.10", + "resolved": "https://registry.npmjs.org/node-releases/-/node-releases-2.0.10.tgz", + "integrity": "sha512-5GFldHPXVG/YZmFzJvKK2zDSzPKhEp0+ZR5SVaoSag9fsL5YgHbUHDfnG5494ISANDcK4KwPXAx2xqVEydmd7w==", + "dev": true + }, + "nopt": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/nopt/-/nopt-5.0.0.tgz", + "integrity": "sha512-Tbj67rffqceeLpcRXrT7vKAN8CwfPeIBgM7E6iBkmKLV7bEMwpGgYLGv0jACUsECaa/vuxP0IjEont6umdMgtQ==", + "requires": { + "abbrev": "1" + } + }, + "normalize-path": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/normalize-path/-/normalize-path-3.0.0.tgz", + "integrity": "sha512-6eZs5Ls3WtCisHWp9S2GUy8dqkpGi4BVSz3GaqiE6ezub0512ESztXUwUB6C6IKbQkY2Pnb/mD4WYojCRwcwLA==", + "dev": true + }, + "npm-run-path": { + "version": "4.0.1", + "resolved": "https://registry.npmjs.org/npm-run-path/-/npm-run-path-4.0.1.tgz", + "integrity": "sha512-S48WzZW777zhNIrn7gxOlISNAqi9ZC/uQFnRdbeIHhZhCA6UqpkOT8T1G7BvfdgP4Er8gF4sUbaS0i7QvIfCWw==", + "dev": true, + "requires": { + "path-key": "^3.0.0" + } + }, + "npmlog": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/npmlog/-/npmlog-5.0.1.tgz", + "integrity": "sha512-AqZtDUWOMKs1G/8lwylVjrdYgqA4d9nu8hc+0gzRxlDb1I10+FHBGMXs6aiQHFdCUUlqH99MUMuLfzWDNDtfxw==", + "requires": { + "are-we-there-yet": "^2.0.0", + "console-control-strings": "^1.1.0", + "gauge": "^3.0.0", + "set-blocking": "^2.0.0" + } + }, + "nth-check": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/nth-check/-/nth-check-2.1.1.tgz", + "integrity": "sha512-lqjrjmaOoAnWfMmBPL+XNnynZh2+swxiX3WUE0s4yEHI6m+AwrK2UZOimIRl3X/4QctVqS8AiZjFqyOGrMXb/w==", + "dev": true, + "requires": { + "boolbase": "^1.0.0" + } + }, + "object-assign": { + "version": "4.1.1", + "resolved": "https://registry.npmjs.org/object-assign/-/object-assign-4.1.1.tgz", + "integrity": "sha512-rJgTQnkUnH1sFw8yT6VSU3zD3sWmu6sZhIseY8VX+GRu3P6F7Fu+JNDoXfklElbLJSnc3FUQHVe4cU5hj+BcUg==" + }, + "object-inspect": { + "version": "1.12.3", + "resolved": "https://registry.npmjs.org/object-inspect/-/object-inspect-1.12.3.tgz", + "integrity": "sha512-geUvdk7c+eizMNUDkRpW1wJwgfOiOeHbxBR/hLXK1aT6zmVSO0jsQcs7fj6MGw89jC/cjGfLcNOrtMYtGqm81g==", + "dev": true + }, + "object-is": { + "version": "1.1.5", + "resolved": "https://registry.npmjs.org/object-is/-/object-is-1.1.5.tgz", + "integrity": "sha512-3cyDsyHgtmi7I7DfSSI2LDp6SK2lwvtbg0p0R1e0RvTqF5ceGx+K2dfSjm1bKDMVCFEDAQvy+o8c6a7VujOddw==", + "dev": true, + "requires": { + "call-bind": "^1.0.2", + "define-properties": "^1.1.3" + } + }, + "object-keys": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/object-keys/-/object-keys-1.1.1.tgz", + "integrity": "sha512-NuAESUOUMrlIXOfHKzD6bpPu3tYt3xvjNdRIQ+FeT0lNb4K8WR70CaDxhuNguS2XG+GjkyMwOzsN5ZktImfhLA==", + "dev": true + }, + "object.assign": { + "version": "4.1.4", + "resolved": "https://registry.npmjs.org/object.assign/-/object.assign-4.1.4.tgz", + "integrity": "sha512-1mxKf0e58bvyjSCtKYY4sRe9itRk3PJpquJOjeIkz885CczcI4IvJJDLPS72oowuSh+pBxUFROpX+TU++hxhZQ==", + "dev": true, + "requires": { + "call-bind": "^1.0.2", + "define-properties": "^1.1.4", + "has-symbols": "^1.0.3", + "object-keys": "^1.1.1" + } + }, + "object.entries": { + "version": "1.1.6", + "resolved": "https://registry.npmjs.org/object.entries/-/object.entries-1.1.6.tgz", + "integrity": "sha512-leTPzo4Zvg3pmbQ3rDK69Rl8GQvIqMWubrkxONG9/ojtFE2rD9fjMKfSI5BxW3osRH1m6VdzmqK8oAY9aT4x5w==", + "dev": true, + "requires": { + "call-bind": "^1.0.2", + "define-properties": "^1.1.4", + "es-abstract": "^1.20.4" + } + }, + "object.values": { + "version": "1.1.6", + "resolved": "https://registry.npmjs.org/object.values/-/object.values-1.1.6.tgz", + "integrity": "sha512-FVVTkD1vENCsAcwNs9k6jea2uHC/X0+JcjG8YA60FN5CMaJmG95wT9jek/xX9nornqGRrBkKtzuAu2wuHpKqvw==", + "dev": true, + "requires": { + "call-bind": "^1.0.2", + "define-properties": "^1.1.4", + "es-abstract": "^1.20.4" + } + }, + "once": { + "version": "1.4.0", + "resolved": "https://registry.npmjs.org/once/-/once-1.4.0.tgz", + "integrity": "sha512-lNaJgI+2Q5URQBkccEKHTQOPaXdUxnZZElQTZY0MFUAuaEqe1E+Nyvgdz/aIyNi6Z9MzO5dv1H8n58/GELp3+w==", + "requires": { + "wrappy": "1" + } + }, + "onetime": { + "version": "5.1.2", + "resolved": "https://registry.npmjs.org/onetime/-/onetime-5.1.2.tgz", + "integrity": "sha512-kbpaSSGJTWdAY5KPVeMOKXSrPtr8C8C7wodJbcsd51jRnmD+GZu8Y0VoU6Dm5Z4vWr0Ig/1NKuWRKf7j5aaYSg==", + "dev": true, + "requires": { + "mimic-fn": "^2.1.0" + } + }, + "optionator": { + "version": "0.9.1", + "resolved": "https://registry.npmjs.org/optionator/-/optionator-0.9.1.tgz", + "integrity": "sha512-74RlY5FCnhq4jRxVUPKDaRwrVNXMqsGsiW6AJw4XK8hmtm10wC0ypZBLw5IIp85NZMr91+qd1RvvENwg7jjRFw==", + "dev": true, + "requires": { + "deep-is": "^0.1.3", + "fast-levenshtein": "^2.0.6", + "levn": "^0.4.1", + "prelude-ls": "^1.2.1", + "type-check": "^0.4.0", + "word-wrap": "^1.2.3" + } + }, + "p-limit": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/p-limit/-/p-limit-3.1.0.tgz", + "integrity": "sha512-TYOanM3wGwNGsZN2cVTYPArw454xnXj5qmWF1bEoAc4+cU/ol7GVh7odevjp1FNHduHc3KZMcFduxU5Xc6uJRQ==", + "dev": true, + "requires": { + "yocto-queue": "^0.1.0" + } + }, + "p-locate": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/p-locate/-/p-locate-5.0.0.tgz", + "integrity": "sha512-LaNjtRWUBY++zB5nE/NwcaoMylSPk+S+ZHNB1TzdbMJMny6dynpAGt7X/tl/QYq3TIeE6nxHppbo2LGymrG5Pw==", + "dev": true, + "requires": { + "p-limit": "^3.0.2" + } + }, + "p-try": { + "version": "2.2.0", + "resolved": "https://registry.npmjs.org/p-try/-/p-try-2.2.0.tgz", + "integrity": "sha512-R4nPAVTAU0B9D35/Gk3uJf/7XYbQcyohSKdvAxIRSNghFl4e71hVoGnBNQz9cWaXxO2I10KTC+3jMdvvoKw6dQ==", + "dev": true + }, + "parent-module": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/parent-module/-/parent-module-1.0.1.tgz", + "integrity": "sha512-GQ2EWRpQV8/o+Aw8YqtfZZPfNRWZYkbidE9k5rpl/hC3vtHHBfGm2Ifi6qWV+coDGkrUKZAxE3Lot5kcsRlh+g==", + "dev": true, + "requires": { + "callsites": "^3.0.0" + } + }, + "parse-json": { + "version": "5.2.0", + "resolved": "https://registry.npmjs.org/parse-json/-/parse-json-5.2.0.tgz", + "integrity": "sha512-ayCKvm/phCGxOkYRSCM82iDwct8/EonSEgCSxWxD7ve6jHggsFl4fZVQBPRNgQoKiuV/odhFrGzQXZwbifC8Rg==", + "dev": true, + "requires": { + "@babel/code-frame": "^7.0.0", + "error-ex": "^1.3.1", + "json-parse-even-better-errors": "^2.3.0", + "lines-and-columns": "^1.1.6" + } + }, + "parse5": { + "version": "7.1.2", + "resolved": "https://registry.npmjs.org/parse5/-/parse5-7.1.2.tgz", + "integrity": "sha512-Czj1WaSVpaoj0wbhMzLmWD69anp2WH7FXMB9n1Sy8/ZFF9jolSQVMu1Ij5WIyGmcBmhk7EOndpO4mIpihVqAXw==", + "dev": true, + "requires": { + "entities": "^4.4.0" + } + }, + "parse5-htmlparser2-tree-adapter": { + "version": "7.0.0", + "resolved": "https://registry.npmjs.org/parse5-htmlparser2-tree-adapter/-/parse5-htmlparser2-tree-adapter-7.0.0.tgz", + "integrity": "sha512-B77tOZrqqfUfnVcOrUvfdLbz4pu4RopLD/4vmu3HUPswwTA8OH0EMW9BlWR2B0RCoiZRAHEUu7IxeP1Pd1UU+g==", + "dev": true, + "requires": { + "domhandler": "^5.0.2", + "parse5": "^7.0.0" + } + }, + "path-exists": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/path-exists/-/path-exists-4.0.0.tgz", + "integrity": "sha512-ak9Qy5Q7jYb2Wwcey5Fpvg2KoAc/ZIhLSLOSBmRmygPsGwkVVt0fZa0qrtMz+m6tJTAHfZQ8FnmB4MG4LWy7/w==", + "dev": true + }, + "path-is-absolute": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/path-is-absolute/-/path-is-absolute-1.0.1.tgz", + "integrity": "sha512-AVbw3UJ2e9bq64vSaS9Am0fje1Pa8pbGqTTsmXfaIiMpnr5DlDhfJOuLj9Sf95ZPVDAUerDfEk88MPmPe7UCQg==" + }, + "path-key": { + "version": "3.1.1", + "resolved": "https://registry.npmjs.org/path-key/-/path-key-3.1.1.tgz", + "integrity": "sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q==", + "dev": true + }, + "path-parse": { + "version": "1.0.7", + "resolved": "https://registry.npmjs.org/path-parse/-/path-parse-1.0.7.tgz", + "integrity": "sha512-LDJzPVEEEPR+y48z93A0Ed0yXb8pAByGWo/k5YYdYgpY2/2EsOsksJrq7lOHxryrVOn1ejG6oAp8ahvOIQD8sw==", + "dev": true + }, + "performance-now": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/performance-now/-/performance-now-2.1.0.tgz", + "integrity": "sha512-7EAHlyLHI56VEIdK57uwHdHKIaAGbnXPiw0yWbarQZOKaKpvUIgW0jWRVLiatnM+XXlSwsanIBH/hzGMJulMow==", + "dev": true + }, + "picocolors": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/picocolors/-/picocolors-1.0.0.tgz", + "integrity": "sha512-1fygroTLlHu66zi26VoTDv8yRgm0Fccecssto+MhsZ0D/DGW2sm8E8AjW7NU5VVTRt5GxbeZ5qBuJr+HyLYkjQ==", + "dev": true + }, + "picomatch": { + "version": "2.3.1", + "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-2.3.1.tgz", + "integrity": "sha512-JU3teHTNjmE2VCGFzuY8EXzCDVwEqB2a8fsIvwaStHhAWJEeVd1o1QD80CU6+ZdEXXSLbSsuLwJjkCBWqRQUVA==", + "dev": true + }, + "pirates": { + "version": "4.0.5", + "resolved": "https://registry.npmjs.org/pirates/-/pirates-4.0.5.tgz", + "integrity": "sha512-8V9+HQPupnaXMA23c5hvl69zXvTwTzyAYasnkb0Tts4XvO4CliqONMOnvlq26rkhLC3nWDFBJf73LU1e1VZLaQ==", + "dev": true + }, + "pkg-dir": { + "version": "4.2.0", + "resolved": "https://registry.npmjs.org/pkg-dir/-/pkg-dir-4.2.0.tgz", + "integrity": "sha512-HRDzbaKjC+AOWVXxAU/x54COGeIv9eb+6CkDSQoNTt4XyWoIJvuPsXizxu/Fr23EiekbtZwmh1IcIG/l/a10GQ==", + "dev": true, + "requires": { + "find-up": "^4.0.0" + }, + "dependencies": { + "find-up": { + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/find-up/-/find-up-4.1.0.tgz", + "integrity": "sha512-PpOwAdQ/YlXQ2vj8a3h8IipDuYRi3wceVQQGYWxNINccq40Anw7BlsEXCMbt1Zt+OLA6Fq9suIpIWD0OsnISlw==", + "dev": true, + "requires": { + "locate-path": "^5.0.0", + "path-exists": "^4.0.0" + } + }, + "locate-path": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/locate-path/-/locate-path-5.0.0.tgz", + "integrity": "sha512-t7hw9pI+WvuwNJXwk5zVHpyhIqzg2qTlklJOf0mVxGSbe3Fp2VieZcduNYjaLDoy6p9uGpQEGWG87WpMKlNq8g==", + "dev": true, + "requires": { + "p-locate": "^4.1.0" + } + }, + "p-limit": { + "version": "2.3.0", + "resolved": "https://registry.npmjs.org/p-limit/-/p-limit-2.3.0.tgz", + "integrity": "sha512-//88mFWSJx8lxCzwdAABTJL2MyWB12+eIY7MDL2SqLmAkeKU9qxRvWuSyTjm3FUmpBEMuFfckAIqEaVGUDxb6w==", + "dev": true, + "requires": { + "p-try": "^2.0.0" + } + }, + "p-locate": { + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/p-locate/-/p-locate-4.1.0.tgz", + "integrity": "sha512-R79ZZ/0wAxKGu3oYMlz8jy/kbhsNrS7SKZ7PxEHBgJ5+F2mtFW2fK2cOtBh1cHYkQsbzFV7I+EoRKe6Yt0oK7A==", + "dev": true, + "requires": { + "p-limit": "^2.2.0" + } + } + } + }, + "prelude-ls": { + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/prelude-ls/-/prelude-ls-1.2.1.tgz", + "integrity": "sha512-vkcDPrRZo1QZLbn5RLGPpg/WmIQ65qoWWhcGKf/b5eplkkarX0m9z8ppCat4mlOqUsWpyNuYgO3VRyrYHSzX5g==", + "dev": true + }, + "pretty-format": { + "version": "29.5.0", + "resolved": "https://registry.npmjs.org/pretty-format/-/pretty-format-29.5.0.tgz", + "integrity": "sha512-V2mGkI31qdttvTFX7Mt4efOqHXqJWMu4/r66Xh3Z3BwZaPfPJgp6/gbwoujRpPUtfEF6AUUWx3Jim3GCw5g/Qw==", + "dev": true, + "requires": { + "@jest/schemas": "^29.4.3", + "ansi-styles": "^5.0.0", + "react-is": "^18.0.0" + }, + "dependencies": { + "ansi-styles": { + "version": "5.2.0", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-5.2.0.tgz", + "integrity": "sha512-Cxwpt2SfTzTtXcfOlzGEee8O+c+MmUgGrNiBcXnuWxuFJHe6a5Hz7qwhwe5OgaSYI0IJvkLqWX1ASG+cJOkEiA==", + "dev": true + } + } + }, + "prompts": { + "version": "2.4.2", + "resolved": "https://registry.npmjs.org/prompts/-/prompts-2.4.2.tgz", + "integrity": "sha512-NxNv/kLguCA7p3jE8oL2aEBsrJWgAakBpgmgK6lpPWV+WuOmY6r2/zbAVnP+T8bQlA0nzHXSJSJW0Hq7ylaD2Q==", + "dev": true, + "requires": { + "kleur": "^3.0.3", + "sisteransi": "^1.0.5" + } + }, + "propagate": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/propagate/-/propagate-2.0.1.tgz", + "integrity": "sha512-vGrhOavPSTz4QVNuBNdcNXePNdNMaO1xj9yBeH1ScQPjk/rhg9sSlCXPhMkFuaNNW/syTvYqsnbIJxMBfRbbag==", + "dev": true + }, + "punycode": { + "version": "2.3.0", + "resolved": "https://registry.npmjs.org/punycode/-/punycode-2.3.0.tgz", + "integrity": "sha512-rRV+zQD8tVFys26lAGR9WUuS4iUAngJScM+ZRSKtvl5tKeZ2t5bvdNFdNHBW9FWR4guGHlgmsZ1G7BSm2wTbuA==", + "dev": true + }, + "pure-rand": { + "version": "6.0.0", + "resolved": "https://registry.npmjs.org/pure-rand/-/pure-rand-6.0.0.tgz", + "integrity": "sha512-rLSBxJjP+4DQOgcJAx6RZHT2he2pkhQdSnofG5VWyVl6GRq/K02ISOuOLcsMOrtKDIJb8JN2zm3FFzWNbezdPw==", + "dev": true + }, + "queue-microtask": { + "version": "1.2.3", + "resolved": "https://registry.npmjs.org/queue-microtask/-/queue-microtask-1.2.3.tgz", + "integrity": "sha512-NuaNSa6flKT5JaSYQzJok04JzTL1CA6aGhv5rfLW3PgqA+M2ChpZQnAC8h8i4ZFkBS8X5RqkDBHA7r4hej3K9A==", + "dev": true + }, + "raf": { + "version": "3.4.1", + "resolved": "https://registry.npmjs.org/raf/-/raf-3.4.1.tgz", + "integrity": "sha512-Sq4CW4QhwOHE8ucn6J34MqtZCeWFP2aQSmrlroYgqAV1PjStIhJXxYuTgUIfkEk7zTLjmIjLmU5q+fbD1NnOJA==", + "dev": true, + "requires": { + "performance-now": "^2.1.0" + } + }, + "railroad-diagrams": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/railroad-diagrams/-/railroad-diagrams-1.0.0.tgz", + "integrity": "sha512-cz93DjNeLY0idrCNOH6PviZGRN9GJhsdm9hpn1YCS879fj4W+x5IFJhhkRZcwVgMmFF7R82UA/7Oh+R8lLZg6A==", + "dev": true + }, + "randexp": { + "version": "0.4.6", + "resolved": "https://registry.npmjs.org/randexp/-/randexp-0.4.6.tgz", + "integrity": "sha512-80WNmd9DA0tmZrw9qQa62GPPWfuXJknrmVmLcxvq4uZBdYqb1wYoKTmnlGUchvVWe0XiLupYkBoXVOxz3C8DYQ==", + "dev": true, + "requires": { + "discontinuous-range": "1.0.0", + "ret": "~0.1.10" + } + }, + "react-is": { + "version": "18.2.0", + "resolved": "https://registry.npmjs.org/react-is/-/react-is-18.2.0.tgz", + "integrity": "sha512-xWGDIW6x921xtzPkhiULtthJHoJvBbF3q26fzloPCK0hsvxtPVelvftw3zjbHWSkR2km9Z+4uxbDDK/6Zw9B8w==", + "dev": true + }, + "readable-stream": { + "version": "3.6.1", + "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-3.6.1.tgz", + "integrity": "sha512-+rQmrWMYGA90yenhTYsLWAsLsqVC8osOw6PKE1HDYiO0gdPeKe/xDHNzIAIn4C91YQ6oenEhfYqqc1883qHbjQ==", + "requires": { + "inherits": "^2.0.3", + "string_decoder": "^1.1.1", + "util-deprecate": "^1.0.1" + } + }, + "regexp.prototype.flags": { + "version": "1.4.3", + "resolved": "https://registry.npmjs.org/regexp.prototype.flags/-/regexp.prototype.flags-1.4.3.tgz", + "integrity": "sha512-fjggEOO3slI6Wvgjwflkc4NFRCTZAu5CnNfBd5qOMYhWdn67nJBBu34/TkD++eeFmd8C9r9jfXJ27+nSiRkSUA==", + "dev": true, + "requires": { + "call-bind": "^1.0.2", + "define-properties": "^1.1.3", + "functions-have-names": "^1.2.2" + } + }, + "regexpp": { + "version": "3.2.0", + "resolved": "https://registry.npmjs.org/regexpp/-/regexpp-3.2.0.tgz", + "integrity": "sha512-pq2bWo9mVD43nbts2wGv17XLiNLya+GklZ8kaDLV2Z08gDCsGpnKn9BFMepvWuHCbyVvY7J5o5+BVvoQbmlJLg==", + "dev": true + }, + "require-directory": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/require-directory/-/require-directory-2.1.1.tgz", + "integrity": "sha512-fGxEI7+wsG9xrvdjsrlmL22OMTTiHRwAMroiEeMgq8gzoLC/PQr7RsRDSTLUg/bZAZtF+TVIkHc6/4RIKrui+Q==", + "dev": true + }, + "resolve": { + "version": "1.22.1", + "resolved": "https://registry.npmjs.org/resolve/-/resolve-1.22.1.tgz", + "integrity": "sha512-nBpuuYuY5jFsli/JIs1oldw6fOQCBioohqWZg/2hiaOybXOft4lonv85uDOKXdf8rhyK159cxU5cDcK/NKk8zw==", + "dev": true, + "requires": { + "is-core-module": "^2.9.0", + "path-parse": "^1.0.7", + "supports-preserve-symlinks-flag": "^1.0.0" + } + }, + "resolve-cwd": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/resolve-cwd/-/resolve-cwd-3.0.0.tgz", + "integrity": "sha512-OrZaX2Mb+rJCpH/6CpSqt9xFVpN++x01XnN2ie9g6P5/3xelLAkXWVADpdz1IHD/KFfEXyE6V0U01OQ3UO2rEg==", + "dev": true, + "requires": { + "resolve-from": "^5.0.0" + }, + "dependencies": { + "resolve-from": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/resolve-from/-/resolve-from-5.0.0.tgz", + "integrity": "sha512-qYg9KP24dD5qka9J47d0aVky0N+b4fTU89LN9iDnjB5waksiC49rvMB0PrUJQGoTmH50XPiqOvAjDfaijGxYZw==", + "dev": true + } + } + }, + "resolve-from": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/resolve-from/-/resolve-from-4.0.0.tgz", + "integrity": "sha512-pb/MYmXstAkysRFx8piNI1tGFNQIFA3vkE3Gq4EuA1dF6gHp/+vgZqsCGJapvy8N3Q+4o7FwvquPJcnZ7RYy4g==", + "dev": true + }, + "resolve.exports": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/resolve.exports/-/resolve.exports-2.0.1.tgz", + "integrity": "sha512-OEJWVeimw8mgQuj3HfkNl4KqRevH7lzeQNaWRPfx0PPse7Jk6ozcsG4FKVgtzDsC1KUF+YlTHh17NcgHOPykLw==", + "dev": true + }, + "ret": { + "version": "0.1.15", + "resolved": "https://registry.npmjs.org/ret/-/ret-0.1.15.tgz", + "integrity": "sha512-TTlYpa+OL+vMMNG24xSlQGEJ3B/RzEfUlLct7b5G/ytav+wPrplCpVMFuwzXbkecJrb6IYo1iFb0S9v37754mg==", + "dev": true + }, + "reusify": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/reusify/-/reusify-1.0.4.tgz", + "integrity": "sha512-U9nH88a3fc/ekCF1l0/UP1IosiuIjyTh7hBvXVMHYgVcfGvt897Xguj2UOLDeI5BG2m7/uwyaLVT6fbtCwTyzw==", + "dev": true + }, + "rimraf": { + "version": "3.0.2", + "resolved": "https://registry.npmjs.org/rimraf/-/rimraf-3.0.2.tgz", + "integrity": "sha512-JZkJMZkAGFFPP2YqXZXPbMlMBgsxzE8ILs4lMIX/2o0L9UBw9O/Y3o6wFw/i9YLapcUJWwqbi3kdxIPdC62TIA==", + "requires": { + "glob": "^7.1.3" + } + }, + "rst-selector-parser": { + "version": "2.2.3", + "resolved": "https://registry.npmjs.org/rst-selector-parser/-/rst-selector-parser-2.2.3.tgz", + "integrity": "sha512-nDG1rZeP6oFTLN6yNDV/uiAvs1+FS/KlrEwh7+y7dpuApDBy6bI2HTBcc0/V8lv9OTqfyD34eF7au2pm8aBbhA==", + "dev": true, + "requires": { + "lodash.flattendeep": "^4.4.0", + "nearley": "^2.7.10" + } + }, + "run-parallel": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/run-parallel/-/run-parallel-1.2.0.tgz", + "integrity": "sha512-5l4VyZR86LZ/lDxZTR6jqL8AFE2S0IFLMP26AbjsLVADxHdhB/c0GUsH+y39UfCi3dzz8OlQuPmnaJOMoDHQBA==", + "dev": true, + "requires": { + "queue-microtask": "^1.2.2" + } + }, + "safe-buffer": { + "version": "5.2.1", + "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.2.1.tgz", + "integrity": "sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ==" + }, + "safe-regex-test": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/safe-regex-test/-/safe-regex-test-1.0.0.tgz", + "integrity": "sha512-JBUUzyOgEwXQY1NuPtvcj/qcBDbDmEvWufhlnXZIm75DEHp+afM1r1ujJpJsV/gSM4t59tpDyPi1sd6ZaPFfsA==", + "dev": true, + "requires": { + "call-bind": "^1.0.2", + "get-intrinsic": "^1.1.3", + "is-regex": "^1.1.4" + } + }, + "semver": { + "version": "6.3.0", + "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.0.tgz", + "integrity": "sha512-b39TBaTSfV6yBrapU89p5fKekE2m/NwnDocOVruQFS1/veMgdzuPcnOM34M6CwxW8jH/lxEa5rBoDeUwu5HHTw==" + }, + "set-blocking": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/set-blocking/-/set-blocking-2.0.0.tgz", + "integrity": "sha512-KiKBS8AnWGEyLzofFfmvKwpdPzqiy16LvQfK3yv/fVH7Bj13/wl3JSR1J+rfgRE9q7xUJK4qvgS8raSOeLUehw==" + }, + "shebang-command": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/shebang-command/-/shebang-command-2.0.0.tgz", + "integrity": "sha512-kHxr2zZpYtdmrN1qDjrrX/Z1rR1kG8Dx+gkpK1G4eXmvXswmcE1hTWBWYUzlraYw1/yZp6YuDY77YtvbN0dmDA==", + "dev": true, + "requires": { + "shebang-regex": "^3.0.0" + } + }, + "shebang-regex": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/shebang-regex/-/shebang-regex-3.0.0.tgz", + "integrity": "sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A==", + "dev": true + }, + "side-channel": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/side-channel/-/side-channel-1.0.4.tgz", + "integrity": "sha512-q5XPytqFEIKHkGdiMIrY10mvLRvnQh42/+GoBlFW3b2LXLE2xxJpZFdm94we0BaoV3RwJyGqg5wS7epxTv0Zvw==", + "dev": true, + "requires": { + "call-bind": "^1.0.0", + "get-intrinsic": "^1.0.2", + "object-inspect": "^1.9.0" + } + }, + "signal-exit": { + "version": "3.0.7", + "resolved": "https://registry.npmjs.org/signal-exit/-/signal-exit-3.0.7.tgz", + "integrity": "sha512-wnD2ZE+l+SPC/uoS0vXeE9L1+0wuaMqKlfz9AMUo38JsyLSBWSFcHR1Rri62LZc12vLr1gb3jl7iwQhgwpAbGQ==" + }, + "sisteransi": { + "version": "1.0.5", + "resolved": "https://registry.npmjs.org/sisteransi/-/sisteransi-1.0.5.tgz", + "integrity": "sha512-bLGGlR1QxBcynn2d5YmDX4MGjlZvy2MRBDRNHLJ8VI6l6+9FUiyTFNJ0IveOSP0bcXgVDPRcfGqA0pjaqUpfVg==", + "dev": true + }, + "slash": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/slash/-/slash-3.0.0.tgz", + "integrity": "sha512-g9Q1haeby36OSStwb4ntCGGGaKsaVSjQ68fBxoQcutl5fS1vuY18H3wSt3jFyFtrkx+Kz0V1G85A4MyAdDMi2Q==", + "dev": true + }, + "source-map": { + "version": "0.6.1", + "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.6.1.tgz", + "integrity": "sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==", + "dev": true + }, + "source-map-support": { + "version": "0.5.13", + "resolved": "https://registry.npmjs.org/source-map-support/-/source-map-support-0.5.13.tgz", + "integrity": "sha512-SHSKFHadjVA5oR4PPqhtAVdcBWwRYVd6g6cAXnIbRiIwc2EhPrTuKUBdSLvlEKyIP3GCf89fltvcZiP9MMFA1w==", + "dev": true, + "requires": { + "buffer-from": "^1.0.0", + "source-map": "^0.6.0" + } + }, + "sprintf-js": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/sprintf-js/-/sprintf-js-1.0.3.tgz", + "integrity": "sha512-D9cPgkvLlV3t3IzL0D0YLvGA9Ahk4PcvVwUbN0dSGr1aP0Nrt4AEnTUbuGvquEC0mA64Gqt1fzirlRs5ibXx8g==", + "dev": true + }, + "stack-utils": { + "version": "2.0.6", + "resolved": "https://registry.npmjs.org/stack-utils/-/stack-utils-2.0.6.tgz", + "integrity": "sha512-XlkWvfIm6RmsWtNJx+uqtKLS8eqFbxUg0ZzLXqY0caEy9l7hruX8IpiDnjsLavoBgqCCR71TqWO8MaXYheJ3RQ==", + "dev": true, + "requires": { + "escape-string-regexp": "^2.0.0" + }, + "dependencies": { + "escape-string-regexp": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-2.0.0.tgz", + "integrity": "sha512-UpzcLCXolUWcNu5HtVMHYdXJjArjsF9C0aNnquZYY4uW/Vu0miy5YoWvbV345HauVvcAUnpRuhMMcqTcGOY2+w==", + "dev": true + } + } + }, + "string_decoder": { + "version": "1.3.0", + "resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-1.3.0.tgz", + "integrity": "sha512-hkRX8U1WjJFd8LsDJ2yQ/wWWxaopEsABU1XfkM8A+j0+85JAGppt16cr1Whg6KIbb4okU6Mql6BOj+uup/wKeA==", + "requires": { + "safe-buffer": "~5.2.0" + } + }, + "string-length": { + "version": "4.0.2", + "resolved": "https://registry.npmjs.org/string-length/-/string-length-4.0.2.tgz", + "integrity": "sha512-+l6rNN5fYHNhZZy41RXsYptCjA2Igmq4EG7kZAYFQI1E1VTXarr6ZPXBg6eq7Y6eK4FEhY6AJlyuFIb/v/S0VQ==", + "dev": true, + "requires": { + "char-regex": "^1.0.2", + "strip-ansi": "^6.0.0" + } + }, + "string-width": { + "version": "4.2.3", + "resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.3.tgz", + "integrity": "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==", + "requires": { + "emoji-regex": "^8.0.0", + "is-fullwidth-code-point": "^3.0.0", + "strip-ansi": "^6.0.1" + } + }, + "string.prototype.trim": { + "version": "1.2.7", + "resolved": "https://registry.npmjs.org/string.prototype.trim/-/string.prototype.trim-1.2.7.tgz", + "integrity": "sha512-p6TmeT1T3411M8Cgg9wBTMRtY2q9+PNy9EV1i2lIXUN/btt763oIfxwN3RR8VU6wHX8j/1CFy0L+YuThm6bgOg==", + "dev": true, + "requires": { + "call-bind": "^1.0.2", + "define-properties": "^1.1.4", + "es-abstract": "^1.20.4" + } + }, + "string.prototype.trimend": { + "version": "1.0.6", + "resolved": "https://registry.npmjs.org/string.prototype.trimend/-/string.prototype.trimend-1.0.6.tgz", + "integrity": "sha512-JySq+4mrPf9EsDBEDYMOb/lM7XQLulwg5R/m1r0PXEFqrV0qHvl58sdTilSXtKOflCsK2E8jxf+GKC0T07RWwQ==", + "dev": true, + "requires": { + "call-bind": "^1.0.2", + "define-properties": "^1.1.4", + "es-abstract": "^1.20.4" + } + }, + "string.prototype.trimstart": { + "version": "1.0.6", + "resolved": "https://registry.npmjs.org/string.prototype.trimstart/-/string.prototype.trimstart-1.0.6.tgz", + "integrity": "sha512-omqjMDaY92pbn5HOX7f9IccLA+U1tA9GvtU4JrodiXFfYB7jPzzHpRzpglLAjtUV6bB557zwClJezTqnAiYnQA==", + "dev": true, + "requires": { + "call-bind": "^1.0.2", + "define-properties": "^1.1.4", + "es-abstract": "^1.20.4" + } + }, + "strip-ansi": { + "version": "6.0.1", + "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz", + "integrity": "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==", + "requires": { + "ansi-regex": "^5.0.1" + } + }, + "strip-bom": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/strip-bom/-/strip-bom-4.0.0.tgz", + "integrity": "sha512-3xurFv5tEgii33Zi8Jtp55wEIILR9eh34FAW00PZf+JnSsTmV/ioewSgQl97JHvgjoRGwPShsWm+IdrxB35d0w==", + "dev": true + }, + "strip-final-newline": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/strip-final-newline/-/strip-final-newline-2.0.0.tgz", + "integrity": "sha512-BrpvfNAE3dcvq7ll3xVumzjKjZQ5tI1sEUIKr3Uoks0XUl45St3FlatVqef9prk4jRDzhW6WZg+3bk93y6pLjA==", + "dev": true + }, + "strip-json-comments": { + "version": "3.1.1", + "resolved": "https://registry.npmjs.org/strip-json-comments/-/strip-json-comments-3.1.1.tgz", + "integrity": "sha512-6fPc+R4ihwqP6N/aIv2f1gMH8lOVtWQHoqC4yK6oSDVVocumAsfCqjkXnqiYMhmMwS/mEHLp7Vehlt3ql6lEig==", + "dev": true + }, + "supports-color": { + "version": "7.2.0", + "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-7.2.0.tgz", + "integrity": "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==", + "dev": true, + "requires": { + "has-flag": "^4.0.0" + } + }, + "supports-preserve-symlinks-flag": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/supports-preserve-symlinks-flag/-/supports-preserve-symlinks-flag-1.0.0.tgz", + "integrity": "sha512-ot0WnXS9fgdkgIcePe6RHNk1WA8+muPa6cSjeR3V8K27q9BB1rTE3R1p7Hv0z1ZyAc8s6Vvv8DIyWf681MAt0w==", + "dev": true + }, + "tar": { + "version": "6.1.13", + "resolved": "https://registry.npmjs.org/tar/-/tar-6.1.13.tgz", + "integrity": "sha512-jdIBIN6LTIe2jqzay/2vtYLlBHa3JF42ot3h1dW8Q0PaAG4v8rm0cvpVePtau5C6OKXGGcgO9q2AMNSWxiLqKw==", + "requires": { + "chownr": "^2.0.0", + "fs-minipass": "^2.0.0", + "minipass": "^4.0.0", + "minizlib": "^2.1.1", + "mkdirp": "^1.0.3", + "yallist": "^4.0.0" + }, + "dependencies": { + "yallist": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/yallist/-/yallist-4.0.0.tgz", + "integrity": "sha512-3wdGidZyq5PB084XLES5TpOSRA3wjXAlIWMhum2kRcv/41Sn2emQ0dycQW4uZXLejwKvg6EsvbdlVL+FYEct7A==" + } + } + }, + "test-exclude": { + "version": "6.0.0", + "resolved": "https://registry.npmjs.org/test-exclude/-/test-exclude-6.0.0.tgz", + "integrity": "sha512-cAGWPIyOHU6zlmg88jwm7VRyXnMN7iV68OGAbYDk/Mh/xC/pzVPlQtY6ngoIH/5/tciuhGfvESU8GrHrcxD56w==", + "dev": true, + "requires": { + "@istanbuljs/schema": "^0.1.2", + "glob": "^7.1.4", + "minimatch": "^3.0.4" + } + }, + "text-table": { + "version": "0.2.0", + "resolved": "https://registry.npmjs.org/text-table/-/text-table-0.2.0.tgz", + "integrity": "sha512-N+8UisAXDGk8PFXP4HAzVR9nbfmVJ3zYLAWiTIoqC5v5isinhr+r5uaO8+7r3BMfuNIufIsA7RdpVgacC2cSpw==", + "dev": true + }, + "tmpl": { + "version": "1.0.5", + "resolved": "https://registry.npmjs.org/tmpl/-/tmpl-1.0.5.tgz", + "integrity": "sha512-3f0uOEAQwIqGuWW2MVzYg8fV/QNnc/IpuJNG837rLuczAaLVHslWHZQj4IGiEl5Hs3kkbhwL9Ab7Hrsmuj+Smw==", + "dev": true + }, + "to-fast-properties": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/to-fast-properties/-/to-fast-properties-2.0.0.tgz", + "integrity": "sha512-/OaKK0xYrs3DmxRYqL/yDc+FxFUVYhDlXMhRmv3z915w2HF1tnN1omB354j8VUGO/hbRzyD6Y3sA7v7GS/ceog==", + "dev": true + }, + "to-regex-range": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/to-regex-range/-/to-regex-range-5.0.1.tgz", + "integrity": "sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ==", + "dev": true, + "requires": { + "is-number": "^7.0.0" + } + }, + "tr46": { + "version": "0.0.3", + "resolved": "https://registry.npmjs.org/tr46/-/tr46-0.0.3.tgz", + "integrity": "sha512-N3WMsuqV66lT30CrXNbEjx4GEwlow3v6rr4mCcv6prnfwhS01rkgyFdjPNBYd9br7LpXV1+Emh01fHnq2Gdgrw==" + }, + "tunnel": { + "version": "0.0.6", + "resolved": "https://registry.npmjs.org/tunnel/-/tunnel-0.0.6.tgz", + "integrity": "sha512-1h/Lnq9yajKY2PEbBadPXj3VxsDDu844OnaAo52UVmIzIvwwtBPIuNvkjuzBlTWpfJyUbG3ez0KSBibQkj4ojg==" + }, + "type-check": { + "version": "0.4.0", + "resolved": "https://registry.npmjs.org/type-check/-/type-check-0.4.0.tgz", + "integrity": "sha512-XleUoc9uwGXqjWwXaUTZAmzMcFZ5858QA2vvx1Ur5xIcixXIP+8LnFDgRplU30us6teqdlskFfu+ae4K79Ooew==", + "dev": true, + "requires": { + "prelude-ls": "^1.2.1" + } + }, + "type-detect": { + "version": "4.0.8", + "resolved": "https://registry.npmjs.org/type-detect/-/type-detect-4.0.8.tgz", + "integrity": "sha512-0fr/mIH1dlO+x7TlcMy+bIDqKPsw/70tVyeHW787goQjhmqaZe10uwLujubK9q9Lg6Fiho1KUKDYz0Z7k7g5/g==", + "dev": true + }, + "type-fest": { + "version": "0.20.2", + "resolved": "https://registry.npmjs.org/type-fest/-/type-fest-0.20.2.tgz", + "integrity": "sha512-Ne+eE4r0/iWnpAxD852z3A+N0Bt5RN//NjJwRd2VFHEmrywxf5vsZlh4R6lixl6B+wz/8d+maTSAkN1FIkI3LQ==", + "dev": true + }, + "typed-array-length": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/typed-array-length/-/typed-array-length-1.0.4.tgz", + "integrity": "sha512-KjZypGq+I/H7HI5HlOoGHkWUUGq+Q0TPhQurLbyrVrvnKTBgzLhIJ7j6J/XTQOi0d1RjyZ0wdas8bKs2p0x3Ng==", + "dev": true, + "requires": { + "call-bind": "^1.0.2", + "for-each": "^0.3.3", + "is-typed-array": "^1.1.9" + } + }, + "unbox-primitive": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/unbox-primitive/-/unbox-primitive-1.0.2.tgz", + "integrity": "sha512-61pPlCD9h51VoreyJ0BReideM3MDKMKnh6+V9L08331ipq6Q8OFXZYiqP6n/tbHx4s5I9uRhcye6BrbkizkBDw==", + "dev": true, + "requires": { + "call-bind": "^1.0.2", + "has-bigints": "^1.0.2", + "has-symbols": "^1.0.3", + "which-boxed-primitive": "^1.0.2" + } + }, + "universal-user-agent": { + "version": "6.0.0", + "resolved": "https://registry.npmjs.org/universal-user-agent/-/universal-user-agent-6.0.0.tgz", + "integrity": "sha512-isyNax3wXoKaulPDZWHQqbmIx1k2tb9fb3GGDBRxCscfYV2Ch7WxPArBsFEG8s/safwXTT7H4QGhaIkTp9447w==" + }, + "update-browserslist-db": { + "version": "1.0.10", + "resolved": "https://registry.npmjs.org/update-browserslist-db/-/update-browserslist-db-1.0.10.tgz", + "integrity": "sha512-OztqDenkfFkbSG+tRxBeAnCVPckDBcvibKd35yDONx6OU8N7sqgwc7rCbkJ/WcYtVRZ4ba68d6byhC21GFh7sQ==", + "dev": true, + "requires": { + "escalade": "^3.1.1", + "picocolors": "^1.0.0" + } + }, + "uri-js": { + "version": "4.4.1", + "resolved": "https://registry.npmjs.org/uri-js/-/uri-js-4.4.1.tgz", + "integrity": "sha512-7rKUyy33Q1yc98pQ1DAmLtwX109F7TIfWlW1Ydo8Wl1ii1SeHieeh0HHfPeL2fMXK6z0s8ecKs9frCuLJvndBg==", + "dev": true, + "requires": { + "punycode": "^2.1.0" + } + }, + "url-template": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/url-template/-/url-template-3.1.0.tgz", + "integrity": "sha512-vB/eHWttzhN+NZzk9FcQB2h1cSEgb7zDYyvyxPhw02LYw7YqIzO+w1AqkcKvZ51gPH8o4+nyiWve/xuQqMdJZw==", + "dev": true + }, + "util-deprecate": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/util-deprecate/-/util-deprecate-1.0.2.tgz", + "integrity": "sha512-EPD5q1uXyFxJpCrLnCc1nHnq3gOa6DZBocAIiI2TaSCA7VCJ1UJDMagCzIkXNsUYfD1daK//LTEQ8xiIbrHtcw==" + }, + "uuid": { + "version": "8.3.2", + "resolved": "https://registry.npmjs.org/uuid/-/uuid-8.3.2.tgz", + "integrity": "sha512-+NYs2QeMWy+GWFOEm9xnn6HCDp0l7QBD7ml8zLUmJ+93Q5NF0NocErnwkTkXVFNiX3/fpC6afS8Dhb/gz7R7eg==" + }, + "v8-to-istanbul": { + "version": "9.1.0", + "resolved": "https://registry.npmjs.org/v8-to-istanbul/-/v8-to-istanbul-9.1.0.tgz", + "integrity": "sha512-6z3GW9x8G1gd+JIIgQQQxXuiJtCXeAjp6RaPEPLv62mH3iPHPxV6W3robxtCzNErRo6ZwTmzWhsbNvjyEBKzKA==", + "dev": true, + "requires": { + "@jridgewell/trace-mapping": "^0.3.12", + "@types/istanbul-lib-coverage": "^2.0.1", + "convert-source-map": "^1.6.0" + }, + "dependencies": { + "convert-source-map": { + "version": "1.9.0", + "resolved": "https://registry.npmjs.org/convert-source-map/-/convert-source-map-1.9.0.tgz", + "integrity": "sha512-ASFBup0Mz1uyiIjANan1jzLQami9z1PoYSZCiiYW2FczPbenXc45FZdBZLzOT+r6+iciuEModtmCti+hjaAk0A==", + "dev": true + } + } + }, + "walker": { + "version": "1.0.8", + "resolved": "https://registry.npmjs.org/walker/-/walker-1.0.8.tgz", + "integrity": "sha512-ts/8E8l5b7kY0vlWLewOkDXMmPdLcVV4GmOQLyxuSswIJsweeFZtAsMF7k1Nszz+TYBQrlYRmzOnr398y1JemQ==", + "dev": true, + "requires": { + "makeerror": "1.0.12" + } + }, + "webidl-conversions": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/webidl-conversions/-/webidl-conversions-3.0.1.tgz", + "integrity": "sha512-2JAn3z8AR6rjK8Sm8orRC0h/bcl/DqL7tRPdGZ4I1CjdF+EaMLmYxBHyXuKL849eucPFhvBoxMsflfOb8kxaeQ==" + }, + "whatwg-url": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/whatwg-url/-/whatwg-url-5.0.0.tgz", + "integrity": "sha512-saE57nupxk6v3HY35+jzBwYa0rKSy0XR8JSxZPwgLr7ys0IBzhGviA1/TUGJLmSVqs8pb9AnvICXEuOHLprYTw==", + "requires": { + "tr46": "~0.0.3", + "webidl-conversions": "^3.0.0" + } + }, + "which": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/which/-/which-2.0.2.tgz", + "integrity": "sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA==", + "dev": true, + "requires": { + "isexe": "^2.0.0" + } + }, + "which-boxed-primitive": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/which-boxed-primitive/-/which-boxed-primitive-1.0.2.tgz", + "integrity": "sha512-bwZdv0AKLpplFY2KZRX6TvyuN7ojjr7lwkg6ml0roIy9YeuSr7JS372qlNW18UQYzgYK9ziGcerWqZOmEn9VNg==", + "dev": true, + "requires": { + "is-bigint": "^1.0.1", + "is-boolean-object": "^1.1.0", + "is-number-object": "^1.0.4", + "is-string": "^1.0.5", + "is-symbol": "^1.0.3" + } + }, + "which-typed-array": { + "version": "1.1.9", + "resolved": "https://registry.npmjs.org/which-typed-array/-/which-typed-array-1.1.9.tgz", + "integrity": "sha512-w9c4xkx6mPidwp7180ckYWfMmvxpjlZuIudNtDf4N/tTAUB8VJbX25qZoAsrtGuYNnGw3pa0AXgbGKRB8/EceA==", + "dev": true, + "requires": { + "available-typed-arrays": "^1.0.5", + "call-bind": "^1.0.2", + "for-each": "^0.3.3", + "gopd": "^1.0.1", + "has-tostringtag": "^1.0.0", + "is-typed-array": "^1.1.10" + } + }, + "wide-align": { + "version": "1.1.5", + "resolved": "https://registry.npmjs.org/wide-align/-/wide-align-1.1.5.tgz", + "integrity": "sha512-eDMORYaPNZ4sQIuuYPDHdQvf4gyCF9rEEV/yPxGfwPkRodwEgiMUUXTx/dex+Me0wxx53S+NgUHaP7y3MGlDmg==", + "requires": { + "string-width": "^1.0.2 || 2 || 3 || 4" + } + }, + "word-wrap": { + "version": "1.2.3", + "resolved": "https://registry.npmjs.org/word-wrap/-/word-wrap-1.2.3.tgz", + "integrity": "sha512-Hz/mrNwitNRh/HUAtM/VT/5VH+ygD6DV7mYKZAtHOrbs8U7lvPS6xf7EJKMF0uW1KJCl0H701g3ZGus+muE5vQ==", + "dev": true + }, + "wordwrap": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/wordwrap/-/wordwrap-1.0.0.tgz", + "integrity": "sha512-gvVzJFlPycKc5dZN4yPkP8w7Dc37BtP1yczEneOb4uq34pXZcvrtRTmWV8W+Ume+XCxKgbjM+nevkyFPMybd4Q==", + "dev": true + }, + "wrap-ansi": { + "version": "7.0.0", + "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-7.0.0.tgz", + "integrity": "sha512-YVGIj2kamLSTxw6NsZjoBxfSwsn0ycdesmc4p+Q21c5zPuZ1pl+NfxVdxPtdHvmNVOQ6XSYG4AUtyt/Fi7D16Q==", + "dev": true, + "requires": { + "ansi-styles": "^4.0.0", + "string-width": "^4.1.0", + "strip-ansi": "^6.0.0" + } + }, + "wrappy": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/wrappy/-/wrappy-1.0.2.tgz", + "integrity": "sha512-l4Sp/DRseor9wL6EvV2+TuQn63dMkPjZ/sp9XkghTEbV9KlPS1xUsZ3u7/IQO4wxtcFB4bgpQPRcR3QCvezPcQ==" + }, + "write-file-atomic": { + "version": "4.0.2", + "resolved": "https://registry.npmjs.org/write-file-atomic/-/write-file-atomic-4.0.2.tgz", + "integrity": "sha512-7KxauUdBmSdWnmpaGFg+ppNjKF8uNLry8LyzjauQDOVONfFLNKrKvQOxZ/VuTIcS/gge/YNahf5RIIQWTSarlg==", + "dev": true, + "requires": { + "imurmurhash": "^0.1.4", + "signal-exit": "^3.0.7" + } + }, + "xml": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/xml/-/xml-1.0.1.tgz", + "integrity": "sha512-huCv9IH9Tcf95zuYCsQraZtWnJvBtLVE0QHMOs8bWyZAFZNDcYjsPq1nEx8jKA9y+Beo9v+7OBPRisQTjinQMw==", + "dev": true + }, + "y18n": { + "version": "5.0.8", + "resolved": "https://registry.npmjs.org/y18n/-/y18n-5.0.8.tgz", + "integrity": "sha512-0pfFzegeDWJHJIAmTLRP2DwHjdF5s7jo9tuztdQxAhINCdvS+3nGINqPd00AphqJR/0LhANUS6/+7SCb98YOfA==", + "dev": true + }, + "yallist": { + "version": "3.1.1", + "resolved": "https://registry.npmjs.org/yallist/-/yallist-3.1.1.tgz", + "integrity": "sha512-a4UGQaWPH59mOXUYnAG2ewncQS4i4F43Tv3JoAM+s2VDAmS9NsK8GpDMLrCHPksFT7h3K6TOoUNn2pb7RoXx4g==", + "dev": true + }, + "yargs": { + "version": "17.7.1", + "resolved": "https://registry.npmjs.org/yargs/-/yargs-17.7.1.tgz", + "integrity": "sha512-cwiTb08Xuv5fqF4AovYacTFNxk62th7LKJ6BL9IGUpTJrWoU7/7WdQGTP2SjKf1dUNBGzDd28p/Yfs/GI6JrLw==", + "dev": true, + "requires": { + "cliui": "^8.0.1", + "escalade": "^3.1.1", + "get-caller-file": "^2.0.5", + "require-directory": "^2.1.1", + "string-width": "^4.2.3", + "y18n": "^5.0.5", + "yargs-parser": "^21.1.1" + } + }, + "yargs-parser": { + "version": "21.1.1", + "resolved": "https://registry.npmjs.org/yargs-parser/-/yargs-parser-21.1.1.tgz", + "integrity": "sha512-tVpsJW7DdjecAiFpbIB1e3qxIQsE6NoPc5/eTdrbbIC4h0LVsWhnoa3g+m2HclBIujHzsxZ4VJVA+GUuc2/LBw==", + "dev": true + }, + "yocto-queue": { + "version": "0.1.0", + "resolved": "https://registry.npmjs.org/yocto-queue/-/yocto-queue-0.1.0.tgz", + "integrity": "sha512-rVksvsnNCdJ/ohGc6xgPwyN8eheCxsiLM8mxuE/t/mOVqJewPuO1miLpTHQiRgTKCLexL4MeAFVagts7HmNZ2Q==", + "dev": true + } + } +} diff --git a/action-surefire-report/package.json b/action-surefire-report/package.json new file mode 100644 index 0000000..4c9f031 --- /dev/null +++ b/action-surefire-report/package.json @@ -0,0 +1,50 @@ +{ + "name": "action-surefire-report", + "version": "1.0.0", + "description": "", + "author": "Scalable Capital", + "license": "Apache-2.0", + "main": "index.js", + "homepage": "https://github.com/ScaCap/action-surefire-report#readme", + "scripts": { + "eslint": "eslint .", + "package": "ncc build index.js -o dist", + "test": "jest", + "test-ci": "jest --ci --reporters=jest-junit" + }, + "repository": { + "type": "git", + "url": "git+https://github.com/ScaCap/action-surefire-report" + }, + "keywords": [ + "GitHub", + "Actions", + "Junit", + "Surefire" + ], + "bugs": { + "url": "https://github.com/ScaCap/action-surefire-report/issues" + }, + "jest-junit": { + "suiteNameTemplate": "{filepath}", + "classNameTemplate": "{classname}", + "titleTemplate": "{title}" + }, + "dependencies": { + "@actions/core": "1.10.0", + "@actions/github": "5.1.1", + "@actions/glob": "0.4.0", + "@octokit/rest": "19.0.7", + "@octokit/plugin-retry": "4.1.1", + "libxmljs": "0.19.10" + }, + "devDependencies": { + "@octokit/fixtures": "22.0.6", + "@vercel/ncc": "0.36.1", + "enzyme": "3.11.0", + "eslint": "8.33.0", + "jest": "29.4.2", + "jest-junit": "15.0.0", + "nock": "13.3.0" + } +} diff --git a/action-surefire-report/python/__init__.py b/action-surefire-report/python/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/action-surefire-report/python/test_sample.py b/action-surefire-report/python/test_sample.py new file mode 100644 index 0000000..cf4af95 --- /dev/null +++ b/action-surefire-report/python/test_sample.py @@ -0,0 +1,14 @@ +# -*- coding: utf-8 -*- + + +def test_which_succeeds(): + event = { 'attr': 'test'} + assert event['attr'] == 'test' + +def test_which_fails(): + event = { 'attr': 'test'} + assert event['attr'] == 'xyz' + +def test_with_error(): + event = { 'attr': 'test'} + assert event.attr == 'test' diff --git a/action-surefire-report/screenshot.png b/action-surefire-report/screenshot.png new file mode 100644 index 0000000000000000000000000000000000000000..6ede3d846876314ad93a3995333b797cb21dda63 GIT binary patch literal 97659 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 literal 0 HcmV?d00001 diff --git a/action-surefire-report/tests/email/build/java/test/action/surefire/report/email/EmailAddressTest.class b/action-surefire-report/tests/email/build/java/test/action/surefire/report/email/EmailAddressTest.class new file mode 100644 index 0000000000000000000000000000000000000000..d121cb09e73d47ac04b87a4dd97c65b01305d5a2 GIT binary patch literal 2786 zcmb7FTW=Fb6h7-1yqFMza{-4-oNx;cYZH?IAwX>B0s$vb90HVZ8SjqmP1ZB+?m7wd z^27`3L!bKAcT}lTn@SZ3seLGKeS#kW>aVDJX4W_xunM)TvpaLn`Mx=~*}wjI@dp45 zLn#dVVN8W{VK@&L!q5lfDx_7&sE}1*LWM~crc{_#;i3wcRG3lWvIZiV4Cd>)27uo!~7A-Jc&)^jE^-3tn|3>;ffAUMGd zs=&^i$>?0IQlR!cDOk7@$#I=n3&b|Xy1p57%ci41GDmdRRI_{VPy-u0eEF()Va&Am9UMrQSxt%8#b&A~9kuQ3^#$2;P7fi=Q z!VF{FC4vO`+H>44C6{V=@MImZ-2(!j=`--PoEn9cO}9s+>{gqJK|AGr^fl zOeSNy#2ulGzptEOF14BDCYJe#8p3dnR45vcc*YrBr&ad@!%2>jGiiFmFN|Mo@R6hOr=Y7VuvRnx@|ay4O{ zcCo313q~Q`8(Lwiz_F#8<7y7CP;6IL(%dp}HB&RVhCQXNij}v8soN%8B!~iS^4$`B zFKDnXazi-K72g?%=30gV9a8&poiO9&3vrwTLGq~FU1OSt``W1rN$Cw;XQrSprZG)v zx<)Ehi+VxqnYO917|U9`RB|?}x-N5?SVYb0=KW~D@Tt4>Z`N%m1(Gh1f(O3))vvF= zef{{=FXEXdj)8wq(~U=exo#~l8AVKhD~8rnw2S->{`u6G=gv3Z{rvXHk8jq$PyhYf zg~r^n%~x4$ zhOOW%8vYLSb$k0pD_<=v;Ut8h&RF|La=A zM*C!Y1p>UNz<9H<{PfEdFH&Eq-dN*}jyGt9V7rbsLBHc0b1yez$9!A$s{wI0ZrF^2 zBY|+iB6b9RkNWTfC4Sp+ByrYJ9>P@;pE#wkCH@SQb$kiHVU%0t<~BHj@2#Ez9EAZ~ zVY<*cAe~2WC7eT%z;kH1x#1p01ArX})8>N+)gj`j69j`2?sx<45_$=^NL+aa!FXhg zlv`15AV(l5EMNB)BT&wk8x&JYo;Vz8A^%`6xP? zQY4yDgeCZPDO;OR#E_y7Df*G(;72Kv4T_O^6rp%z$0k@W?MD%Izz5en?I(P2@2c3= ztcu4GPWvd_Py;SsKV38)*(pPBmvWbskxl3A#xep7Awde$a1zrn40~Y2M;2|G?No#8 zZk?<*9_f$-ol + + + action.surefire.report + tests + 0.0.1-SNAPSHOT + + 4.0.0 + email + + + + junit + junit + test + + + org.apache.commons + commons-lang3 + + + org.hamcrest + hamcrest-all + test + + + org.assertj + assertj-core + test + + + diff --git a/action-surefire-report/tests/email/src/main/java/action/surefire/report/email/EmailAddress.java b/action-surefire-report/tests/email/src/main/java/action/surefire/report/email/EmailAddress.java new file mode 100644 index 0000000..7c150ca --- /dev/null +++ b/action-surefire-report/tests/email/src/main/java/action/surefire/report/email/EmailAddress.java @@ -0,0 +1,34 @@ +package action.surefire.report.email; + +import org.apache.commons.lang3.StringUtils; + +import java.util.Locale; +import java.util.regex.Pattern; + +public class EmailAddress { + + private final String address; + + private static final Pattern EMAIL_PATTERN = Pattern.compile("" + + "^" + + "[a-z0-9!#$%&'*+/=?^_`{|}~-]+" + // non-greedy local part + "(?:\\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*" + // non-greedy local part with dot + "@" + + "(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\\.)+" + // non-greedy domain with dot + "[a-z0-9](?:[a-z0-9-]*[a-z0-9])?" + // the rest of the domain + "$" + ); + + public static EmailAddress of(String address) throws InvalidEmailAddressException { + return new EmailAddress(address); + } + + private EmailAddress(String address) { + if (StringUtils.isBlank(address)) + throw new InvalidEmailAddressException("Email address must not be null, empty, or blanks"); + String normalized = address.toLowerCase(Locale.ENGLISH).trim(); + if (!EMAIL_PATTERN.matcher(normalized).matches()) + throw new InvalidEmailAddressException("Invalid email address '" + address + "'"); + this.address = normalized; + } +} diff --git a/action-surefire-report/tests/email/src/main/java/action/surefire/report/email/InvalidEmailAddressException.java b/action-surefire-report/tests/email/src/main/java/action/surefire/report/email/InvalidEmailAddressException.java new file mode 100644 index 0000000..b0d417f --- /dev/null +++ b/action-surefire-report/tests/email/src/main/java/action/surefire/report/email/InvalidEmailAddressException.java @@ -0,0 +1,7 @@ +package action.surefire.report.email; + +public class InvalidEmailAddressException extends RuntimeException { + public InvalidEmailAddressException(String message) { + super(message); + } +} diff --git a/action-surefire-report/tests/email/src/test/java/action/surefire/report/email/EmailAddressTest.java b/action-surefire-report/tests/email/src/test/java/action/surefire/report/email/EmailAddressTest.java new file mode 100644 index 0000000..110ec4d --- /dev/null +++ b/action-surefire-report/tests/email/src/test/java/action/surefire/report/email/EmailAddressTest.java @@ -0,0 +1,80 @@ +package action.surefire.report.email; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertNotEquals; +import static org.junit.Assert.fail; + +import org.junit.Test; + +public class EmailAddressTest { + + @Test + public void shouldBeGoodEnoughForSalesforce() { + EmailAddress.of("abcdefg.hijklmnopqrstuvwxyz!#$%&'*/=?^_+-`{|}~0123456789@host.com"); + } + + @Test + public void shouldNotBeBlank() { + expectException(null); + expectException(""); + expectException(" "); + } + + @Test + public void shouldNotMissComponents() { + expectException("user-without-host@test.com"); + expectException("@host-without-user"); + expectException("just-something-that-i-do-not-what-that-is"); + } + + @Test + public void shouldNotContainLocalHosts() { + expectException("user@host"); + expectException("user@localhost"); + expectException("user@whatever-without-a-tld"); + } + + @Test + public void shouldNotContainInternationalizedHostNames() { + expectException("user@ñandú.com.ar"); + } + + @Test + public void shouldAcceptInternationalizedDomainNamesUsingPunycode() { + EmailAddress.of("user@xn--and-6ma2c.com.ar"); + } + + @Test + public void shouldBeStricterThanRfc2821() { + expectException("Abc\\@def@example.com"); + expectException("Fred\\ Bloggs@example.com"); + expectException("Joe.\\Blow@example.com"); + expectException("\"Fred Bloggs\"@example.com"); + } + + @Test + public void shouldBeStricterThanRfc2822() { + expectException("aba@bab.com"); + expectException("выфавы@asdasd.com"); + expectException("ñañlkjdf@hotmail.com"); + expectException("test+§@test.com"); + expectException("可扩展@资本.com"); + } + + @Test + public void shouldNotAllowDotsInWeirdPlaces() { + expectException(".user@host.com"); + expectException("user.@host.com"); + expectException(".user.@host.com"); + expectException("user..name@host.com"); + } + + private void expectException(String address) { + try { + EmailAddress.of(address); + fail(String.format("Address %s should have thrown InvalidEmailAddressException", address)); + } catch (IllegalArgumentException ex) { + // OK + } + } +} diff --git a/action-surefire-report/tests/evil_twins/pom.xml b/action-surefire-report/tests/evil_twins/pom.xml new file mode 100644 index 0000000..cb85558 --- /dev/null +++ b/action-surefire-report/tests/evil_twins/pom.xml @@ -0,0 +1,26 @@ + + + + tests + action.surefire.report + 0.0.1-SNAPSHOT + + 4.0.0 + + evil_twins + + + + junit + junit + test + + + org.hamcrest + hamcrest-all + test + + + diff --git a/action-surefire-report/tests/evil_twins/src/main/java/action/surefire/report/twin/first/Twin.java b/action-surefire-report/tests/evil_twins/src/main/java/action/surefire/report/twin/first/Twin.java new file mode 100644 index 0000000..05d6c69 --- /dev/null +++ b/action-surefire-report/tests/evil_twins/src/main/java/action/surefire/report/twin/first/Twin.java @@ -0,0 +1,8 @@ +package action.surefire.report.twin.first; + +public class Twin { + + public String getName() { + return "Good Twin"; + } +} diff --git a/action-surefire-report/tests/evil_twins/src/main/java/action/surefire/report/twin/second/Twin.java b/action-surefire-report/tests/evil_twins/src/main/java/action/surefire/report/twin/second/Twin.java new file mode 100644 index 0000000..adae8b6 --- /dev/null +++ b/action-surefire-report/tests/evil_twins/src/main/java/action/surefire/report/twin/second/Twin.java @@ -0,0 +1,8 @@ +package action.surefire.report.twin.second; + +public class Twin { + + public String getName() { + return "Evil Twin"; + } +} diff --git a/action-surefire-report/tests/evil_twins/src/test/java/action/surefire/report/twin/first/TwinTest.java b/action-surefire-report/tests/evil_twins/src/test/java/action/surefire/report/twin/first/TwinTest.java new file mode 100644 index 0000000..53d4667 --- /dev/null +++ b/action-surefire-report/tests/evil_twins/src/test/java/action/surefire/report/twin/first/TwinTest.java @@ -0,0 +1,16 @@ +package action.surefire.report.twin.first; + +import static org.hamcrest.MatcherAssert.assertThat; +import static org.hamcrest.Matchers.equalTo; + +import org.junit.Test; + +public class TwinTest { + + @Test + public void should_always_pass() { + Twin goodTwin = new Twin(); + assertThat(goodTwin.getName(), equalTo("Good Twin")); + } + +} diff --git a/action-surefire-report/tests/evil_twins/src/test/java/action/surefire/report/twin/second/TwinTest.java b/action-surefire-report/tests/evil_twins/src/test/java/action/surefire/report/twin/second/TwinTest.java new file mode 100644 index 0000000..f7a0297 --- /dev/null +++ b/action-surefire-report/tests/evil_twins/src/test/java/action/surefire/report/twin/second/TwinTest.java @@ -0,0 +1,16 @@ +package action.surefire.report.twin.second; + +import static org.hamcrest.MatcherAssert.assertThat; +import static org.hamcrest.Matchers.equalTo; + +import org.junit.Test; + +public class TwinTest { + + @Test + public void should_always_fail() { + Twin evilTwin = new Twin(); + assertThat(evilTwin.getName(), equalTo("Good Twin")); + } + +} diff --git a/action-surefire-report/tests/pom.xml b/action-surefire-report/tests/pom.xml new file mode 100644 index 0000000..e7c4613 --- /dev/null +++ b/action-surefire-report/tests/pom.xml @@ -0,0 +1,84 @@ + + + 4.0.0 + + action.surefire.report + tests + pom + + 0.0.1-SNAPSHOT + + + utils + email + evil_twins + + + + UTF-8 + 1.8 + 1.8 + 1.8 + 1.3.72 + + + + + + junit + junit + 4.13.1 + + + org.hamcrest + hamcrest-all + 1.3 + test + + + org.jetbrains.kotlin + kotlin-stdlib-jdk8 + ${kotlin.version} + + + org.jetbrains.kotlin + kotlin-test-junit + ${kotlin.version} + test + + + commons-io + commons-io + 2.7 + + + org.assertj + assertj-core + 3.11.1 + test + + + org.apache.commons + commons-lang3 + 3.7 + + + + + + + + org.apache.maven.plugins + maven-surefire-plugin + 2.22.2 + + -Duser.language=en + true + true + + + + + + diff --git a/action-surefire-report/tests/utils/pom.xml b/action-surefire-report/tests/utils/pom.xml new file mode 100644 index 0000000..f93517c --- /dev/null +++ b/action-surefire-report/tests/utils/pom.xml @@ -0,0 +1,89 @@ + + + + tests + action.surefire.report + 0.0.1-SNAPSHOT + + 4.0.0 + utils + + + + org.apache.commons + commons-lang3 + + + junit + junit + test + + + org.hamcrest + hamcrest-all + test + + + org.jetbrains.kotlin + kotlin-stdlib-jdk8 + ${kotlin.version} + + + org.jetbrains.kotlin + kotlin-test-junit + ${kotlin.version} + test + + + + + + + org.jetbrains.kotlin + kotlin-maven-plugin + ${kotlin.version} + + + compile + compile + + compile + + + + test-compile + test-compile + + test-compile + + + + + 1.8 + + + + org.apache.maven.plugins + maven-compiler-plugin + + + compile + compile + + compile + + + + testCompile + test-compile + + testCompile + + + + + + + + + diff --git a/action-surefire-report/tests/utils/src/main/java/action/surefire/report/calc/CalcUtils.java b/action-surefire-report/tests/utils/src/main/java/action/surefire/report/calc/CalcUtils.java new file mode 100644 index 0000000..7466db3 --- /dev/null +++ b/action-surefire-report/tests/utils/src/main/java/action/surefire/report/calc/CalcUtils.java @@ -0,0 +1,62 @@ +package action.surefire.report.calc; + +import static java.math.BigDecimal.ZERO; +import static java.math.RoundingMode.HALF_EVEN; + +import java.math.BigDecimal; + +public final class CalcUtils { + + private CalcUtils() { + // utility class + } + + /** + * Rounds value to 4 decimal places + */ + public static BigDecimal roundPercentageValue(BigDecimal value) { + return value.setScale(4, HALF_EVEN); + } + + public static boolean equalTo(BigDecimal value1, BigDecimal value2) { + return value1.compareTo(value2) == 0; + } + + public static boolean greaterThanEqualTo(BigDecimal value1, BigDecimal value2) { + return value1.compareTo(value2) >= 0; + } + + public static BigDecimal positiveOrZero(BigDecimal value) { + return greaterThanEqualTo(value, ZERO) ? value : ZERO; + } + + /** + * @return zero if divisor is 0 + */ + public static BigDecimal safeDivide(BigDecimal dividend, BigDecimal divisor, + int decimalPlaces) { + if (equalTo(divisor, ZERO)) { + return ZERO; + } else { + return dividend.divide(divisor, decimalPlaces, HALF_EVEN); + } + } + + /** + * Scales amount to 2 decimal places, throwing error if decimal places overflow + */ + public static BigDecimal scaleAmount(BigDecimal amount) { + if (!(amount.stripTrailingZeros().scale() <= 2)) { + throw new IllegalArgumentException("Amount must have max 2 non-zero decimal places"); + } + return amount.stripTrailingZeros().setScale(2, HALF_EVEN); + } + + public static BigDecimal nullToZero(BigDecimal value) { + if (value != null) { + return value; + } else { + return ZERO; + } + } +} diff --git a/action-surefire-report/tests/utils/src/main/java/action/surefire/report/calc/StringUtils.java b/action-surefire-report/tests/utils/src/main/java/action/surefire/report/calc/StringUtils.java new file mode 100644 index 0000000..7efd196 --- /dev/null +++ b/action-surefire-report/tests/utils/src/main/java/action/surefire/report/calc/StringUtils.java @@ -0,0 +1,29 @@ +package action.surefire.report.calc; + +public final class StringUtils { + + private StringUtils() { + // utility class + } + + public static String nullIfBlank(String value) { + if (org.apache.commons.lang3.StringUtils.isBlank(value)) { + return null; + } + return value; + } + + + public static String requireNotBlank(String input) { + return requireNotBlank(input, null); + } + + public static String requireNotBlank(String input, String message) { + if (!org.apache.commons.lang3.StringUtils.isBlank(input)) { + return input; + } else { + throw new IllegalArgumentException( + message != null ? message : "Input='" + input + "' didn't match condition."); + } + } +} diff --git a/action-surefire-report/tests/utils/src/test/java/action/surefire/report/calc/AllOkTest.java b/action-surefire-report/tests/utils/src/test/java/action/surefire/report/calc/AllOkTest.java new file mode 100644 index 0000000..e79f23c --- /dev/null +++ b/action-surefire-report/tests/utils/src/test/java/action/surefire/report/calc/AllOkTest.java @@ -0,0 +1,10 @@ +package action.surefire.report.calc; + +import org.junit.Test; + +public class AllOkTest { + + @Test + public void everythingIsFine() { + } +} \ No newline at end of file diff --git a/action-surefire-report/tests/utils/src/test/java/action/surefire/report/calc/CalcUtilsTest.kt b/action-surefire-report/tests/utils/src/test/java/action/surefire/report/calc/CalcUtilsTest.kt new file mode 100644 index 0000000..5e2bf1f --- /dev/null +++ b/action-surefire-report/tests/utils/src/test/java/action/surefire/report/calc/CalcUtilsTest.kt @@ -0,0 +1,33 @@ +package action.surefire.report.calc + +import org.hamcrest.MatcherAssert.assertThat +import org.hamcrest.Matchers.equalTo +import org.junit.Assert.assertThrows +import org.junit.Test +import java.math.BigDecimal + +class CalcUtilsTest { + + @Test + fun `test scale`() { + assertThat(scale("100.0000"), equalTo(BigDecimal("100.00"))) + assertThat(scale("100.0100"), equalTo(BigDecimal("100.01"))) + assertThat(scale("100.110"), equalTo(BigDecimal("100.10"))) + assertThat(scale("100.1"), equalTo(BigDecimal("100.10"))) + assertThat(scale("100"), equalTo(BigDecimal("100.00"))) + assertThat(scale(".0000"), equalTo(BigDecimal("0.00"))) + assertThat(scale(".0100"), equalTo(BigDecimal("0.01"))) + assertThat(scale(".110"), equalTo(BigDecimal("0.11"))) + assertThat(scale(".1"), equalTo(BigDecimal("0.10"))) + assertThat(scale("0"), equalTo(BigDecimal("0.00"))) + } + + @Test + fun `test error handling`() { + assertThrows(IllegalStateException::class.java) { scale("100.001") } + } + + private fun scale(amount: String): BigDecimal { + return CalcUtils.scaleAmount(BigDecimal(amount)) + } +} \ No newline at end of file diff --git a/action-surefire-report/tests/utils/src/test/java/action/surefire/report/calc/StringUtilsTest.java b/action-surefire-report/tests/utils/src/test/java/action/surefire/report/calc/StringUtilsTest.java new file mode 100644 index 0000000..1a7498a --- /dev/null +++ b/action-surefire-report/tests/utils/src/test/java/action/surefire/report/calc/StringUtilsTest.java @@ -0,0 +1,51 @@ +package action.surefire.report.calc; + +import org.junit.Ignore; +import org.junit.Rule; +import org.junit.Test; +import org.junit.rules.ExpectedException; + +import static org.hamcrest.CoreMatchers.equalTo; +import static org.hamcrest.MatcherAssert.assertThat; +import static org.junit.Assert.assertTrue; + +public class StringUtilsTest { + + @Rule + public ExpectedException thrown = ExpectedException.none(); + + @Test + public void require() { + final String output = StringUtils.requireNotBlank("hello"); + assertTrue(output.equals("wrong")); + } + + @Test + public void require_fail() { + thrown.expect(IllegalArgumentException.class); + thrown.expectMessage("This is unexpected"); + StringUtils.requireNotBlank(""); + } + + @Test + public void require_failMsg() { + thrown.expect(IllegalArgumentException.class); + thrown.expectMessage("I really need that input"); + StringUtils.requireNotBlank("", "I really need that input"); + } + + @Ignore + @Test + public void require_fail_null() { + thrown.expect(IllegalArgumentException.class); + thrown.expectMessage("Input='null' didn't match condition."); + StringUtils.requireNotBlank(null); + } + + @Test + public void require_withNullMsg() { + thrown.expect(IllegalArgumentException.class); + thrown.expectMessage("Input='' didn't match condition."); + StringUtils.requireNotBlank(""); + } +} \ No newline at end of file diff --git a/action-surefire-report/utils.js b/action-surefire-report/utils.js new file mode 100644 index 0000000..c2b765c --- /dev/null +++ b/action-surefire-report/utils.js @@ -0,0 +1,123 @@ +const glob = require('@actions/glob'); +const core = require('@actions/core'); +const fs = require('fs'); +const libxmljs = require("libxmljs"); + +const resolveFileAndLine = (file, classname, output, isFilenameInOutput) => { + // extract filename from classname and remove suffix + let filename; + let filenameWithPackage; + if (isFilenameInOutput) { + filename = output.split(':')[0].trim(); + filenameWithPackage = filename + } else { + filename = file ? file : classname.split('.').slice(-1)[0].split('(')[0]; + filenameWithPackage = classname.replace(/\./g, "/"); + } + const matches = output.match(new RegExp(`${filename}.*?:\\d+`, 'g')); + if (!matches) return { filename: filename, filenameWithPackage: filenameWithPackage, line: 1 }; + + const [lastItem] = matches.slice(-1); + const [, line] = lastItem.split(':'); + core.debug(`Resolved file ${filenameWithPackage} with name ${filename} and line ${line}`); + + return { filename, filenameWithPackage, line: parseInt(line) }; +}; + +const resolvePath = async filenameWithPackage => { + if (!filenameWithPackage) { + return ''; + } + core.debug(`Resolving path for ${filenameWithPackage}`); + const globber = await glob.create([`**/${filenameWithPackage}.*`, `**/${filenameWithPackage}`].join('\n'), { followSymbolicLinks: false }); + const results = await globber.glob(); + core.debug(`Matched files: ${results}`); + const searchPath = globber.getSearchPaths()[0]; + + let path = ''; + if (results.length) { + // skip various temp folders + const found = results.find(r => !r.includes('__pycache__') && !r.endsWith('.class')); + if (found) path = found.slice(searchPath.length + 1); + else path = filenameWithPackage; + } else { + path = filenameWithPackage; + } + core.debug(`Resolved path: ${path}`); + + // canonicalize to make windows paths use forward slashes + const canonicalPath = path.replace(/\\/g, '/'); + core.debug(`Canonical path: ${canonicalPath}`); + + return canonicalPath; +}; + +async function parseFile(file, isFilenameInStackTrace) { + core.debug(`Parsing file ${file}`); + let count = 0; + let skipped = 0; + let annotations = []; + + const data = await fs.promises.readFile(file); + + const report = libxmljs.parseXml(data + "", {huge: true}); + const testsuites = report.find('//testsuite'); + + for (const testsuite of testsuites) { + const testcases = testsuite.find('testcase'); + for (const testcase of testcases) { + count++; + skipped += testcase.find('skipped').length; + let failures = testcase.find('failure | flakyFailure | error'); + if (failures.length == 0) { + continue; + } + const stackTrace = failures.map(failure => failure.text()).join('').trim(); + const message = ( + failures.map(failure => failure.attr('message')?.value()).join('') || + stackTrace.split('\n').slice(0, 2).join('\n') + ).trim(); + + const { filename, filenameWithPackage, line } = resolveFileAndLine( + testcase.attr('file')?.value() || '', + testcase.attr('classname')?.value() || '', + stackTrace, + isFilenameInStackTrace + ); + + const path = await resolvePath(filenameWithPackage); + const title = `${filename}.${testcase.attr('name')?.value()}`; + core.info(`${path}:${line} | ${message.replace(/\n/g, ' ')}`); + + annotations.push({ + path, + start_line: line, + end_line: line, + start_column: 0, + end_column: 0, + annotation_level: 'failure', + title, + message, + raw_details: stackTrace + }); + } + } + return { count, skipped, annotations }; +} + +const parseTestReports = async (reportPaths, isFilenameInStackTrace) => { + const globber = await glob.create(reportPaths, { followSymbolicLinks: false }); + let annotations = []; + let count = 0; + let skipped = 0; + for await (const file of globber.globGenerator()) { + const { count: c, skipped: s, annotations: a } = await parseFile(file, isFilenameInStackTrace); + if (c === 0) continue; + count += c; + skipped += s; + annotations = annotations.concat(a); + } + return { count, skipped, annotations }; +}; + +module.exports = { resolveFileAndLine, resolvePath, parseFile, parseTestReports }; diff --git a/action-surefire-report/utils.test.js b/action-surefire-report/utils.test.js new file mode 100644 index 0000000..e42ef83 --- /dev/null +++ b/action-surefire-report/utils.test.js @@ -0,0 +1,360 @@ +const { resolveFileAndLine, resolvePath, parseFile } = require('./utils'); + +describe('resolveFileAndLine', () => { + it('should default to 1 if no line found', () => { + const { filename, line } = resolveFileAndLine(null, 'someClassName', 'not a stacktrace'); + expect(filename).toBe('someClassName'); + expect(line).toBe(1); + }); + + it('should parse correctly filename and line for a Java file', () => { + const { filename, line } = resolveFileAndLine( + null, + 'action.surefire.report.email.EmailAddressTest', + ` +action.surefire.report.email.InvalidEmailAddressException: Invalid email address 'user@ñandú.com.ar' + at action.surefire.report.email.EmailAddressTest.expectException(EmailAddressTest.java:74) + at action.surefire.report.email.EmailAddressTest.shouldNotContainInternationalizedHostNames(EmailAddressTest.java:39) + `, + false, + ); + expect(filename).toBe('EmailAddressTest'); + expect(line).toBe(39); + }); + + it('should parse correctly filename and line for a Kotlin file', () => { + const { filename, line } = resolveFileAndLine( + null, + 'action.surefire.report.calc.CalcUtilsTest', + ` +java.lang.AssertionError: unexpected exception type thrown; expected: but was: + at action.surefire.report.calc.CalcUtilsTest.test error handling(CalcUtilsTest.kt:27) +Caused by: java.lang.IllegalArgumentException: Amount must have max 2 non-zero decimal places + at action.surefire.report.calc.CalcUtilsTest.scale(CalcUtilsTest.kt:31) + at action.surefire.report.calc.CalcUtilsTest.access$scale(CalcUtilsTest.kt:9) + at action.surefire.report.calc.CalcUtilsTest.test error handling(CalcUtilsTest.kt:27) + `, + false, + ); + expect(filename).toBe('CalcUtilsTest'); + expect(line).toBe(27); + }); + + it('should parse correctly filename and line for extended stacktrace', () => { + const { filename, line } = resolveFileAndLine( + null, + 'action.surefire.report.calc.StringUtilsTest', + ` +java.lang.AssertionError: + +Expected: (an instance of java.lang.IllegalArgumentException and exception with message a string containing "This is unexpected") + but: exception with message a string containing "This is unexpected" message was "Input='' didn't match condition." +Stacktrace was: java.lang.IllegalArgumentException: Input='' didn't match condition. + at action.surefire.report.calc.StringUtils.requireNotBlank(StringUtils.java:25) + at action.surefire.report.calc.StringUtils.requireNotBlank(StringUtils.java:18) + at action.surefire.report.calc.StringUtilsTest.require_fail(StringUtilsTest.java:26) + at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method) + at org.junit.runners.ParentRunner.run(ParentRunner.java:413) + at org.apache.maven.surefire.junit4.JUnit4Provider.invoke(JUnit4Provider.java:159) + at org.apache.maven.surefire.booter.ForkedBooter.main(ForkedBooter.java:418) +`, + false, + ); + expect(filename).toBe('StringUtilsTest'); + expect(line).toBe(26); + }); + + it('should parse correctly filename and line for pytest', () => { + const { filename, line } = resolveFileAndLine( + 'test.py', + 'anything', + ` +def +test_with_error(): +event = { 'attr': 'test'} +> assert event.attr == 'test' +E AttributeError: 'dict' object has no attribute 'attr' + +test.py:14: AttributeError +`, + false + ); + expect(filename).toBe('test.py'); + expect(line).toBe(14); + }); + + it('should parse correctly filename and line for a Go file when filename is in stack trace', () => { + const {filename, line} = resolveFileAndLine( + null, + 'com/ScaCap/action-surefire-report', + 'main_test.go:8: failing test', + true, + ); + expect(filename).toBe('main_test.go'); + expect(line).toBe(8); + }); +}); + +describe('resolvePath', () => { + it('should find correct file for Java filename', async () => { + const path = await resolvePath('EmailAddressTest'); + expect(path).toBe( + 'tests/email/src/test/java/action/surefire/report/email/EmailAddressTest.java' + ); + }); + + it('should find correct file for Kotlin filename', async () => { + const path = await resolvePath('CalcUtilsTest'); + expect(path).toBe('tests/utils/src/test/java/action/surefire/report/calc/CalcUtilsTest.kt'); + }); + + it('should find correct file when extension is included', async () => { + const path = await resolvePath('CalcUtilsTest.kt'); + expect(path).toBe('tests/utils/src/test/java/action/surefire/report/calc/CalcUtilsTest.kt'); + }); +}); + +describe('parseFile', () => { + it('should parse CalcUtils results', async () => { + const { count, skipped, annotations } = await parseFile( + 'tests/utils/target/surefire-reports/TEST-action.surefire.report.calc.CalcUtilsTest.xml' + ); + + expect(count).toBe(2); + expect(skipped).toBe(0); + expect(annotations).toStrictEqual([ + { + path: 'tests/utils/src/test/java/action/surefire/report/calc/CalcUtilsTest.kt', + start_line: 27, + end_line: 27, + start_column: 0, + end_column: 0, + annotation_level: 'failure', + title: 'CalcUtilsTest.test error handling', + message: + 'unexpected exception type thrown; expected: but was:', + raw_details: + 'java.lang.AssertionError: unexpected exception type thrown; expected: but was:\n\tat action.surefire.report.calc.CalcUtilsTest.test error handling(CalcUtilsTest.kt:27)\nCaused by: java.lang.IllegalArgumentException: Amount must have max 2 non-zero decimal places\n\tat action.surefire.report.calc.CalcUtilsTest.scale(CalcUtilsTest.kt:31)\n\tat action.surefire.report.calc.CalcUtilsTest.access$scale(CalcUtilsTest.kt:9)\n\tat action.surefire.report.calc.CalcUtilsTest.test error handling(CalcUtilsTest.kt:27)' + }, + { + path: 'tests/utils/src/test/java/action/surefire/report/calc/CalcUtilsTest.kt', + start_line: 15, + end_line: 15, + start_column: 0, + end_column: 0, + annotation_level: 'failure', + title: 'CalcUtilsTest.test scale', + message: 'Expected: <100.10>\n but: was <100.11>', + raw_details: + 'java.lang.AssertionError: \n\nExpected: <100.10>\n but: was <100.11>\n\tat action.surefire.report.calc.CalcUtilsTest.test scale(CalcUtilsTest.kt:15)' + } + ]); + }); + it('should parse pytest results', async () => { + const { count, skipped, annotations } = await parseFile('python/report.xml'); + + expect(count).toBe(3); + expect(skipped).toBe(0); + expect(annotations).toStrictEqual([ + { + path: 'python/test_sample.py', + start_line: 10, + end_line: 10, + start_column: 0, + end_column: 0, + annotation_level: 'failure', + title: 'test_sample.test_which_fails', + message: "AssertionError: assert 'test' == 'xyz'\n \n - xyz\n + test", + raw_details: + "def test_which_fails():\n event = { 'attr': 'test'}\n> assert event['attr'] == 'xyz'\nE AssertionError: assert 'test' == 'xyz'\nE \nE - xyz\nE + test\n\npython/test_sample.py:10: AssertionError" + }, + { + path: 'python/test_sample.py', + start_line: 14, + end_line: 14, + start_column: 0, + end_column: 0, + annotation_level: 'failure', + title: 'test_sample.test_with_error', + message: "AttributeError: 'dict' object has no attribute 'attr'", + raw_details: + "def test_with_error():\n event = { 'attr': 'test'}\n> assert event.attr == 'test'\nE AttributeError: 'dict' object has no attribute 'attr'\n\npython/test_sample.py:14: AttributeError" + } + ]); + }); + it('should parse go results', async () => { + const {count, skipped, annotations} = await parseFile('go/report.xml', true); + + expect(count).toBe(3); + expect(skipped).toBe(0); + // noinspection RegExpRepeatedSpace + expect(annotations).toStrictEqual([ + { + path: 'go/main_test.go', + start_line: 12, + end_line: 12, + start_column: 0, + end_column: 0, + annotation_level: 'failure', + title: 'main_test.go.TestFailing', + message: 'Failed', + raw_details: 'main_test.go:12: failing test' + }, + { + path: 'go/utils/string_test.go', + start_line: 7, + end_line: 7, + start_column: 0, + end_column: 0, + annotation_level: 'failure', + title: 'string_test.go.TestFailing', + message: 'Failed', + raw_details: expect.stringMatching(new RegExp(`string_test.go:7: +\\s*Error Trace:.*action-surefire-report/go/utils/string_test.go:7 +\\s*Error: \\s*Not equal: +\\s*expected: "1" +\\s*actual : "2" +\\s* +\\s*Diff: +\\s*--- Expected +\\s*\\+\\+\\+ Actual +\\s*@@ -1 \\+1 @@ +\\s*-1 +\\s*\\+2 +\\s*Test:\\s*TestFailing`)) + }, + ]); + }); + it('should parse custom report with details as an array', async () => { + const { count, skipped, annotations } = await parseFile( + 'custom_reports/TEST-pro.taskana.common.api.ListUtilTest-H2.xml' + ); + + expect(count).toBe(1); + expect(skipped).toBe(0); + expect(annotations).toStrictEqual([ + { + path: 'pro/taskana/common/api/ListUtilTest(H2)', + start_line: 22, + end_line: 22, + start_column: 0, + end_column: 0, + annotation_level: 'failure', + title: 'ListUtilTest.should_SplitListIntoChunks_When_CallingPartitionBasedOnSize', + message: 'java.lang.AssertionError:', + raw_details: + 'java.lang.AssertionError: \n' + + '\n' + + 'Expected size:<11> but was:<10> in:\n' + + '<[[1,\n' + + ' 2,\n' + + ' 3,\n' + + ' 4,\n' + + ' 5,\n' + + ' 6,\n' + + ' 7,\n' + + ' 96,\n' + + ' 97,\n' + + ' 98,\n' + + ' 99,\n' + + ' 100],\n' + + ' [101,\n' + + ' 102,\n' + + ' 103,\n' + + ' 104,\n' + + ' 194,\n' + + ' 195,\n' + + ' 196,\n' + + ' 197,\n' + + ' 198,\n' + + ' 199,\n' + + ' 200],\n' + + ' [201,\n' + + ' 202,\n' + + ' 997,\n' + + ' 998,\n' + + ' 999,\n' + + ' 1000]]>\n' + + '\tat pro.taskana.common.api.ListUtilTest.should_SplitListIntoChunks_When_CallingPartitionBasedOnSize(ListUtilTest.java:22)' + } + ]); + }); + + it('should parse custom report with flaky failures', async () => { + const { count, skipped, annotations } = await parseFile( + 'custom_reports/TEST-test.MyIntegrationTestSuite.xml' + ); + + expect(count).toBe(5); + expect(skipped).toBe(0); + expect(annotations).toStrictEqual([ + { + path: 'test/MyIntegrationTest', + start_line: 43, + end_line: 43, + start_column: 0, + end_column: 0, + annotation_level: 'failure', + title: 'MyIntegrationTest.testGetMails', + message: + 'JSON path "$.mails[0].subject"\n' + + 'Expected: "MySubject"\n' + + ' but: was "YourSubject"', + raw_details: + 'java.lang.AssertionError: \n' + + 'JSON path "$.mails[0].subject"\n' + + 'Expected: "MySubject"\n' + + ' but: was "YourSubject"\n' + + ' at test.MyIntegrationTest.testGetMails(MyIntegrationTest.java:43)\n' + + '\n' + + ' 2021-02-05 09:11:05.249 INFO [,,,] 2909 --- [ main] o.s.b.t.m.w.SpringBootMockServletContext : Initializing Spring TestDispatcherServlet \'\'\n' + + '2021-02-05 09:11:05.249 INFO [,,,] 2909 --- [ main] o.s.t.web.servlet.TestDispatcherServlet : Initializing Servlet \'\'\n' + + '2021-02-05 09:11:05.255 INFO [,,,] 2909 --- [ main] o.s.t.web.servlet.TestDispatcherServlet : Completed initialization in 6 ms', + }, + { + path: 'test/DocumentUploadIntegrationTest', + start_line: 33, + end_line: 33, + start_column: 0, + end_column: 0, + annotation_level: 'failure', + title: + 'DocumentUploadIntegrationTest.shouldReturnBadRequestIfDocumentTypeIsInvalid', + message: 'Status expected:<400> but was:<403>', + raw_details: + 'java.lang.AssertionError: Status expected:<400> but was:<403>\n' + + '\tat test.DocumentUploadIntegrationTest.shouldReturnBadRequestIfDocumentTypeIsInvalid(DocumentUploadIntegrationTest.java:33)' + }, + { + path: 'test/DocumentUploadIntegrationTest', + start_line: 23, + end_line: 23, + start_column: 0, + end_column: 0, + annotation_level: 'failure', + title: 'DocumentUploadIntegrationTest.shouldReturnSuccessResponse', + message: 'Status expected:<200> but was:<403>', + raw_details: + 'java.lang.AssertionError: Status expected:<200> but was:<403>\n' + + ' at test.DocumentUploadIntegrationTest.shouldReturnSuccessResponse(DocumentUploadIntegrationTest.java:23)\n' + + '\n' + + ' 2021-02-05 09:11:11.668 INFO [,,,] 2909 --- [ main] o.s.b.t.m.w.SpringBootMockServletContext : Initializing Spring TestDispatcherServlet \'\'\n' + + '2021-02-05 09:11:11.668 INFO [,,,] 2909 --- [ main] o.s.t.web.servlet.TestDispatcherServlet : Initializing Servlet \'\'\n' + + '2021-02-05 09:11:11.673 INFO [,,,] 2909 --- [ main] o.s.t.web.servlet.TestDispatcherServlet : Completed initialization in 5 ms', + }, + { + path: 'test/DocumentUploadIntegrationTest', + start_line: 47, + end_line: 47, + start_column: 0, + end_column: 0, + annotation_level: 'failure', + title: 'DocumentUploadIntegrationTest.shouldReturnBadRequestIfDocumentSizeIsZero', + message: 'Status expected:<400> but was:<403>', + raw_details: + 'java.lang.AssertionError: Status expected:<400> but was:<403>\n' + + '\tat test.DocumentUploadIntegrationTest.shouldReturnBadRequestIfDocumentSizeIsZero(DocumentUploadIntegrationTest.java:47)' + } + ]); + }); +});