diff --git a/.eslintrc.json b/.eslintrc.json index 1a8e951..e049a8e 100644 --- a/.eslintrc.json +++ b/.eslintrc.json @@ -1,54 +1,94 @@ { - "plugins": ["jest", "@typescript-eslint"], - "extends": ["plugin:github/recommended"], - "parser": "@typescript-eslint/parser", - "parserOptions": { - "ecmaVersion": 9, - "sourceType": "module", - "project": "./tsconfig.json" + "root": true, + "ignorePatterns": ["**/*"], + "plugins": ["@nrwl/nx"], + "overrides": [ + { + "files": ["*.ts", "*.tsx", "*.js", "*.jsx"], + "excludedFiles": ["*.stories.ts"], + "rules": { + "@nrwl/nx/enforce-module-boundaries": [ + "error", + { + "enforceBuildableLibDependency": true, + "allow": [], + "depConstraints": [ + { + "sourceTag": "scope:app", + "onlyDependOnLibsWithTags": ["*"] + }, + { + "sourceTag": "scope:core", + "onlyDependOnLibsWithTags": ["scope:core", "scope:testing"] + }, + { + "sourceTag": "scope:shared", + "onlyDependOnLibsWithTags": [ + "scope:core", + "scope:shared", + "scope:legacy", + "scope:testing", + "scope:maps", + "scope:quotes" + ] + }, + { + "sourceTag": "scope:maps", + "onlyDependOnLibsWithTags": ["scope:core", "scope:shared", "scope:legacy", "scope:testing"] + }, + { + "sourceTag": "scope:quotes", + "onlyDependOnLibsWithTags": [ + "scope:core", + "scope:shared", + "scope:legacy", + "scope:quotes", + "scope:maps", + "scope:testing" + ] + }, + { + "sourceTag": "scope:aeon", + "onlyDependOnLibsWithTags": ["scope:core", "scope:shared", "scope:legacy", "scope:aeon"] + }, + { + "sourceTag": "scope:legacy", + "onlyDependOnLibsWithTags": ["scope:legacy", "scope:core"] + }, + { + "sourceTag": "scope:configs-client", + "onlyDependOnLibsWithTags": [ + "scope:configs-client", + "scope:core", + "scope:configs", + "scope:shared", + "scope:legacy", + "scope:testing" + ] + }, + { + "sourceTag": "scope:configs", + "onlyDependOnLibsWithTags": [ + "scope:configs", + "scope:core", + "scope:legacy", + "scope:shared", + "scope:testing" + ] + } + ] + } + ] + } }, - "rules": { - "eslint-comments/no-use": "off", - "import/no-namespace": "off", - "no-unused-vars": "off", - "@typescript-eslint/no-unused-vars": "error", - "@typescript-eslint/explicit-member-accessibility": ["error", {"accessibility": "no-public"}], - "@typescript-eslint/no-require-imports": "error", - "@typescript-eslint/array-type": "error", - "@typescript-eslint/await-thenable": "error", - "@typescript-eslint/ban-ts-comment": "error", - "camelcase": "off", - "@typescript-eslint/consistent-type-assertions": "error", - "@typescript-eslint/explicit-function-return-type": ["error", {"allowExpressions": true}], - "@typescript-eslint/func-call-spacing": ["error", "never"], - "@typescript-eslint/no-array-constructor": "error", - "@typescript-eslint/no-empty-interface": "error", - "@typescript-eslint/no-explicit-any": "error", - "@typescript-eslint/no-extraneous-class": "error", - "@typescript-eslint/no-for-in-array": "error", - "@typescript-eslint/no-inferrable-types": "error", - "@typescript-eslint/no-misused-new": "error", - "@typescript-eslint/no-namespace": "error", - "@typescript-eslint/no-non-null-assertion": "warn", - "@typescript-eslint/no-unnecessary-qualifier": "error", - "@typescript-eslint/no-unnecessary-type-assertion": "error", - "@typescript-eslint/no-useless-constructor": "error", - "@typescript-eslint/no-var-requires": "error", - "@typescript-eslint/prefer-for-of": "warn", - "@typescript-eslint/prefer-function-type": "warn", - "@typescript-eslint/prefer-includes": "error", - "@typescript-eslint/prefer-string-starts-ends-with": "error", - "@typescript-eslint/promise-function-async": "error", - "@typescript-eslint/require-array-sort-compare": "error", - "@typescript-eslint/restrict-plus-operands": "error", - "semi": "off", - "@typescript-eslint/semi": ["error", "never"], - "@typescript-eslint/type-annotation-spacing": "error", - "@typescript-eslint/unbound-method": "error" - }, - "env": { - "node": true, - "es6": true, - "jest/globals": true + { + "files": ["*.ts"], + "extends": ["plugin:@nrwl/nx/typescript"], + "rules": { + "@typescript-eslint/no-unused-vars": "off", + "@typescript-eslint/no-empty-function": "off", + "@typescript-eslint/no-this-alias": "off" + } } - } \ No newline at end of file + ] +} diff --git a/.prettierrc.json b/.prettierrc.json index c34bafc..987c669 100644 --- a/.prettierrc.json +++ b/.prettierrc.json @@ -1,10 +1,7 @@ { - "printWidth": 80, - "tabWidth": 2, - "useTabs": false, - "semi": false, + "printWidth": 120, "singleQuote": true, - "trailingComma": "none", - "bracketSpacing": false, - "arrowParens": "avoid" + "useTabs": false, + "arrowParens": "avoid", + "endOfLine": "crlf" } diff --git a/README.md b/README.md index 68d5d07..f2516cd 100644 --- a/README.md +++ b/README.md @@ -2,104 +2,116 @@ typescript-action status

-# Create a JavaScript Action using TypeScript - -Use this template to bootstrap the creation of a TypeScript action.:rocket: - -This template includes compilation support, tests, a validation workflow, publishing, and versioning guidance. - -If you are new, there's also a simpler introduction. See the [Hello World JavaScript Action](https://github.com/actions/hello-world-javascript-action) - -## Create an action from this template - -Click the `Use this Template` and provide the new repo details for your action - -## Code in Main - -> First, you'll need to have a reasonably modern version of `node` handy. This won't work with versions older than 9, for instance. - -Install the dependencies -```bash -$ npm install -``` - -Build the typescript and package it for distribution -```bash -$ npm run build && npm run package -``` - -Run the tests :heavy_check_mark: -```bash -$ npm test - - PASS ./index.test.js - ✓ throws invalid number (3ms) - ✓ wait 500 ms (504ms) - ✓ test runs (95ms) - -... -``` - -## Change action.yml - -The action.yml contains defines the inputs and output for your action. - -Update the action.yml with your name, description, inputs and outputs for your action. - -See the [documentation](https://help.github.com/en/articles/metadata-syntax-for-github-actions) - -## Change the Code - -Most toolkit and CI/CD operations involve async operations so the action is run in an async function. - -```javascript -import * as core from '@actions/core'; -... - -async function run() { - try { - ... - } - catch (error) { - core.setFailed(error.message); - } -} - -run() -``` - -See the [toolkit documentation](https://github.com/actions/toolkit/blob/master/README.md#packages) for the various packages. - -## Publish to a distribution branch - -Actions are run from GitHub repos so we will checkin the packed dist folder. - -Then run [ncc](https://github.com/zeit/ncc) and push the results: -```bash -$ npm run package -$ git add dist -$ git commit -a -m "prod dependencies" -$ git push origin releases/v1 -``` - -Note: We recommend using the `--license` option for ncc, which will create a license file for all of the production node modules used in your project. - -Your action is now published! :rocket: - -See the [versioning documentation](https://github.com/actions/toolkit/blob/master/docs/action-versioning.md) - -## Validate - -You can now validate the action by referencing `./` in a workflow in your repo (see [test.yml](.github/workflows/test.yml)) - -```yaml -uses: ./ -with: - milliseconds: 1000 -``` - -See the [actions tab](https://github.com/actions/typescript-action/actions) for runs of this action! :rocket: - -## Usage: - -After testing you can [create a v1 tag](https://github.com/actions/toolkit/blob/master/docs/action-versioning.md) to reference the stable and latest V1 action +# Microservices version auto bumping + +This action helps to automatically bump version files, create tag and a release when a closed pull-request with specific labels containing the service name and the release type is found. +The list of files that contain the version that need to be changed will updated in the future depending on usage requirement. At the moment, version files of Helm charts and .Net core projects are supported. +However it is not necessary to change files to tag and create a release. + +More paramaters and outputs will be added in the future. + +## Usage + +This example workflow contains a condition on job level as said before for the workflow to run. +In order to avoid multiple useless versions bumping a guard exist to run the workflow only once with the same context. +if an issue occurs, warning will be added to the run summary. + +It is important to checkout the master/main branch before and set the git config. + +For a manual run, providing service_name and release_type parameter is necessary. + +```YAML +name: Version Bumping + +on: + workflow_dispatch: + inputs: + release_type: + description: "Major, Minor or Patch" + required: true + service: + description: "Service name" + required: true + service_path: + description: "The service path" + required: true + pull_request: + types: + - closed + +jobs: + setup: + runs-on: ubuntu-latest + if: | + github.event_name == 'workflow_dispatch' || + (github.event.pull_request.merged == true && + (contains(toJson(github.event.pull_request.labels.*.name), ':patch') || + contains(toJson(github.event.pull_request.labels.*.name), ':minor') || + contains(toJson(github.event.pull_request.labels.*.name), ':major'))) + concurrency: version-bumping + steps: + - name: Setting variables + if: github.event_name != 'workflow_dispatch' + run: | + echo "UNIQUE_FILE_NAME=${{ github.workflow }}-${{ github.run_id }}-${{ github.run_number }}" >> $GITHUB_ENV + echo "CACHE_PATH=${{ github.workspace }}/firstrun" >> $GITHUB_ENV + + - name: Cache workflow run + if: github.event_name != 'workflow_dispatch' + id: cache-workflow-run + uses: actions/cache@v2 + env: + cache-name: ${{ env.UNIQUE_FILE_NAME }} + with: + path: ${{ env.CACHE_PATH }} + key: ${{ runner.os }}-${{ env.cache-name }} + + - name: "Checkout" + if: steps.cache-workflow-run.outputs.cache-hit != 'true' + uses: actions/checkout@v2 + with: + ref: master + - run: | + git config --global user.email "${{ secrets.AUTO_BUMP_MAIL }}" + git config --global user.name "${{ secrets.AUTO_BUMP_NAME }}" + + - name: Autobumping + if: steps.cache-workflow-run.outputs.cache-hit != 'true' && github.event_name != 'workflow_dispatch' + uses: cactusoft-ca/microservices-versioning@main + id: microservices_versioning + with: + pull_number: ${{ github.event.number }} + owner: cactusoft-ca + repo: microservices-versioning + token: ${{ secrets.GITHUB_TOKEN }} + working_directory: ${{ github.workspace }} + services_path: "services" + custom_services_path: | + service2,custom/service2/path + + - name: Manual autobumping + if: steps.cache-workflow-run.outputs.cache-hit != 'true' && github.event_name == 'workflow_dispatch' + uses: cactusoft-ca/microservices-versioning@main + with: + pull_number: ${{ github.event.number }} + owner: cactusoft-ca + repo: microservices-versioning + token: ${{ secrets.GITHUB_TOKEN }} + working_directory: ${{ github.workspace }} + service_name: ${{ github.event.inputs.service_name }} + # release type: Patch, minor or major + release_type: ${{ github.event.inputs.release_type }} + # service_path ex: direct/path/to/services2 + service_path: ${{ github.event.inputs.service_path }} + + # results is empty atm + - name: Saving first run results + if: github.event_name != 'workflow_dispatch' && steps.cache-workflow-run.outputs.cache-hit == 'true' + run: | + echo "${{ steps.microservices_versioning.outputs.results }}" > ${{ env.CACHE_PATH }} + + - name: Workflow already triggered + if: github.event_name != 'workflow_dispatch' && steps.cache-workflow-run.outputs.cache-hit == 'true' + run: | + echo "Already runned" > ${{ env.CACHE_PATH }} +``` \ No newline at end of file diff --git a/__tests__/main.test.ts b/__tests__/main.test.ts index 98f44c5..7b22aa4 100644 --- a/__tests__/main.test.ts +++ b/__tests__/main.test.ts @@ -1,29 +1,28 @@ -import {wait} from '../src/wait' -import * as process from 'process' -import * as cp from 'child_process' -import * as path from 'path' -import {expect, test} from '@jest/globals' +// import * as process from 'process' +// import * as cp from 'child_process' +// import * as path from 'path' +// import {expect, test} from '@jest/globals' -test('throws invalid number', async () => { - const input = parseInt('foo', 10) - await expect(wait(input)).rejects.toThrow('milliseconds not a number') -}) +// test('throws invalid number', async () => { +// const input = parseInt('foo', 10) +// await expect(wait(input)).rejects.toThrow('milliseconds not a number') +// }) -test('wait 500 ms', async () => { - const start = new Date() - await wait(500) - const end = new Date() - var delta = Math.abs(end.getTime() - start.getTime()) - expect(delta).toBeGreaterThan(450) -}) +// test('wait 500 ms', async () => { +// const start = new Date() +// await wait(500) +// const end = new Date() +// var delta = Math.abs(end.getTime() - start.getTime()) +// expect(delta).toBeGreaterThan(450) +// }) -// shows how the runner will run a javascript action with env / stdout protocol -test('test runs', () => { - process.env['INPUT_MILLISECONDS'] = '500' - const np = process.execPath - const ip = path.join(__dirname, '..', 'lib', 'main.js') - const options: cp.ExecFileSyncOptions = { - env: process.env - } - console.log(cp.execFileSync(np, [ip], options).toString()) -}) +// // shows how the runner will run a javascript action with env / stdout protocol +// test('test runs', () => { +// process.env['INPUT_MILLISECONDS'] = '500' +// const np = process.execPath +// const ip = path.join(__dirname, '..', 'lib', 'main.js') +// const options: cp.ExecFileSyncOptions = { +// env: process.env +// } +// console.log(cp.execFileSync(np, [ip], options).toString()) +// }) diff --git a/action.yml b/action.yml index bfbb165..fd891e2 100644 --- a/action.yml +++ b/action.yml @@ -1,11 +1,38 @@ -name: 'Your name here' -description: 'Provide a description here' -author: 'Your name or organization here' +name: 'Microservices versioning' +description: 'This actions is about upping versions of each microservice automatically' +author: 'Mostefa Kamal Lala' inputs: - milliseconds: # change this + pull_number: + required: false + description: 'The pull request number, if not provided will take the one from context if not manually ran' + owner: required: true - description: 'input description here' - default: 'default value if applicable' + description: 'Owner of pull request repo, if not provided will take the one from context' + repo: + required: true + description: 'Repo name, if not provided will take the one from context' + token: + required: true + description: 'Github token, if not provided will take the one from context' + working_directory: + required: true + description: 'The working directory of the repo' + service_name: + required: false + description: The service name to bump when running manually the workflow + release_type: + required: false + description: The service release type when running manually the workflow (patch, minor, major) + service_path: + required: false + description: 'The service path when running manually the workflow' + services_path: + required: false + description: 'The relative path where each microservice is in repo for changing versions in files' + default: 'services' + custom_services_path: + required: false + description: 'A list of comma separated relative path by microservice that are not in the common place in the repo. ' runs: using: 'node12' main: 'dist/index.js' diff --git a/dist/index.js b/dist/index.js index cab9718..2e5c511 100644 --- a/dist/index.js +++ b/dist/index.js @@ -1,31 +1,175 @@ -require('./sourcemap-register.js');module.exports = -/******/ (() => { // webpackBootstrap -/******/ "use strict"; +require('./sourcemap-register.js');/******/ (() => { // webpackBootstrap /******/ var __webpack_modules__ = ({ -/***/ 109: -/***/ (function(__unused_webpack_module, exports, __webpack_require__) { +/***/ 79275: +/***/ ((__unused_webpack_module, exports) => { +"use strict"; -var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { - if (k2 === undefined) k2 = k; - Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } }); -}) : (function(o, m, k, k2) { - if (k2 === undefined) k2 = k; - o[k2] = m[k]; -})); -var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { - Object.defineProperty(o, "default", { enumerable: true, value: v }); -}) : function(o, v) { - o["default"] = v; -}); -var __importStar = (this && this.__importStar) || function (mod) { - if (mod && mod.__esModule) return mod; - var result = {}; - if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k); - __setModuleDefault(result, mod); - return result; +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.VersionFileType = void 0; +var VersionFileType; +(function (VersionFileType) { + VersionFileType["DotNetCore"] = "DotNetCore"; + VersionFileType["Helm"] = "Helm"; +})(VersionFileType = exports.VersionFileType || (exports.VersionFileType = {})); + + +/***/ }), + +/***/ 56424: +/***/ (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()); + }); +}; +var __importDefault = (this && this.__importDefault) || function (mod) { + return (mod && mod.__esModule) ? mod : { "default": mod }; }; +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.GitService = void 0; +const simple_git_1 = __importDefault(__nccwpck_require__(91477)); +const core_1 = __nccwpck_require__(42186); +const graphql_1 = __nccwpck_require__(88467); +const github_1 = __nccwpck_require__(95438); +class GitService { + constructor(repo, token) { + core_1.debug(`Context repo owner from GitService: ${github_1.context.repo.owner}`); + this.git = simple_git_1.default(repo, { binary: 'git' }); + core_1.debug(`Is git repo: ${JSON.stringify(this.git.checkIsRepo())}`); + this.token = token; + } + addFile(path) { + return __awaiter(this, void 0, void 0, function* () { + const result = yield this.git.add(path); + core_1.debug(result); + return result; + }); + } + commit(message) { + return __awaiter(this, void 0, void 0, function* () { + try { + core_1.debug(`Commiting ${message}`); + const result = yield this.git.commit(message); + core_1.debug(`Commit result ${JSON.stringify(result, null, 2)}`); + return result; + } + catch (error) { + throw new Error(`FATAL: An error occured while commiting: "${message}.\n ${error}`); + } + }); + } + commitGeneratedCode(message) { + return __awaiter(this, void 0, void 0, function* () { + const status = yield this.git.status(); + console.log(`Status: ${JSON.stringify(status, null, 2)}`); + if (status.files.length > 0) { + const add = yield this.git.add(status.files.map(x => x.path)); + console.log(add); + return yield this.commit(message); + } + return status; + }); + } + createAnnotatedTag(service) { + return __awaiter(this, void 0, void 0, function* () { + try { + core_1.debug(`Creating an annonated tag for service ${service.name}`); + const result = yield this.git.addAnnotatedTag(service.getNextVersionTag(), service.getNextVersionMessage()); + core_1.debug(`Creating an annonated tag result ${JSON.stringify(result, null, 2)}`); + return result; + } + catch (error) { + core_1.warning(error); + throw new Error(`FATAL: An error occured while creating a new tag for service: "${service.name}.\n ${error}`); + } + }); + } + pushAll(service) { + return __awaiter(this, void 0, void 0, function* () { + try { + core_1.debug(`Pushing all changes service ${service.name}`); + const pushRes = yield this.git.push(); + core_1.debug(`Push result ${JSON.stringify(pushRes, null, 2)}`); + const tagPushRes = yield this.git.pushTags(); + core_1.debug(`Tag push result ${JSON.stringify(tagPushRes, null, 2)}`); + return [pushRes, tagPushRes]; + } + catch (error) { + throw new Error(`FATAL: An error occured while pushing commits and new tag for service: "${service.name}.\n ${error}`); + } + }); + } + getLatestTagByServiceName(serviceName, owner, repo) { + return __awaiter(this, void 0, void 0, function* () { + core_1.debug(`GH GraphQL API - Getting current version for ${serviceName} from ${owner}/${repo}`); + const graphqlWithAuth = graphql_1.graphql.defaults({ + headers: { + authorization: `token ${this.token}`, + }, + }); + const { repository } = yield graphqlWithAuth(` + { + repository(owner: "${owner}", name: "${repo}") { + refs(refPrefix: "refs/tags/", query: "${serviceName}", orderBy: {field: TAG_COMMIT_DATE, direction: ASC}, last: 1) { + edges { + node { + name + } + } + } + } + } + `); + core_1.debug(`GH GraphQl result: \n ${JSON.stringify(repository, null, 2)}`); + const result = repository.refs.edges[0].node.name.replace(`${serviceName}/v`, ''); + return result; + }); + } + createRelease(owner, repo, tag, body, draft = true, prerelease = true) { + return __awaiter(this, void 0, void 0, function* () { + try { + core_1.debug(`Creating release with tag ${tag} for ${owner}/${repo} `); + // Get authenticated GitHub client (Ocktokit): https://github.com/actions/toolkit/tree/master/packages/github#usage + const octokit = github_1.getOctokit(this.token); + // Create a release + // API Documentation: https://developer.github.com/v3/repos/releases/#create-a-release + // Octokit Documentation: https://octokit.github.io/rest.js/#octokit-routes-repos-create-release + const createReleaseResponse = yield octokit.rest.repos.createRelease({ + owner, + repo, + tag_name: tag, + name: tag, + body: body, + draft, + prerelease + }); + return createReleaseResponse; + } + catch (error) { + core_1.setFailed(error.message); + } + }); + } +} +exports.GitService = GitService; + + +/***/ }), + +/***/ 3109: +/***/ (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) { @@ -36,31 +180,217 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge }); }; Object.defineProperty(exports, "__esModule", ({ value: true })); -const core = __importStar(__webpack_require__(186)); -const wait_1 = __webpack_require__(817); +const core_1 = __nccwpck_require__(42186); +const github_1 = __nccwpck_require__(95438); +const linq_to_typescript_1 = __nccwpck_require__(39657); +const fs_1 = __nccwpck_require__(35747); +const js_yaml_1 = __nccwpck_require__(21917); +const path_1 = __nccwpck_require__(85622); +const service_paths_1 = __nccwpck_require__(7529); +const version_files_1 = __nccwpck_require__(274); +const service_sem_ver_1 = __nccwpck_require__(32973); +const git_service_1 = __nccwpck_require__(56424); function run() { return __awaiter(this, void 0, void 0, function* () { try { - const ms = core.getInput('milliseconds'); - core.debug(`Waiting ${ms} milliseconds ...`); // debug is only output if you set the secret `ACTIONS_RUNNER_DEBUG` to true - core.debug(new Date().toTimeString()); - yield wait_1.wait(parseInt(ms, 10)); - core.debug(new Date().toTimeString()); - core.setOutput('time', new Date().toTimeString()); + const pull_number = core_1.getInput('pull_number'); + const owner = core_1.getInput('owner'); + const repo = core_1.getInput('repo'); + const token = core_1.getInput('token'); + const workingDirectory = core_1.getInput('working_directory', { required: true }); + const servicesPath = core_1.getInput('services_path'); + const servicePath = core_1.getInput('service_path'); + const customServicesPaths = core_1.getMultilineInput('custom_services_path').map(function (x) { + return new service_paths_1.ServicePaths(x.split(',')[0], x.split(',')[1]); + }); + const serviceName = core_1.getInput('service_name'); + const releaseType = core_1.getInput('release_type'); + const git = new git_service_1.GitService(workingDirectory, token); + const uniqueService = serviceName !== ""; + core_1.debug(`customServicesPaths:\n ${JSON.stringify(customServicesPaths, null, 2)}`); + core_1.debug(`Context repo owner: ${github_1.context.repo.owner}`); + core_1.debug(`Checking labels for pull request number ${pull_number}`); + const octokit = github_1.getOctokit(token); + let bumpLabels; + const versionPriorities = ['major', 'minor', 'patch']; + if (uniqueService) { + if (releaseType === "") { + throw new Error(`A release type must be provided in order to bump service: "${serviceName}"`); + } + if (servicePath === "") { + throw new Error(`A service path must be provided in order to bump service: "${serviceName}"`); + } + if (!versionPriorities.includes(releaseType)) { + throw new Error(`A release type must be either Major, Minor or Patch`); + } + bumpLabels = [`${serviceName}:${releaseType}`]; + } + else { + const pull = yield octokit.request('GET /repos/{owner}/{repo}/pulls/{pull_number}', { + owner, + repo, + pull_number: Number(pull_number) + }); + const tags = pull.data.labels.map(a => a == null ? '' : a.name); + bumpLabels = tags.filter(x => versionPriorities.some(x.includes.bind(x))); + } + core_1.debug(`Versioning Labels ${JSON.stringify(bumpLabels, null, 2)}`); + let errors = new Array(); + let versionsByService = linq_to_typescript_1.from(bumpLabels).groupBy(function (x) { return x.split(':')[0]; }) + .select(function (x) { + let servicePaths = null; + try { + servicePaths = setServicePaths(x.key, workingDirectory, servicesPath, customServicesPaths, uniqueService, servicePath); + } + catch (error) { + core_1.debug(`SetServicePaths ERROR: ${error}`); + core_1.debug(`setServicePaths Service: ${x.key} push errors: ${JSON.stringify(error, Object.getOwnPropertyNames(error), 2)}`); + errors.push({ service: x.key, error: error.message }); + } + return new service_sem_ver_1.ServiceSemVer(x.key, JSON.stringify(x.select(x => x.split(':')[1]).toArray().sort(function (a, b) { + const aKey = versionPriorities.indexOf(a); + const bKey = versionPriorities.indexOf(b); + return aKey - bKey; + })[0]).replace(/['"]+/g, ''), servicePaths, git); + }).toArray(); + const unexistantServices = errors.filter(x => x.error.includes('An expected service root folder is missing')).map(x => x.service); + core_1.debug(`List of unexistant services:\n ${JSON.stringify(unexistantServices, null, 2)}`); + versionsByService = versionsByService.filter(svc => !unexistantServices.includes(svc.name)); + if (versionsByService.length === 0) { + core_1.debug('No service to bump'); + setOutputsAndAnnotations(errors, versionsByService); + return; + } + for (const service of versionsByService) { + try { + const currentVersion = yield git.getLatestTagByServiceName(service.name, owner, repo); + yield service.setVersions(currentVersion, git); + } + catch (error) { + core_1.debug(`setVersions Service: ${service.name} push errors: ${JSON.stringify(error, null, 2)}`); + errors.push({ service: service.name, error: error.message }); + } + } + setOutputsAndAnnotations(errors, versionsByService); } catch (error) { - core.setFailed(error.message); + core_1.setFailed(error.message); } }); } run(); +function setOutputsAndAnnotations(errors, versionsByService) { + core_1.debug('Setting outputs'); + const fatalErrors = errors.filter(x => x.error.includes('FATAL')).map(x => x.service); + const allFailed = [...new Set(fatalErrors)].length === versionsByService.length; + if (allFailed) { + core_1.debug('All services failed'); + throw new Error(JSON.stringify(errors, null, 2)); + } + if (errors.length > 0) { + for (const error of errors) { + if (error.error.includes('An expected service root folder is missing')) { + core_1.error(`Service not BUMPED: "${error.service}".\n ${error.error}`); + } + else { + core_1.warning(`Service bump warning:: "${error.service}".\n ${error.error}`); + } + } + } + let results = new Array(); + for (const svc of versionsByService) { + results.push({ + service: svc.name, + releaseType: svc.releaseType, + oldVersion: svc.currentVersion, + newVersion: svc.getBumpedVersion(), + modifiedFiles: svc.modifedFiles, + tagged: svc.tagged, + released: svc.released, + releaseURL: svc.releaseURL + }); + } + core_1.setOutput('results', JSON.stringify(results, null, 2)); +} +function getVersionFilesTypesAndPaths(serviceName, metadataFilePath, workingDirectory) { + const versionFiles = new Array(); + try { + const doc = js_yaml_1.load(fs_1.readFileSync(metadataFilePath, { encoding: "utf8" })); + if (doc.versionFiles === null || doc.versionFiles === undefined) { + throw new Error(); + } + for (const vFile of doc.versionFiles) { + core_1.debug(`Versioning metadata for ${serviceName}: ${vFile.type} : ${vFile.path}`); + versionFiles.push(new version_files_1.VersionFiles(vFile.type, path_1.join(workingDirectory, vFile.path), vFile.path)); + } + return versionFiles; + } + catch (err) { + if (err && err.code == 'ENOENT') { + throw new Error(`Versioning file metadata not found for ${serviceName}. + Searched Path: ${metadataFilePath}, the service will be released without any version files changed \n ${err}`); + } + else { + throw err; + } + } +} +function setServicePaths(name, workingDirectory, servicesPath, customServicePaths, uniqueService, uniqueServicePath) { + core_1.debug(`Setting service path for ${name}`); + const servicePaths = new service_paths_1.ServicePaths(); + const customeServiceNames = customServicePaths.map(function (x) { return x.name; }); + const customServicePathIndex = customeServiceNames.indexOf(name); + let serviceRootPath; + if (customServicePathIndex === -1) { + if (uniqueService) { + serviceRootPath = path_1.join(workingDirectory, uniqueServicePath); + } + else { + serviceRootPath = path_1.join(workingDirectory, servicesPath, name); + } + } + else { + if (customServicePaths[customServicePathIndex].path === null) { + throw Error(`No custom path was found for service ${name}`); + } + serviceRootPath = path_1.join(workingDirectory, customServicePaths[customServicePathIndex].path); + core_1.debug(`Setting custom path for service ${name} to ${serviceRootPath}`); + } + if (!fs_1.existsSync(serviceRootPath)) { + throw new Error(`FATAL: An expected service root folder is missing. Service name: ${name}, Path: ${serviceRootPath}\nMake sure to checkout your repo`); + } + servicePaths.path = serviceRootPath; + core_1.debug(`Root folder for service ${name} has been set to ${serviceRootPath}`); + servicePaths.versionFiles = getVersionFilesTypesAndPaths(name, path_1.join(serviceRootPath, 'versioning.yaml'), workingDirectory); + return servicePaths; +} /***/ }), -/***/ 817: -/***/ (function(__unused_webpack_module, exports) { +/***/ 7529: +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.ServicePaths = void 0; +class ServicePaths { + constructor(name = null, path = null, versionFiles = null) { + this.name = name; + this.path = path; + this.versionFiles = versionFiles; + } +} +exports.ServicePaths = ServicePaths; + + +/***/ }), + +/***/ 32973: +/***/ (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); }); } @@ -72,36 +402,213 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge }); }; Object.defineProperty(exports, "__esModule", ({ value: true })); -exports.wait = void 0; -function wait(milliseconds) { - return __awaiter(this, void 0, void 0, function* () { - return new Promise(resolve => { - if (isNaN(milliseconds)) { - throw new Error('milliseconds not a number'); +exports.ServiceSemVer = void 0; +const semver_1 = __nccwpck_require__(11383); +const core_1 = __nccwpck_require__(42186); +const github_1 = __nccwpck_require__(95438); +class ServiceSemVer { + constructor(name, releaseType, paths, gitService) { + this.tagged = false; + this.released = false; + this.modifedFiles = new Array(); + this.releaseURL = ""; + core_1.debug(`Context repo owner from GitService: ${github_1.context.repo.owner}`); + this.name = name; + this.releaseType = releaseType; + this.paths = paths; + this.gitService = gitService; + } + getNextVersionTag() { + if (this.currentVersion === undefined) { + throw new Error('FATAL: Cannot provite a next version since current version is null'); + } + return `${this.name}/v${this.getBumpedVersion()}`; + } + getBumpedVersion() { + if (this.currentVersion === undefined) { + throw new Error('FATAL: Cannot provite a next version since current version is null'); + } + return semver_1.inc(this.currentVersion, this.releaseType); + } + getNextVersionMessage() { + if (this.currentVersion === undefined) { + throw new Error('FATAL: Cannot provite a next version since current version is null'); + } + return `Auto bump ${this.name} ${this.getNextVersionTag()} ${this.releaseType.toString()}`; + } + setVersions(currentVersion, git) { + return __awaiter(this, void 0, void 0, function* () { + try { + this.currentVersion = currentVersion; + if (this.paths === null || this.paths.versionFiles === null) { + core_1.warning(`No Version files to process for service "${this.name}"`); + yield this.CreateTag(git); + yield this.CreateRelease(git); + return; + } + const versionFiles = this.paths.versionFiles; + core_1.debug(`${versionFiles === null || versionFiles === void 0 ? void 0 : versionFiles.length} Version files to process for service "${this.name}"`); + core_1.debug(`${JSON.stringify(versionFiles, null, 2)}`); + for (const file of versionFiles) { + core_1.debug(`Processing version file of type: ${file.type}`); + if (file.fullPath === null) { + throw new Error(`FATAL: Full path is missing for version file of type: "${file.type}" for service: "${this.name}"`); + } + if (file.relativePath === null) { + throw new Error(`FATAL: Relative path is missing for version file of type: "${file.type}" for service: "${this.name}"`); + } + const result = yield file.setVersion(this, git); + if (result !== null) { + this.modifedFiles.push(result); + } + } + const commitRes = yield git.commit(this.getNextVersionMessage()); + core_1.debug(JSON.stringify(commitRes, null, 2)); + const generatedCodeCommitRes = yield git.commitGeneratedCode(`Generated files - upping ${this.getNextVersionTag}`); + console.log(JSON.stringify(generatedCodeCommitRes)); + yield this.CreateTag(git); + yield this.CreateRelease(git); + } + catch (error) { + throw new Error(`FATAL: An error occured while setting versions:\n ${error}`); } - setTimeout(() => resolve('done!'), milliseconds); }); + } + CreateTag(git) { + return __awaiter(this, void 0, void 0, function* () { + const tagRes = yield git.createAnnotatedTag(this); + core_1.debug(JSON.stringify(tagRes, null, 2)); + const pushRes = yield git.pushAll(this); + core_1.debug(JSON.stringify(pushRes, null, 2)); + this.tagged = true; + }); + } + CreateRelease(git) { + var _a; + return __awaiter(this, void 0, void 0, function* () { + const createReleaseRes = yield git.createRelease(github_1.context.repo.owner, github_1.context.repo.repo, this.getNextVersionTag(), "a body", true); + core_1.debug(JSON.stringify(createReleaseRes, null, 2)); + this.released = true; + this.releaseURL = (_a = createReleaseRes === null || createReleaseRes === void 0 ? void 0 : createReleaseRes.data.html_url) !== null && _a !== void 0 ? _a : ""; + }); + } +} +exports.ServiceSemVer = ServiceSemVer; + + +/***/ }), + +/***/ 274: +/***/ (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.VersionFiles = void 0; +const xml2js_1 = __nccwpck_require__(66189); +const fs_1 = __nccwpck_require__(35747); +const js_yaml_1 = __nccwpck_require__(21917); +const core_1 = __nccwpck_require__(42186); +const enums_1 = __nccwpck_require__(79275); +class VersionFiles { + constructor(type, fullPath, relativePath) { + this.type = type; + this.fullPath = fullPath; + this.relativePath = relativePath; + } + setVersion(service, gitClient) { + return __awaiter(this, void 0, void 0, function* () { + core_1.debug(`Setting version in file of type: ${this.type} located at: ${this.fullPath} for service: ${service.name}`); + switch (this.type) { + case enums_1.VersionFileType.DotNetCore: + yield this.setDotNetCoreBuildPropVersion(service, gitClient); + return { type: enums_1.VersionFileType.DotNetCore, path: this.relativePath }; + case enums_1.VersionFileType.Helm: + yield this.setHelmChartAppVersion(service, gitClient); + return { type: enums_1.VersionFileType.DotNetCore, path: this.relativePath }; + default: + core_1.warning(`No method found to modify version in file of type: ${this.type} located at: ${this.fullPath} for service: ${service.name}`); + return null; + } + }); + } + setDotNetCoreBuildPropVersion(service, gitClient) { + return __awaiter(this, void 0, void 0, function* () { + try { + const data = fs_1.readFileSync(this.fullPath, { encoding: "utf8" }); + const result = yield xml2js_1.parseStringPromise(data); + const nextVersion = service.getBumpedVersion(); + result.Project.PropertyGroup[0].Version = nextVersion; + const builder = new xml2js_1.Builder({ headless: true }); + const xml = builder.buildObject(result); + fs_1.writeFileSync(this.fullPath, xml); + core_1.debug(`Service "${service.name}": Updated .Net Core BuildPropVersion to ${nextVersion}. Path: ${this.fullPath}.\n New Content:\n ${xml}`); + yield gitClient.addFile(this.relativePath); + } + catch (err) { + throw new Error(`FATAL: An error occured trying to update helm chart for service ${service.name} - err: ${err}`); + } + }); + } + setHelmChartAppVersion(service, gitClient) { + return __awaiter(this, void 0, void 0, function* () { + try { + const file = fs_1.readFileSync(this.fullPath, { encoding: "utf8" }); + const doc = js_yaml_1.load(file); + const nextVersion = service.getBumpedVersion(); + doc.appVersion = nextVersion; + fs_1.writeFileSync(this.fullPath, js_yaml_1.dump(doc)); + core_1.debug(`Service ${service.name}: Updated Helm Chart appVersion to ${nextVersion}. Path: ${this.fullPath}.\n New Content:\n ${JSON.stringify(js_yaml_1.load(file), null, 2)}`); + yield gitClient.addFile(this.relativePath); + } + catch (err) { + throw new Error(`FATAL: An error occured trying to update helm chart for service ${service.name} - err: ${err}`); + } + }); + } } -exports.wait = wait; +exports.VersionFiles = VersionFiles; /***/ }), -/***/ 351: -/***/ (function(__unused_webpack_module, exports, __webpack_require__) { +/***/ 87351: +/***/ (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 (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k]; - result["default"] = mod; + 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 })); -const os = __importStar(__webpack_require__(87)); -const utils_1 = __webpack_require__(278); +exports.issue = exports.issueCommand = void 0; +const os = __importStar(__nccwpck_require__(12087)); +const utils_1 = __nccwpck_require__(5278); /** * Commands * @@ -173,10 +680,30 @@ function escapeProperty(s) { /***/ }), -/***/ 186: -/***/ (function(__unused_webpack_module, exports, __webpack_require__) { +/***/ 42186: +/***/ (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) { @@ -186,19 +713,13 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge step((generator = generator.apply(thisArg, _arguments || [])).next()); }); }; -var __importStar = (this && this.__importStar) || function (mod) { - if (mod && mod.__esModule) return mod; - var result = {}; - if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k]; - result["default"] = mod; - return result; -}; Object.defineProperty(exports, "__esModule", ({ value: true })); -const command_1 = __webpack_require__(351); -const file_command_1 = __webpack_require__(717); -const utils_1 = __webpack_require__(278); -const os = __importStar(__webpack_require__(87)); -const path = __importStar(__webpack_require__(622)); +exports.getState = exports.saveState = exports.group = exports.endGroup = exports.startGroup = exports.info = exports.warning = exports.error = exports.debug = exports.isDebug = exports.setFailed = exports.setCommandEcho = exports.setOutput = exports.getBooleanInput = exports.getMultilineInput = exports.getInput = exports.addPath = exports.setSecret = exports.exportVariable = exports.ExitCode = void 0; +const command_1 = __nccwpck_require__(87351); +const file_command_1 = __nccwpck_require__(717); +const utils_1 = __nccwpck_require__(5278); +const os = __importStar(__nccwpck_require__(12087)); +const path = __importStar(__nccwpck_require__(85622)); /** * The code to exit an action */ @@ -260,7 +781,9 @@ function addPath(inputPath) { } exports.addPath = addPath; /** - * Gets the value of an input. The value is also trimmed. + * 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. @@ -271,9 +794,49 @@ function getInput(name, options) { if (options && options.required && !val) { throw new Error(`Input required and not supplied: ${name}`); } + if (options && options.trimWhitespace === false) { + return val; + } return val.trim(); } exports.getInput = getInput; +/** + * Gets the values of an multiline input. Each value is also trimmed. + * + * @param name name of the input to get + * @param options optional. See InputOptions. + * @returns string[] + * + */ +function getMultilineInput(name, options) { + const inputs = getInput(name, options) + .split('\n') + .filter(x => x !== ''); + return inputs; +} +exports.getMultilineInput = getMultilineInput; +/** + * Gets the input value of the boolean type in the YAML 1.2 "core schema" specification. + * Support boolean input list: `true | True | TRUE | false | False | FALSE` . + * The return value is also in boolean type. + * ref: https://yaml.org/spec/1.2/spec.html#id2804923 + * + * @param name name of the input to get + * @param options optional. See InputOptions. + * @returns boolean + */ +function getBooleanInput(name, options) { + const trueValue = ['true', 'True', 'TRUE']; + const falseValue = ['false', 'False', 'FALSE']; + const val = getInput(name, options); + if (trueValue.includes(val)) + return true; + if (falseValue.includes(val)) + return false; + throw new TypeError(`Input does not meet YAML 1.2 "Core Schema" specification: ${name}\n` + + `Support boolean input list: \`true | True | TRUE | false | False | FALSE\``); +} +exports.getBooleanInput = getBooleanInput; /** * Sets the value of an output. * @@ -282,6 +845,7 @@ exports.getInput = getInput; */ // eslint-disable-next-line @typescript-eslint/no-explicit-any function setOutput(name, value) { + process.stdout.write(os.EOL); command_1.issueCommand('set-output', { name }, value); } exports.setOutput = setOutput; @@ -418,23 +982,37 @@ exports.getState = getState; /***/ }), /***/ 717: -/***/ (function(__unused_webpack_module, exports, __webpack_require__) { +/***/ (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 (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k]; - result["default"] = mod; + if (mod != null) for (var k in mod) if (k !== "default" && Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k); + __setModuleDefault(result, mod); return result; }; Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.issueCommand = void 0; // We use any as a valid input type /* eslint-disable @typescript-eslint/no-explicit-any */ -const fs = __importStar(__webpack_require__(747)); -const os = __importStar(__webpack_require__(87)); -const utils_1 = __webpack_require__(278); +const fs = __importStar(__nccwpck_require__(35747)); +const os = __importStar(__nccwpck_require__(12087)); +const utils_1 = __nccwpck_require__(5278); function issueCommand(command, message) { const filePath = process.env[`GITHUB_${command}`]; if (!filePath) { @@ -452,13 +1030,15 @@ exports.issueCommand = issueCommand; /***/ }), -/***/ 278: +/***/ 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.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 @@ -477,49 +1057,39042 @@ exports.toCommandValue = toCommandValue; /***/ }), -/***/ 747: -/***/ ((module) => { - -module.exports = require("fs");; - -/***/ }), +/***/ 74087: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { -/***/ 87: -/***/ ((module) => { +"use strict"; -module.exports = require("os");; +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.Context = void 0; +const fs_1 = __nccwpck_require__(35747); +const os_1 = __nccwpck_require__(12087); +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 /***/ }), -/***/ 622: -/***/ ((module) => { - -module.exports = require("path");; +/***/ 95438: +/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { -/***/ }) +"use strict"; -/******/ }); -/************************************************************************/ -/******/ // The module cache -/******/ var __webpack_module_cache__ = {}; -/******/ -/******/ // The require function -/******/ function __webpack_require__(moduleId) { -/******/ // Check if module is in cache -/******/ if(__webpack_module_cache__[moduleId]) { -/******/ return __webpack_module_cache__[moduleId].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 +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__(74087)); +const utils_1 = __nccwpck_require__(73030); +exports.context = new Context.Context(); +/** + * Returns a hydrated octokit ready to use for GitHub Actions + * + * @param token the repo PAT or GITHUB_TOKEN + * @param options other options to set + */ +function getOctokit(token, options) { + return new utils_1.GitHub(utils_1.getOctokitOptions(token, options)); +} +exports.getOctokit = getOctokit; +//# sourceMappingURL=github.js.map + +/***/ }), + +/***/ 47914: +/***/ (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__(39925)); +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 + +/***/ }), + +/***/ 73030: +/***/ (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.context = void 0; +const Context = __importStar(__nccwpck_require__(74087)); +const Utils = __importStar(__nccwpck_require__(47914)); +// octokit + plugins +const core_1 = __nccwpck_require__(76762); +const plugin_rest_endpoint_methods_1 = __nccwpck_require__(83044); +const plugin_paginate_rest_1 = __nccwpck_require__(64193); +exports.context = new Context.Context(); +const baseUrl = Utils.getApiBaseUrl(); +const defaults = { + baseUrl, + request: { + agent: Utils.getProxyAgent(baseUrl) + } +}; +exports.GitHub = core_1.Octokit.plugin(plugin_rest_endpoint_methods_1.restEndpointMethods, plugin_paginate_rest_1.paginateRest).defaults(defaults); +/** + * Convience function to correctly format Octokit Options to pass into the constructor. + * + * @param token the repo PAT or GITHUB_TOKEN + * @param options other options to set + */ +function getOctokitOptions(token, options) { + const opts = Object.assign({}, options || {}); // Shallow clone - don't mutate the object provided by the caller + // Auth + const auth = Utils.getAuthString(token, opts); + if (auth) { + opts.auth = auth; + } + return opts; +} +exports.getOctokitOptions = getOctokitOptions; +//# sourceMappingURL=utils.js.map + +/***/ }), + +/***/ 39925: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +const http = __nccwpck_require__(98605); +const https = __nccwpck_require__(57211); +const pm = __nccwpck_require__(16443); +let tunnel; +var HttpCodes; +(function (HttpCodes) { + HttpCodes[HttpCodes["OK"] = 200] = "OK"; + HttpCodes[HttpCodes["MultipleChoices"] = 300] = "MultipleChoices"; + HttpCodes[HttpCodes["MovedPermanently"] = 301] = "MovedPermanently"; + HttpCodes[HttpCodes["ResourceMoved"] = 302] = "ResourceMoved"; + HttpCodes[HttpCodes["SeeOther"] = 303] = "SeeOther"; + HttpCodes[HttpCodes["NotModified"] = 304] = "NotModified"; + HttpCodes[HttpCodes["UseProxy"] = 305] = "UseProxy"; + HttpCodes[HttpCodes["SwitchProxy"] = 306] = "SwitchProxy"; + HttpCodes[HttpCodes["TemporaryRedirect"] = 307] = "TemporaryRedirect"; + HttpCodes[HttpCodes["PermanentRedirect"] = 308] = "PermanentRedirect"; + HttpCodes[HttpCodes["BadRequest"] = 400] = "BadRequest"; + HttpCodes[HttpCodes["Unauthorized"] = 401] = "Unauthorized"; + HttpCodes[HttpCodes["PaymentRequired"] = 402] = "PaymentRequired"; + HttpCodes[HttpCodes["Forbidden"] = 403] = "Forbidden"; + HttpCodes[HttpCodes["NotFound"] = 404] = "NotFound"; + HttpCodes[HttpCodes["MethodNotAllowed"] = 405] = "MethodNotAllowed"; + HttpCodes[HttpCodes["NotAcceptable"] = 406] = "NotAcceptable"; + HttpCodes[HttpCodes["ProxyAuthenticationRequired"] = 407] = "ProxyAuthenticationRequired"; + HttpCodes[HttpCodes["RequestTimeout"] = 408] = "RequestTimeout"; + HttpCodes[HttpCodes["Conflict"] = 409] = "Conflict"; + HttpCodes[HttpCodes["Gone"] = 410] = "Gone"; + HttpCodes[HttpCodes["TooManyRequests"] = 429] = "TooManyRequests"; + HttpCodes[HttpCodes["InternalServerError"] = 500] = "InternalServerError"; + HttpCodes[HttpCodes["NotImplemented"] = 501] = "NotImplemented"; + HttpCodes[HttpCodes["BadGateway"] = 502] = "BadGateway"; + HttpCodes[HttpCodes["ServiceUnavailable"] = 503] = "ServiceUnavailable"; + HttpCodes[HttpCodes["GatewayTimeout"] = 504] = "GatewayTimeout"; +})(HttpCodes = exports.HttpCodes || (exports.HttpCodes = {})); +var Headers; +(function (Headers) { + Headers["Accept"] = "accept"; + Headers["ContentType"] = "content-type"; +})(Headers = exports.Headers || (exports.Headers = {})); +var MediaTypes; +(function (MediaTypes) { + MediaTypes["ApplicationJson"] = "application/json"; +})(MediaTypes = exports.MediaTypes || (exports.MediaTypes = {})); +/** + * Returns the proxy URL, depending upon the supplied url and proxy environment variables. + * @param serverUrl The server URL where the request will be sent. For example, https://api.github.com + */ +function getProxyUrl(serverUrl) { + let proxyUrl = pm.getProxyUrl(new URL(serverUrl)); + return proxyUrl ? proxyUrl.href : ''; +} +exports.getProxyUrl = getProxyUrl; +const HttpRedirectCodes = [ + HttpCodes.MovedPermanently, + HttpCodes.ResourceMoved, + HttpCodes.SeeOther, + HttpCodes.TemporaryRedirect, + HttpCodes.PermanentRedirect +]; +const HttpResponseRetryCodes = [ + HttpCodes.BadGateway, + HttpCodes.ServiceUnavailable, + HttpCodes.GatewayTimeout +]; +const RetryableHttpVerbs = ['OPTIONS', 'GET', 'DELETE', 'HEAD']; +const ExponentialBackoffCeiling = 10; +const ExponentialBackoffTimeSlice = 5; +class HttpClientError extends Error { + constructor(message, statusCode) { + super(message); + this.name = 'HttpClientError'; + this.statusCode = statusCode; + Object.setPrototypeOf(this, HttpClientError.prototype); + } +} +exports.HttpClientError = HttpClientError; +class HttpClientResponse { + constructor(message) { + this.message = message; + } + readBody() { + return new Promise(async (resolve, reject) => { + let output = Buffer.alloc(0); + this.message.on('data', (chunk) => { + output = Buffer.concat([output, chunk]); + }); + this.message.on('end', () => { + resolve(output.toString()); + }); + }); + } +} +exports.HttpClientResponse = HttpClientResponse; +function isHttps(requestUrl) { + let parsedUrl = new URL(requestUrl); + return parsedUrl.protocol === 'https:'; +} +exports.isHttps = isHttps; +class HttpClient { + constructor(userAgent, handlers, requestOptions) { + this._ignoreSslError = false; + this._allowRedirects = true; + this._allowRedirectDowngrade = false; + this._maxRedirects = 50; + this._allowRetries = false; + this._maxRetries = 1; + this._keepAlive = false; + this._disposed = false; + this.userAgent = userAgent; + this.handlers = handlers || []; + this.requestOptions = requestOptions; + if (requestOptions) { + if (requestOptions.ignoreSslError != null) { + this._ignoreSslError = requestOptions.ignoreSslError; + } + this._socketTimeout = requestOptions.socketTimeout; + if (requestOptions.allowRedirects != null) { + this._allowRedirects = requestOptions.allowRedirects; + } + if (requestOptions.allowRedirectDowngrade != null) { + this._allowRedirectDowngrade = requestOptions.allowRedirectDowngrade; + } + if (requestOptions.maxRedirects != null) { + this._maxRedirects = Math.max(requestOptions.maxRedirects, 0); + } + if (requestOptions.keepAlive != null) { + this._keepAlive = requestOptions.keepAlive; + } + if (requestOptions.allowRetries != null) { + this._allowRetries = requestOptions.allowRetries; + } + if (requestOptions.maxRetries != null) { + this._maxRetries = requestOptions.maxRetries; + } + } + } + options(requestUrl, additionalHeaders) { + return this.request('OPTIONS', requestUrl, null, additionalHeaders || {}); + } + get(requestUrl, additionalHeaders) { + return this.request('GET', requestUrl, null, additionalHeaders || {}); + } + del(requestUrl, additionalHeaders) { + return this.request('DELETE', requestUrl, null, additionalHeaders || {}); + } + post(requestUrl, data, additionalHeaders) { + return this.request('POST', requestUrl, data, additionalHeaders || {}); + } + patch(requestUrl, data, additionalHeaders) { + return this.request('PATCH', requestUrl, data, additionalHeaders || {}); + } + put(requestUrl, data, additionalHeaders) { + return this.request('PUT', requestUrl, data, additionalHeaders || {}); + } + head(requestUrl, additionalHeaders) { + return this.request('HEAD', requestUrl, null, additionalHeaders || {}); + } + sendStream(verb, requestUrl, stream, additionalHeaders) { + return this.request(verb, requestUrl, stream, additionalHeaders); + } + /** + * Gets a typed object from an endpoint + * Be aware that not found returns a null. Other errors (4xx, 5xx) reject the promise + */ + async getJson(requestUrl, additionalHeaders = {}) { + additionalHeaders[Headers.Accept] = this._getExistingOrDefaultHeader(additionalHeaders, Headers.Accept, MediaTypes.ApplicationJson); + let res = await this.get(requestUrl, additionalHeaders); + return this._processResponse(res, this.requestOptions); + } + async postJson(requestUrl, obj, additionalHeaders = {}) { + let data = JSON.stringify(obj, null, 2); + additionalHeaders[Headers.Accept] = this._getExistingOrDefaultHeader(additionalHeaders, Headers.Accept, MediaTypes.ApplicationJson); + additionalHeaders[Headers.ContentType] = this._getExistingOrDefaultHeader(additionalHeaders, Headers.ContentType, MediaTypes.ApplicationJson); + let res = await this.post(requestUrl, data, additionalHeaders); + return this._processResponse(res, this.requestOptions); + } + async putJson(requestUrl, obj, additionalHeaders = {}) { + let data = JSON.stringify(obj, null, 2); + additionalHeaders[Headers.Accept] = this._getExistingOrDefaultHeader(additionalHeaders, Headers.Accept, MediaTypes.ApplicationJson); + additionalHeaders[Headers.ContentType] = this._getExistingOrDefaultHeader(additionalHeaders, Headers.ContentType, MediaTypes.ApplicationJson); + let res = await this.put(requestUrl, data, additionalHeaders); + return this._processResponse(res, this.requestOptions); + } + async patchJson(requestUrl, obj, additionalHeaders = {}) { + let data = JSON.stringify(obj, null, 2); + additionalHeaders[Headers.Accept] = this._getExistingOrDefaultHeader(additionalHeaders, Headers.Accept, MediaTypes.ApplicationJson); + additionalHeaders[Headers.ContentType] = this._getExistingOrDefaultHeader(additionalHeaders, Headers.ContentType, MediaTypes.ApplicationJson); + let res = await this.patch(requestUrl, data, additionalHeaders); + return this._processResponse(res, this.requestOptions); + } + /** + * Makes a raw http request. + * All other methods such as get, post, patch, and request ultimately call this. + * Prefer get, del, post and patch + */ + async request(verb, requestUrl, data, headers) { + if (this._disposed) { + throw new Error('Client has already been disposed.'); + } + let parsedUrl = new URL(requestUrl); + let info = this._prepareRequest(verb, parsedUrl, headers); + // Only perform retries on reads since writes may not be idempotent. + let maxTries = this._allowRetries && RetryableHttpVerbs.indexOf(verb) != -1 + ? this._maxRetries + 1 + : 1; + let numTries = 0; + let response; + while (numTries < maxTries) { + response = await this.requestRaw(info, data); + // Check if it's an authentication challenge + if (response && + response.message && + response.message.statusCode === HttpCodes.Unauthorized) { + let authenticationHandler; + for (let i = 0; i < this.handlers.length; i++) { + if (this.handlers[i].canHandleAuthentication(response)) { + authenticationHandler = this.handlers[i]; + break; + } + } + if (authenticationHandler) { + return authenticationHandler.handleAuthentication(this, info, data); + } + else { + // We have received an unauthorized response but have no handlers to handle it. + // Let the response return to the caller. + return response; + } + } + let redirectsRemaining = this._maxRedirects; + while (HttpRedirectCodes.indexOf(response.message.statusCode) != -1 && + this._allowRedirects && + redirectsRemaining > 0) { + const redirectUrl = response.message.headers['location']; + if (!redirectUrl) { + // if there's no location to redirect to, we won't + break; + } + let parsedRedirectUrl = new URL(redirectUrl); + if (parsedUrl.protocol == 'https:' && + parsedUrl.protocol != parsedRedirectUrl.protocol && + !this._allowRedirectDowngrade) { + throw new Error('Redirect from HTTPS to HTTP protocol. This downgrade is not allowed for security reasons. If you want to allow this behavior, set the allowRedirectDowngrade option to true.'); + } + // we need to finish reading the response before reassigning response + // which will leak the open socket. + await response.readBody(); + // strip authorization header if redirected to a different hostname + if (parsedRedirectUrl.hostname !== parsedUrl.hostname) { + for (let header in headers) { + // header names are case insensitive + if (header.toLowerCase() === 'authorization') { + delete headers[header]; + } + } + } + // let's make the request with the new redirectUrl + info = this._prepareRequest(verb, parsedRedirectUrl, headers); + response = await this.requestRaw(info, data); + redirectsRemaining--; + } + if (HttpResponseRetryCodes.indexOf(response.message.statusCode) == -1) { + // If not a retry code, return immediately instead of retrying + return response; + } + numTries += 1; + if (numTries < maxTries) { + await response.readBody(); + await this._performExponentialBackoff(numTries); + } + } + return response; + } + /** + * Needs to be called if keepAlive is set to true in request options. + */ + dispose() { + if (this._agent) { + this._agent.destroy(); + } + this._disposed = true; + } + /** + * Raw request. + * @param info + * @param data + */ + requestRaw(info, data) { + return new Promise((resolve, reject) => { + let callbackForResult = function (err, res) { + if (err) { + reject(err); + } + resolve(res); + }; + this.requestRawWithCallback(info, data, callbackForResult); + }); + } + /** + * Raw request with callback. + * @param info + * @param data + * @param onResult + */ + requestRawWithCallback(info, data, onResult) { + let socket; + if (typeof data === 'string') { + info.options.headers['Content-Length'] = Buffer.byteLength(data, 'utf8'); + } + let callbackCalled = false; + let handleResult = (err, res) => { + if (!callbackCalled) { + callbackCalled = true; + onResult(err, res); + } + }; + let req = info.httpModule.request(info.options, (msg) => { + let res = new HttpClientResponse(msg); + handleResult(null, res); + }); + req.on('socket', sock => { + socket = sock; + }); + // If we ever get disconnected, we want the socket to timeout eventually + req.setTimeout(this._socketTimeout || 3 * 60000, () => { + if (socket) { + socket.end(); + } + handleResult(new Error('Request timeout: ' + info.options.path), null); + }); + req.on('error', function (err) { + // err has statusCode property + // res should have headers + handleResult(err, null); + }); + if (data && typeof data === 'string') { + req.write(data, 'utf8'); + } + if (data && typeof data !== 'string') { + data.on('close', function () { + req.end(); + }); + data.pipe(req); + } + else { + req.end(); + } + } + /** + * Gets an http agent. This function is useful when you need an http agent that handles + * routing through a proxy server - depending upon the url and proxy environment variables. + * @param serverUrl The server URL where the request will be sent. For example, https://api.github.com + */ + getAgent(serverUrl) { + let parsedUrl = new URL(serverUrl); + return this._getAgent(parsedUrl); + } + _prepareRequest(method, requestUrl, headers) { + const info = {}; + info.parsedUrl = requestUrl; + const usingSsl = info.parsedUrl.protocol === 'https:'; + info.httpModule = usingSsl ? https : http; + const defaultPort = usingSsl ? 443 : 80; + info.options = {}; + info.options.host = info.parsedUrl.hostname; + info.options.port = info.parsedUrl.port + ? parseInt(info.parsedUrl.port) + : defaultPort; + info.options.path = + (info.parsedUrl.pathname || '') + (info.parsedUrl.search || ''); + info.options.method = method; + info.options.headers = this._mergeHeaders(headers); + if (this.userAgent != null) { + info.options.headers['user-agent'] = this.userAgent; + } + info.options.agent = this._getAgent(info.parsedUrl); + // gives handlers an opportunity to participate + if (this.handlers) { + this.handlers.forEach(handler => { + handler.prepareRequest(info.options); + }); + } + return info; + } + _mergeHeaders(headers) { + const lowercaseKeys = obj => Object.keys(obj).reduce((c, k) => ((c[k.toLowerCase()] = obj[k]), c), {}); + if (this.requestOptions && this.requestOptions.headers) { + return Object.assign({}, lowercaseKeys(this.requestOptions.headers), lowercaseKeys(headers)); + } + return lowercaseKeys(headers || {}); + } + _getExistingOrDefaultHeader(additionalHeaders, header, _default) { + const lowercaseKeys = obj => Object.keys(obj).reduce((c, k) => ((c[k.toLowerCase()] = obj[k]), c), {}); + let clientHeader; + if (this.requestOptions && this.requestOptions.headers) { + clientHeader = lowercaseKeys(this.requestOptions.headers)[header]; + } + return additionalHeaders[header] || clientHeader || _default; + } + _getAgent(parsedUrl) { + let agent; + let proxyUrl = pm.getProxyUrl(parsedUrl); + let useProxy = proxyUrl && proxyUrl.hostname; + if (this._keepAlive && useProxy) { + agent = this._proxyAgent; + } + if (this._keepAlive && !useProxy) { + agent = this._agent; + } + // if agent is already assigned use that agent. + if (!!agent) { + return agent; + } + const usingSsl = parsedUrl.protocol === 'https:'; + let maxSockets = 100; + if (!!this.requestOptions) { + maxSockets = this.requestOptions.maxSockets || http.globalAgent.maxSockets; + } + if (useProxy) { + // If using proxy, need tunnel + if (!tunnel) { + tunnel = __nccwpck_require__(74294); + } + const agentOptions = { + maxSockets: maxSockets, + keepAlive: this._keepAlive, + proxy: { + ...((proxyUrl.username || proxyUrl.password) && { + proxyAuth: `${proxyUrl.username}:${proxyUrl.password}` + }), + host: proxyUrl.hostname, + port: proxyUrl.port + } + }; + let tunnelAgent; + const overHttps = proxyUrl.protocol === 'https:'; + if (usingSsl) { + tunnelAgent = overHttps ? tunnel.httpsOverHttps : tunnel.httpsOverHttp; + } + else { + tunnelAgent = overHttps ? tunnel.httpOverHttps : tunnel.httpOverHttp; + } + agent = tunnelAgent(agentOptions); + this._proxyAgent = agent; + } + // if reusing agent across request and tunneling agent isn't assigned create a new agent + if (this._keepAlive && !agent) { + const options = { keepAlive: this._keepAlive, maxSockets: maxSockets }; + agent = usingSsl ? new https.Agent(options) : new http.Agent(options); + this._agent = agent; + } + // if not using private agent and tunnel agent isn't setup then use global agent + if (!agent) { + agent = usingSsl ? https.globalAgent : http.globalAgent; + } + if (usingSsl && this._ignoreSslError) { + // we don't want to set NODE_TLS_REJECT_UNAUTHORIZED=0 since that will affect request for entire process + // http.RequestOptions doesn't expose a way to modify RequestOptions.agent.options + // we have to cast it to any and change it directly + agent.options = Object.assign(agent.options || {}, { + rejectUnauthorized: false + }); + } + return agent; + } + _performExponentialBackoff(retryNumber) { + retryNumber = Math.min(ExponentialBackoffCeiling, retryNumber); + const ms = ExponentialBackoffTimeSlice * Math.pow(2, retryNumber); + return new Promise(resolve => setTimeout(() => resolve(), ms)); + } + static dateTimeDeserializer(key, value) { + if (typeof value === 'string') { + let a = new Date(value); + if (!isNaN(a.valueOf())) { + return a; + } + } + return value; + } + async _processResponse(res, options) { + return new Promise(async (resolve, reject) => { + const statusCode = res.message.statusCode; + const response = { + statusCode: statusCode, + result: null, + headers: {} + }; + // not found leads to null obj returned + if (statusCode == HttpCodes.NotFound) { + resolve(response); + } + let obj; + let contents; + // get the result from the body + try { + contents = await res.readBody(); + if (contents && contents.length > 0) { + if (options && options.deserializeDates) { + obj = JSON.parse(contents, HttpClient.dateTimeDeserializer); + } + else { + obj = JSON.parse(contents); + } + response.result = obj; + } + response.headers = res.message.headers; + } + catch (err) { + // Invalid resource (contents not json); leaving result obj null + } + // note that 3xx redirects are handled by the http layer. + if (statusCode > 299) { + let msg; + // if exception/error in body, attempt to get better error + if (obj && obj.message) { + msg = obj.message; + } + else if (contents && contents.length > 0) { + // it may be the case that the exception is in the body message as string + msg = contents; + } + else { + msg = 'Failed request: (' + statusCode + ')'; + } + let err = new HttpClientError(msg, statusCode); + err.result = response.result; + reject(err); + } + else { + resolve(response); + } + }); + } +} +exports.HttpClient = HttpClient; + + +/***/ }), + +/***/ 16443: +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +function getProxyUrl(reqUrl) { + let usingSsl = reqUrl.protocol === 'https:'; + let proxyUrl; + if (checkBypass(reqUrl)) { + return proxyUrl; + } + let proxyVar; + if (usingSsl) { + proxyVar = process.env['https_proxy'] || process.env['HTTPS_PROXY']; + } + else { + proxyVar = process.env['http_proxy'] || process.env['HTTP_PROXY']; + } + if (proxyVar) { + proxyUrl = new URL(proxyVar); + } + return proxyUrl; +} +exports.getProxyUrl = getProxyUrl; +function checkBypass(reqUrl) { + if (!reqUrl.hostname) { + return false; + } + let noProxy = process.env['no_proxy'] || process.env['NO_PROXY'] || ''; + if (!noProxy) { + return false; + } + // Determine the request port + let reqPort; + if (reqUrl.port) { + reqPort = Number(reqUrl.port); + } + else if (reqUrl.protocol === 'http:') { + reqPort = 80; + } + else if (reqUrl.protocol === 'https:') { + reqPort = 443; + } + // Format the request hostname and hostname with port + let upperReqHosts = [reqUrl.hostname.toUpperCase()]; + if (typeof reqPort === 'number') { + upperReqHosts.push(`${upperReqHosts[0]}:${reqPort}`); + } + // Compare request host against noproxy + for (let upperNoProxyItem of noProxy + .split(',') + .map(x => x.trim().toUpperCase()) + .filter(x => x)) { + if (upperReqHosts.some(x => x === upperNoProxyItem)) { + return true; + } + } + return false; +} +exports.checkBypass = checkBypass; + + +/***/ }), + +/***/ 54751: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +function __export(m) { + for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p]; +} +Object.defineProperty(exports, "__esModule", ({ value: true })); +__export(__nccwpck_require__(42825)); +//# sourceMappingURL=index.js.map + +/***/ }), + +/***/ 42825: +/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { + +"use strict"; + +var __importDefault = (this && this.__importDefault) || function (mod) { + return (mod && mod.__esModule) ? mod : { "default": mod }; +}; +Object.defineProperty(exports, "__esModule", ({ value: true })); +const fs_1 = __nccwpck_require__(35747); +const debug_1 = __importDefault(__nccwpck_require__(38237)); +const log = debug_1.default('@kwsites/file-exists'); +function check(path, isFile, isDirectory) { + log(`checking %s`, path); + try { + const stat = fs_1.statSync(path); + if (stat.isFile() && isFile) { + log(`[OK] path represents a file`); + return true; + } + if (stat.isDirectory() && isDirectory) { + log(`[OK] path represents a directory`); + return true; + } + log(`[FAIL] path represents something other than a file or directory`); + return false; + } + catch (e) { + if (e.code === 'ENOENT') { + log(`[FAIL] path is not accessible: %o`, e); + return false; + } + log(`[FATAL] %o`, e); + throw e; + } +} +/** + * Synchronous validation of a path existing either as a file or as a directory. + * + * @param {string} path The path to check + * @param {number} type One or both of the exported numeric constants + */ +function exists(path, type = exports.READABLE) { + return check(path, (type & exports.FILE) > 0, (type & exports.FOLDER) > 0); +} +exports.exists = exists; +/** + * Constant representing a file + */ +exports.FILE = 1; +/** + * Constant representing a folder + */ +exports.FOLDER = 2; +/** + * Constant representing either a file or a folder + */ +exports.READABLE = exports.FILE + exports.FOLDER; +//# sourceMappingURL=index.js.map + +/***/ }), + +/***/ 49819: +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.createDeferred = exports.deferred = void 0; +/** + * Creates a new `DeferredPromise` + * + * ```typescript + import {deferred} from '@kwsites/promise-deferred`; + ``` + */ +function deferred() { + let done; + let fail; + let status = 'pending'; + const promise = new Promise((_done, _fail) => { + done = _done; + fail = _fail; + }); + return { + promise, + done(result) { + if (status === 'pending') { + status = 'resolved'; + done(result); + } + }, + fail(error) { + if (status === 'pending') { + status = 'rejected'; + fail(error); + } + }, + get fulfilled() { + return status !== 'pending'; + }, + get status() { + return status; + }, + }; +} +exports.deferred = deferred; +/** + * Alias of the exported `deferred` function, to help consumers wanting to use `deferred` as the + * local variable name rather than the factory import name, without needing to rename on import. + * + * ```typescript + import {createDeferred} from '@kwsites/promise-deferred`; + ``` + */ +exports.createDeferred = deferred; +/** + * Default export allows use as: + * + * ```typescript + import deferred from '@kwsites/promise-deferred`; + ``` + */ +exports.default = deferred; +//# sourceMappingURL=index.js.map + +/***/ }), + +/***/ 40334: +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + + +Object.defineProperty(exports, "__esModule", ({ value: true })); + +async function auth(token) { + const tokenType = token.split(/\./).length === 3 ? "app" : /^v\d+\./.test(token) ? "installation" : "oauth"; + return { + type: "token", + token: token, + tokenType + }; +} + +/** + * Prefix token for usage in the Authorization header + * + * @param token OAuth token or JSON Web Token + */ +function withAuthorizationPrefix(token) { + if (token.split(/\./).length === 3) { + return `bearer ${token}`; + } + + return `token ${token}`; +} + +async function hook(token, request, route, parameters) { + const endpoint = request.endpoint.merge(route, parameters); + endpoint.headers.authorization = withAuthorizationPrefix(token); + return request(endpoint); +} + +const createTokenAuth = function createTokenAuth(token) { + if (!token) { + throw new Error("[@octokit/auth-token] No token passed to createTokenAuth"); + } + + if (typeof token !== "string") { + throw new Error("[@octokit/auth-token] Token passed to createTokenAuth is not a string"); + } + + token = token.replace(/^(token|bearer) +/i, ""); + return Object.assign(auth.bind(null, token), { + hook: hook.bind(null, token) + }); +}; + +exports.createTokenAuth = createTokenAuth; +//# sourceMappingURL=index.js.map + + +/***/ }), + +/***/ 76762: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + + +Object.defineProperty(exports, "__esModule", ({ value: true })); + +var universalUserAgent = __nccwpck_require__(45030); +var beforeAfterHook = __nccwpck_require__(83682); +var request = __nccwpck_require__(36234); +var graphql = __nccwpck_require__(88467); +var authToken = __nccwpck_require__(40334); + +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.5.1"; + +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 + + +/***/ }), + +/***/ 59440: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + + +Object.defineProperty(exports, "__esModule", ({ value: true })); + +var isPlainObject = __nccwpck_require__(63287); +var universalUserAgent = __nccwpck_require__(45030); + +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 + + +/***/ }), + +/***/ 88467: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + + +Object.defineProperty(exports, "__esModule", ({ value: true })); + +var request = __nccwpck_require__(36234); +var universalUserAgent = __nccwpck_require__(45030); + +const VERSION = "4.6.4"; + +class GraphqlError extends Error { + constructor(request, response) { + const message = response.data.errors[0].message; + super(message); + Object.assign(this, response.data); + Object.assign(this, { + headers: response.headers + }); + this.name = "GraphqlError"; + this.request = request; // Maintains proper stack trace (only available on V8) + + /* istanbul ignore next */ + + if (Error.captureStackTrace) { + Error.captureStackTrace(this, this.constructor); + } + } + +} + +const NON_VARIABLE_OPTIONS = ["method", "baseUrl", "url", "headers", "request", "query", "mediaType"]; +const FORBIDDEN_VARIABLE_OPTIONS = ["query", "method", "url"]; +const GHES_V3_SUFFIX_REGEX = /\/api\/v3\/?$/; +function graphql(request, query, options) { + if (options) { + if (typeof query === "string" && "query" in options) { + return Promise.reject(new Error(`[@octokit/graphql] "query" cannot be used as variable name`)); + } + + for (const key in options) { + if (!FORBIDDEN_VARIABLE_OPTIONS.includes(key)) continue; + return Promise.reject(new Error(`[@octokit/graphql] "${key}" cannot be used as variable name`)); + } + } + + const parsedOptions = typeof query === "string" ? Object.assign({ + query + }, options) : query; + const requestOptions = Object.keys(parsedOptions).reduce((result, key) => { + if (NON_VARIABLE_OPTIONS.includes(key)) { + result[key] = parsedOptions[key]; + return result; + } + + if (!result.variables) { + result.variables = {}; + } + + result.variables[key] = parsedOptions[key]; + return result; + }, {}); // workaround for GitHub Enterprise baseUrl set with /api/v3 suffix + // https://github.com/octokit/auth-app.js/issues/111#issuecomment-657610451 + + const baseUrl = parsedOptions.baseUrl || request.endpoint.DEFAULTS.baseUrl; + + if (GHES_V3_SUFFIX_REGEX.test(baseUrl)) { + requestOptions.url = baseUrl.replace(GHES_V3_SUFFIX_REGEX, "/api/graphql"); + } + + return request(requestOptions).then(response => { + if (response.data.errors) { + const headers = {}; + + for (const key of Object.keys(response.headers)) { + headers[key] = response.headers[key]; + } + + throw new GraphqlError(requestOptions, { + headers, + data: response.data + }); + } + + return response.data.data; + }); +} + +function withDefaults(request$1, newDefaults) { + const newRequest = request$1.defaults(newDefaults); + + const newApi = (query, options) => { + return graphql(newRequest, query, options); + }; + + return Object.assign(newApi, { + defaults: withDefaults.bind(null, newRequest), + endpoint: request.request.endpoint + }); +} + +const graphql$1 = withDefaults(request.request, { + headers: { + "user-agent": `octokit-graphql.js/${VERSION} ${universalUserAgent.getUserAgent()}` + }, + method: "POST", + url: "/graphql" +}); +function withCustomRequest(customRequest) { + return withDefaults(customRequest, { + method: "POST", + url: "/graphql" + }); +} + +exports.graphql = graphql$1; +exports.withCustomRequest = withCustomRequest; +//# sourceMappingURL=index.js.map + + +/***/ }), + +/***/ 64193: +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + + +Object.defineProperty(exports, "__esModule", ({ value: true })); + +const VERSION = "2.15.1"; + +function ownKeys(object, enumerableOnly) { + var keys = Object.keys(object); + + if (Object.getOwnPropertySymbols) { + var symbols = Object.getOwnPropertySymbols(object); + + if (enumerableOnly) { + symbols = symbols.filter(function (sym) { + return Object.getOwnPropertyDescriptor(object, sym).enumerable; + }); + } + + keys.push.apply(keys, symbols); + } + + return keys; +} + +function _objectSpread2(target) { + for (var i = 1; i < arguments.length; i++) { + var source = arguments[i] != null ? arguments[i] : {}; + + if (i % 2) { + ownKeys(Object(source), true).forEach(function (key) { + _defineProperty(target, key, source[key]); + }); + } else if (Object.getOwnPropertyDescriptors) { + Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); + } else { + ownKeys(Object(source)).forEach(function (key) { + Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); + }); + } + } + + return target; +} + +function _defineProperty(obj, key, value) { + if (key in obj) { + Object.defineProperty(obj, key, { + value: value, + enumerable: true, + configurable: true, + writable: true + }); + } else { + obj[key] = value; + } + + return obj; +} + +/** + * Some “list” response that can be paginated have a different response structure + * + * They have a `total_count` key in the response (search also has `incomplete_results`, + * /installation/repositories also has `repository_selection`), as well as a key with + * the list of the items which name varies from endpoint to endpoint. + * + * Octokit normalizes these responses so that paginated results are always returned following + * the same structure. One challenge is that if the list response has only one page, no Link + * header is provided, so this header alone is not sufficient to check wether a response is + * paginated or not. + * + * We check if a "total_count" key is present in the response data, but also make sure that + * a "url" property is not, as the "Get the combined status for a specific ref" endpoint would + * otherwise match: https://developer.github.com/v3/repos/statuses/#get-the-combined-status-for-a-specific-ref + */ +function normalizePaginatedListResponse(response) { + // endpoints can respond with 204 if repository is empty + if (!response.data) { + return _objectSpread2(_objectSpread2({}, response), {}, { + data: [] + }); + } + + const responseNeedsNormalization = "total_count" in response.data && !("url" in response.data); + if (!responseNeedsNormalization) return response; // keep the additional properties intact as there is currently no other way + // to retrieve the same information. + + const incompleteResults = response.data.incomplete_results; + const repositorySelection = response.data.repository_selection; + const totalCount = response.data.total_count; + delete response.data.incomplete_results; + delete response.data.repository_selection; + delete response.data.total_count; + const namespaceKey = Object.keys(response.data)[0]; + const data = response.data[namespaceKey]; + response.data = data; + + if (typeof incompleteResults !== "undefined") { + response.data.incomplete_results = incompleteResults; + } + + if (typeof repositorySelection !== "undefined") { + response.data.repository_selection = repositorySelection; + } + + response.data.total_count = totalCount; + return response; +} + +function iterator(octokit, route, parameters) { + const options = typeof route === "function" ? route.endpoint(parameters) : octokit.request.endpoint(route, parameters); + const requestMethod = typeof route === "function" ? route : octokit.request; + const method = options.method; + const headers = options.headers; + let url = options.url; + return { + [Symbol.asyncIterator]: () => ({ + async next() { + if (!url) return { + done: true + }; + + try { + const response = await requestMethod({ + method, + url, + headers + }); + const normalizedResponse = normalizePaginatedListResponse(response); // `response.headers.link` format: + // '; 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}/actions/runners/downloads", "GET /events", "GET /gists", "GET /gists/public", "GET /gists/starred", "GET /gists/{gist_id}/comments", "GET /gists/{gist_id}/commits", "GET /gists/{gist_id}/forks", "GET /installation/repositories", "GET /issues", "GET /marketplace_listing/plans", "GET /marketplace_listing/plans/{plan_id}/accounts", "GET /marketplace_listing/stubbed/plans", "GET /marketplace_listing/stubbed/plans/{plan_id}/accounts", "GET /networks/{owner}/{repo}/events", "GET /notifications", "GET /organizations", "GET /orgs/{org}/actions/permissions/repositories", "GET /orgs/{org}/actions/runner-groups", "GET /orgs/{org}/actions/runner-groups/{runner_group_id}/repositories", "GET /orgs/{org}/actions/runner-groups/{runner_group_id}/runners", "GET /orgs/{org}/actions/runners", "GET /orgs/{org}/actions/runners/downloads", "GET /orgs/{org}/actions/secrets", "GET /orgs/{org}/actions/secrets/{secret_name}/repositories", "GET /orgs/{org}/blocks", "GET /orgs/{org}/credential-authorizations", "GET /orgs/{org}/events", "GET /orgs/{org}/failed_invitations", "GET /orgs/{org}/hooks", "GET /orgs/{org}/hooks/{hook_id}/deliveries", "GET /orgs/{org}/installations", "GET /orgs/{org}/invitations", "GET /orgs/{org}/invitations/{invitation_id}/teams", "GET /orgs/{org}/issues", "GET /orgs/{org}/members", "GET /orgs/{org}/migrations", "GET /orgs/{org}/migrations/{migration_id}/repositories", "GET /orgs/{org}/outside_collaborators", "GET /orgs/{org}/projects", "GET /orgs/{org}/public_members", "GET /orgs/{org}/repos", "GET /orgs/{org}/team-sync/groups", "GET /orgs/{org}/teams", "GET /orgs/{org}/teams/{team_slug}/discussions", "GET /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/comments", "GET /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/comments/{comment_number}/reactions", "GET /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/reactions", "GET /orgs/{org}/teams/{team_slug}/invitations", "GET /orgs/{org}/teams/{team_slug}/members", "GET /orgs/{org}/teams/{team_slug}/projects", "GET /orgs/{org}/teams/{team_slug}/repos", "GET /orgs/{org}/teams/{team_slug}/team-sync/group-mappings", "GET /orgs/{org}/teams/{team_slug}/teams", "GET /projects/columns/{column_id}/cards", "GET /projects/{project_id}/collaborators", "GET /projects/{project_id}/columns", "GET /repos/{owner}/{repo}/actions/artifacts", "GET /repos/{owner}/{repo}/actions/runners", "GET /repos/{owner}/{repo}/actions/runners/downloads", "GET /repos/{owner}/{repo}/actions/runs", "GET /repos/{owner}/{repo}/actions/runs/{run_id}/artifacts", "GET /repos/{owner}/{repo}/actions/runs/{run_id}/jobs", "GET /repos/{owner}/{repo}/actions/secrets", "GET /repos/{owner}/{repo}/actions/workflows", "GET /repos/{owner}/{repo}/actions/workflows/{workflow_id}/runs", "GET /repos/{owner}/{repo}/assignees", "GET /repos/{owner}/{repo}/autolinks", "GET /repos/{owner}/{repo}/branches", "GET /repos/{owner}/{repo}/check-runs/{check_run_id}/annotations", "GET /repos/{owner}/{repo}/check-suites/{check_suite_id}/check-runs", "GET /repos/{owner}/{repo}/code-scanning/alerts", "GET /repos/{owner}/{repo}/code-scanning/alerts/{alert_number}/instances", "GET /repos/{owner}/{repo}/code-scanning/analyses", "GET /repos/{owner}/{repo}/collaborators", "GET /repos/{owner}/{repo}/comments", "GET /repos/{owner}/{repo}/comments/{comment_id}/reactions", "GET /repos/{owner}/{repo}/commits", "GET /repos/{owner}/{repo}/commits/{commit_sha}/branches-where-head", "GET /repos/{owner}/{repo}/commits/{commit_sha}/comments", "GET /repos/{owner}/{repo}/commits/{commit_sha}/pulls", "GET /repos/{owner}/{repo}/commits/{ref}/check-runs", "GET /repos/{owner}/{repo}/commits/{ref}/check-suites", "GET /repos/{owner}/{repo}/commits/{ref}/statuses", "GET /repos/{owner}/{repo}/contributors", "GET /repos/{owner}/{repo}/deployments", "GET /repos/{owner}/{repo}/deployments/{deployment_id}/statuses", "GET /repos/{owner}/{repo}/events", "GET /repos/{owner}/{repo}/forks", "GET /repos/{owner}/{repo}/git/matching-refs/{ref}", "GET /repos/{owner}/{repo}/hooks", "GET /repos/{owner}/{repo}/hooks/{hook_id}/deliveries", "GET /repos/{owner}/{repo}/invitations", "GET /repos/{owner}/{repo}/issues", "GET /repos/{owner}/{repo}/issues/comments", "GET /repos/{owner}/{repo}/issues/comments/{comment_id}/reactions", "GET /repos/{owner}/{repo}/issues/events", "GET /repos/{owner}/{repo}/issues/{issue_number}/comments", "GET /repos/{owner}/{repo}/issues/{issue_number}/events", "GET /repos/{owner}/{repo}/issues/{issue_number}/labels", "GET /repos/{owner}/{repo}/issues/{issue_number}/reactions", "GET /repos/{owner}/{repo}/issues/{issue_number}/timeline", "GET /repos/{owner}/{repo}/keys", "GET /repos/{owner}/{repo}/labels", "GET /repos/{owner}/{repo}/milestones", "GET /repos/{owner}/{repo}/milestones/{milestone_number}/labels", "GET /repos/{owner}/{repo}/notifications", "GET /repos/{owner}/{repo}/pages/builds", "GET /repos/{owner}/{repo}/projects", "GET /repos/{owner}/{repo}/pulls", "GET /repos/{owner}/{repo}/pulls/comments", "GET /repos/{owner}/{repo}/pulls/comments/{comment_id}/reactions", "GET /repos/{owner}/{repo}/pulls/{pull_number}/comments", "GET /repos/{owner}/{repo}/pulls/{pull_number}/commits", "GET /repos/{owner}/{repo}/pulls/{pull_number}/files", "GET /repos/{owner}/{repo}/pulls/{pull_number}/requested_reviewers", "GET /repos/{owner}/{repo}/pulls/{pull_number}/reviews", "GET /repos/{owner}/{repo}/pulls/{pull_number}/reviews/{review_id}/comments", "GET /repos/{owner}/{repo}/releases", "GET /repos/{owner}/{repo}/releases/{release_id}/assets", "GET /repos/{owner}/{repo}/secret-scanning/alerts", "GET /repos/{owner}/{repo}/stargazers", "GET /repos/{owner}/{repo}/subscribers", "GET /repos/{owner}/{repo}/tags", "GET /repos/{owner}/{repo}/teams", "GET /repositories", "GET /repositories/{repository_id}/environments/{environment_name}/secrets", "GET /scim/v2/enterprises/{enterprise}/Groups", "GET /scim/v2/enterprises/{enterprise}/Users", "GET /scim/v2/organizations/{org}/Users", "GET /search/code", "GET /search/commits", "GET /search/issues", "GET /search/labels", "GET /search/repositories", "GET /search/topics", "GET /search/users", "GET /teams/{team_id}/discussions", "GET /teams/{team_id}/discussions/{discussion_number}/comments", "GET /teams/{team_id}/discussions/{discussion_number}/comments/{comment_number}/reactions", "GET /teams/{team_id}/discussions/{discussion_number}/reactions", "GET /teams/{team_id}/invitations", "GET /teams/{team_id}/members", "GET /teams/{team_id}/projects", "GET /teams/{team_id}/repos", "GET /teams/{team_id}/team-sync/group-mappings", "GET /teams/{team_id}/teams", "GET /user/blocks", "GET /user/emails", "GET /user/followers", "GET /user/following", "GET /user/gpg_keys", "GET /user/installations", "GET /user/installations/{installation_id}/repositories", "GET /user/issues", "GET /user/keys", "GET /user/marketplace_purchases", "GET /user/marketplace_purchases/stubbed", "GET /user/memberships/orgs", "GET /user/migrations", "GET /user/migrations/{migration_id}/repositories", "GET /user/orgs", "GET /user/public_emails", "GET /user/repos", "GET /user/repository_invitations", "GET /user/starred", "GET /user/subscriptions", "GET /user/teams", "GET /users", "GET /users/{username}/events", "GET /users/{username}/events/orgs/{org}", "GET /users/{username}/events/public", "GET /users/{username}/followers", "GET /users/{username}/following", "GET /users/{username}/gists", "GET /users/{username}/gpg_keys", "GET /users/{username}/keys", "GET /users/{username}/orgs", "GET /users/{username}/projects", "GET /users/{username}/received_events", "GET /users/{username}/received_events/public", "GET /users/{username}/repos", "GET /users/{username}/starred", "GET /users/{username}/subscriptions"]; + +function isPaginatingEndpoint(arg) { + if (typeof arg === "string") { + return paginatingEndpoints.includes(arg); + } else { + return false; + } +} + +/** + * @param octokit Octokit instance + * @param options Options passed to Octokit constructor + */ + +function paginateRest(octokit) { + return { + paginate: Object.assign(paginate.bind(null, octokit), { + iterator: iterator.bind(null, octokit) + }) + }; +} +paginateRest.VERSION = VERSION; + +exports.composePaginateRest = composePaginateRest; +exports.isPaginatingEndpoint = isPaginatingEndpoint; +exports.paginateRest = paginateRest; +exports.paginatingEndpoints = paginatingEndpoints; +//# sourceMappingURL=index.js.map + + +/***/ }), + +/***/ 83044: +/***/ ((__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: { + 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"], + 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"], + 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"], + 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}"], + 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}"], + getWorkflowRun: ["GET /repos/{owner}/{repo}/actions/runs/{run_id}"], + getWorkflowRunUsage: ["GET /repos/{owner}/{repo}/actions/runs/{run_id}/timing"], + getWorkflowUsage: ["GET /repos/{owner}/{repo}/actions/workflows/{workflow_id}/timing"], + listArtifactsForRepo: ["GET /repos/{owner}/{repo}/actions/artifacts"], + listEnvironmentSecrets: ["GET /repositories/{repository_id}/environments/{environment_name}/secrets"], + listJobsForWorkflowRun: ["GET /repos/{owner}/{repo}/actions/runs/{run_id}/jobs"], + 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"], + reRunWorkflow: ["POST /repos/{owner}/{repo}/actions/runs/{run_id}/rerun"], + 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"], + 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"] + }, + 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}"], + checkToken: ["POST /applications/{client_id}/token"], + createContentAttachment: ["POST /content_references/{content_reference_id}/attachments", { + mediaType: { + previews: ["corsair"] + } + }], + createContentAttachmentForRepo: ["POST /repos/{owner}/{repo}/content_references/{content_reference_id}/attachments", { + mediaType: { + previews: ["corsair"] + } + }], + 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}"], + 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"], + 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"], + 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}"], + getForRepo: ["GET /repos/{owner}/{repo}/community/code_of_conduct", { + mediaType: { + previews: ["scarlet-witch"] + } + }] + }, + emojis: { + get: ["GET /emojis"] + }, + enterpriseAdmin: { + 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"], + listSelectedOrganizationsEnabledGithubActionsEnterprise: ["GET /enterprises/{enterprise}/actions/permissions/organizations"], + setAllowedActionsEnterprise: ["PUT /enterprises/{enterprise}/actions/permissions/selected-actions"], + 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", { + mediaType: { + previews: ["mockingbird"] + } + }], + listForAuthenticatedUser: ["GET /user/issues"], + listForOrg: ["GET /orgs/{org}/issues"], + listForRepo: ["GET /repos/{owner}/{repo}/issues"], + listLabelsForMilestone: ["GET /repos/{owner}/{repo}/milestones/{milestone_number}/labels"], + listLabelsForRepo: ["GET /repos/{owner}/{repo}/labels"], + listLabelsOnIssue: ["GET /repos/{owner}/{repo}/issues/{issue_number}/labels"], + listMilestones: ["GET /repos/{owner}/{repo}/milestones"], + 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", { + mediaType: { + previews: ["wyandotte"] + } + }], + deleteArchiveForOrg: ["DELETE /orgs/{org}/migrations/{migration_id}/archive", { + mediaType: { + previews: ["wyandotte"] + } + }], + downloadArchiveForOrg: ["GET /orgs/{org}/migrations/{migration_id}/archive", { + mediaType: { + previews: ["wyandotte"] + } + }], + getArchiveForAuthenticatedUser: ["GET /user/migrations/{migration_id}/archive", { + mediaType: { + previews: ["wyandotte"] + } + }], + getCommitAuthors: ["GET /repos/{owner}/{repo}/import/authors"], + getImportStatus: ["GET /repos/{owner}/{repo}/import"], + getLargeFiles: ["GET /repos/{owner}/{repo}/import/large_files"], + getStatusForAuthenticatedUser: ["GET /user/migrations/{migration_id}", { + mediaType: { + previews: ["wyandotte"] + } + }], + getStatusForOrg: ["GET /orgs/{org}/migrations/{migration_id}", { + mediaType: { + previews: ["wyandotte"] + } + }], + listForAuthenticatedUser: ["GET /user/migrations", { + mediaType: { + previews: ["wyandotte"] + } + }], + listForOrg: ["GET /orgs/{org}/migrations", { + mediaType: { + previews: ["wyandotte"] + } + }], + listReposForOrg: ["GET /orgs/{org}/migrations/{migration_id}/repositories", { + mediaType: { + previews: ["wyandotte"] + } + }], + listReposForUser: ["GET /user/migrations/{migration_id}/repositories", { + mediaType: { + previews: ["wyandotte"] + } + }], + mapCommitAuthor: ["PATCH /repos/{owner}/{repo}/import/authors/{author_id}"], + setLfsPreference: ["PATCH /repos/{owner}/{repo}/import/lfs"], + startForAuthenticatedUser: ["POST /user/migrations"], + startForOrg: ["POST /orgs/{org}/migrations"], + startImport: ["PUT /repos/{owner}/{repo}/import"], + unlockRepoForAuthenticatedUser: ["DELETE /user/migrations/{migration_id}/repos/{repo_name}/lock", { + mediaType: { + previews: ["wyandotte"] + } + }], + unlockRepoForOrg: ["DELETE /orgs/{org}/migrations/{migration_id}/repos/{repo_name}/lock", { + mediaType: { + previews: ["wyandotte"] + } + }], + updateImport: ["PATCH /repos/{owner}/{repo}/import"] + }, + orgs: { + 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"], + 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}"], + 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}"], + 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}"], + restorePackageForAuthenticatedUser: ["POST /user/packages/{package_type}/{package_name}/restore{?token}"], + restorePackageForOrg: ["POST /orgs/{org}/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"] + }, + projects: { + addCollaborator: ["PUT /projects/{project_id}/collaborators/{username}", { + mediaType: { + previews: ["inertia"] + } + }], + createCard: ["POST /projects/columns/{column_id}/cards", { + mediaType: { + previews: ["inertia"] + } + }], + createColumn: ["POST /projects/{project_id}/columns", { + mediaType: { + previews: ["inertia"] + } + }], + createForAuthenticatedUser: ["POST /user/projects", { + mediaType: { + previews: ["inertia"] + } + }], + createForOrg: ["POST /orgs/{org}/projects", { + mediaType: { + previews: ["inertia"] + } + }], + createForRepo: ["POST /repos/{owner}/{repo}/projects", { + mediaType: { + previews: ["inertia"] + } + }], + delete: ["DELETE /projects/{project_id}", { + mediaType: { + previews: ["inertia"] + } + }], + deleteCard: ["DELETE /projects/columns/cards/{card_id}", { + mediaType: { + previews: ["inertia"] + } + }], + deleteColumn: ["DELETE /projects/columns/{column_id}", { + mediaType: { + previews: ["inertia"] + } + }], + get: ["GET /projects/{project_id}", { + mediaType: { + previews: ["inertia"] + } + }], + getCard: ["GET /projects/columns/cards/{card_id}", { + mediaType: { + previews: ["inertia"] + } + }], + getColumn: ["GET /projects/columns/{column_id}", { + mediaType: { + previews: ["inertia"] + } + }], + getPermissionForUser: ["GET /projects/{project_id}/collaborators/{username}/permission", { + mediaType: { + previews: ["inertia"] + } + }], + listCards: ["GET /projects/columns/{column_id}/cards", { + mediaType: { + previews: ["inertia"] + } + }], + listCollaborators: ["GET /projects/{project_id}/collaborators", { + mediaType: { + previews: ["inertia"] + } + }], + listColumns: ["GET /projects/{project_id}/columns", { + mediaType: { + previews: ["inertia"] + } + }], + listForOrg: ["GET /orgs/{org}/projects", { + mediaType: { + previews: ["inertia"] + } + }], + listForRepo: ["GET /repos/{owner}/{repo}/projects", { + mediaType: { + previews: ["inertia"] + } + }], + listForUser: ["GET /users/{username}/projects", { + mediaType: { + previews: ["inertia"] + } + }], + moveCard: ["POST /projects/columns/cards/{card_id}/moves", { + mediaType: { + previews: ["inertia"] + } + }], + moveColumn: ["POST /projects/columns/{column_id}/moves", { + mediaType: { + previews: ["inertia"] + } + }], + removeCollaborator: ["DELETE /projects/{project_id}/collaborators/{username}", { + mediaType: { + previews: ["inertia"] + } + }], + update: ["PATCH /projects/{project_id}", { + mediaType: { + previews: ["inertia"] + } + }], + updateCard: ["PATCH /projects/columns/cards/{card_id}", { + mediaType: { + previews: ["inertia"] + } + }], + updateColumn: ["PATCH /projects/columns/{column_id}", { + mediaType: { + previews: ["inertia"] + } + }] + }, + pulls: { + checkIfMerged: ["GET /repos/{owner}/{repo}/pulls/{pull_number}/merge"], + create: ["POST /repos/{owner}/{repo}/pulls"], + 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", { + mediaType: { + previews: ["lydian"] + } + }], + updateReview: ["PUT /repos/{owner}/{repo}/pulls/{pull_number}/reviews/{review_id}"], + updateReviewComment: ["PATCH /repos/{owner}/{repo}/pulls/comments/{comment_id}"] + }, + rateLimit: { + get: ["GET /rate_limit"] + }, + reactions: { + createForCommitComment: ["POST /repos/{owner}/{repo}/comments/{comment_id}/reactions", { + mediaType: { + previews: ["squirrel-girl"] + } + }], + createForIssue: ["POST /repos/{owner}/{repo}/issues/{issue_number}/reactions", { + mediaType: { + previews: ["squirrel-girl"] + } + }], + createForIssueComment: ["POST /repos/{owner}/{repo}/issues/comments/{comment_id}/reactions", { + mediaType: { + previews: ["squirrel-girl"] + } + }], + createForPullRequestReviewComment: ["POST /repos/{owner}/{repo}/pulls/comments/{comment_id}/reactions", { + mediaType: { + previews: ["squirrel-girl"] + } + }], + createForRelease: ["POST /repos/{owner}/{repo}/releases/{release_id}/reactions", { + mediaType: { + previews: ["squirrel-girl"] + } + }], + createForTeamDiscussionCommentInOrg: ["POST /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/comments/{comment_number}/reactions", { + mediaType: { + previews: ["squirrel-girl"] + } + }], + createForTeamDiscussionInOrg: ["POST /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/reactions", { + mediaType: { + previews: ["squirrel-girl"] + } + }], + deleteForCommitComment: ["DELETE /repos/{owner}/{repo}/comments/{comment_id}/reactions/{reaction_id}", { + mediaType: { + previews: ["squirrel-girl"] + } + }], + deleteForIssue: ["DELETE /repos/{owner}/{repo}/issues/{issue_number}/reactions/{reaction_id}", { + mediaType: { + previews: ["squirrel-girl"] + } + }], + deleteForIssueComment: ["DELETE /repos/{owner}/{repo}/issues/comments/{comment_id}/reactions/{reaction_id}", { + mediaType: { + previews: ["squirrel-girl"] + } + }], + deleteForPullRequestComment: ["DELETE /repos/{owner}/{repo}/pulls/comments/{comment_id}/reactions/{reaction_id}", { + mediaType: { + previews: ["squirrel-girl"] + } + }], + deleteForTeamDiscussion: ["DELETE /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/reactions/{reaction_id}", { + mediaType: { + previews: ["squirrel-girl"] + } + }], + deleteForTeamDiscussionComment: ["DELETE /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/comments/{comment_number}/reactions/{reaction_id}", { + mediaType: { + previews: ["squirrel-girl"] + } + }], + deleteLegacy: ["DELETE /reactions/{reaction_id}", { + mediaType: { + previews: ["squirrel-girl"] + } + }, { + deprecated: "octokit.rest.reactions.deleteLegacy() is deprecated, see https://docs.github.com/rest/reference/reactions/#delete-a-reaction-legacy" + }], + listForCommitComment: ["GET /repos/{owner}/{repo}/comments/{comment_id}/reactions", { + mediaType: { + previews: ["squirrel-girl"] + } + }], + listForIssue: ["GET /repos/{owner}/{repo}/issues/{issue_number}/reactions", { + mediaType: { + previews: ["squirrel-girl"] + } + }], + listForIssueComment: ["GET /repos/{owner}/{repo}/issues/comments/{comment_id}/reactions", { + mediaType: { + previews: ["squirrel-girl"] + } + }], + listForPullRequestReviewComment: ["GET /repos/{owner}/{repo}/pulls/comments/{comment_id}/reactions", { + mediaType: { + previews: ["squirrel-girl"] + } + }], + listForTeamDiscussionCommentInOrg: ["GET /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/comments/{comment_number}/reactions", { + mediaType: { + previews: ["squirrel-girl"] + } + }], + listForTeamDiscussionInOrg: ["GET /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/reactions", { + mediaType: { + previews: ["squirrel-girl"] + } + }] + }, + repos: { + acceptInvitation: ["PATCH /user/repository_invitations/{invitation_id}"], + addAppAccessRestrictions: ["POST /repos/{owner}/{repo}/branches/{branch}/protection/restrictions/apps", {}, { + mapToData: "apps" + }], + addCollaborator: ["PUT /repos/{owner}/{repo}/collaborators/{username}"], + addStatusCheckContexts: ["POST /repos/{owner}/{repo}/branches/{branch}/protection/required_status_checks/contexts", {}, { + mapToData: "contexts" + }], + addTeamAccessRestrictions: ["POST /repos/{owner}/{repo}/branches/{branch}/protection/restrictions/teams", {}, { + mapToData: "teams" + }], + addUserAccessRestrictions: ["POST /repos/{owner}/{repo}/branches/{branch}/protection/restrictions/users", {}, { + mapToData: "users" + }], + checkCollaborator: ["GET /repos/{owner}/{repo}/collaborators/{username}"], + checkVulnerabilityAlerts: ["GET /repos/{owner}/{repo}/vulnerability-alerts", { + mediaType: { + previews: ["dorian"] + } + }], + compareCommits: ["GET /repos/{owner}/{repo}/compare/{base}...{head}"], + 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", { + mediaType: { + previews: ["zzzax"] + } + }], + createCommitStatus: ["POST /repos/{owner}/{repo}/statuses/{sha}"], + createDeployKey: ["POST /repos/{owner}/{repo}/keys"], + createDeployment: ["POST /repos/{owner}/{repo}/deployments"], + createDeploymentStatus: ["POST /repos/{owner}/{repo}/deployments/{deployment_id}/statuses"], + createDispatchEvent: ["POST /repos/{owner}/{repo}/dispatches"], + createForAuthenticatedUser: ["POST /user/repos"], + createFork: ["POST /repos/{owner}/{repo}/forks"], + 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", { + mediaType: { + previews: ["switcheroo"] + } + }], + createRelease: ["POST /repos/{owner}/{repo}/releases"], + createUsingTemplate: ["POST /repos/{template_owner}/{template_repo}/generate", { + mediaType: { + previews: ["baptiste"] + } + }], + createWebhook: ["POST /repos/{owner}/{repo}/hooks"], + declineInvitation: ["DELETE /user/repository_invitations/{invitation_id}"], + delete: ["DELETE /repos/{owner}/{repo}"], + deleteAccessRestrictions: ["DELETE /repos/{owner}/{repo}/branches/{branch}/protection/restrictions"], + deleteAdminBranchProtection: ["DELETE /repos/{owner}/{repo}/branches/{branch}/protection/enforce_admins"], + 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", { + mediaType: { + previews: ["zzzax"] + } + }], + 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", { + mediaType: { + previews: ["switcheroo"] + } + }], + deletePullRequestReviewProtection: ["DELETE /repos/{owner}/{repo}/branches/{branch}/protection/required_pull_request_reviews"], + deleteRelease: ["DELETE /repos/{owner}/{repo}/releases/{release_id}"], + deleteReleaseAsset: ["DELETE /repos/{owner}/{repo}/releases/assets/{asset_id}"], + deleteWebhook: ["DELETE /repos/{owner}/{repo}/hooks/{hook_id}"], + disableAutomatedSecurityFixes: ["DELETE /repos/{owner}/{repo}/automated-security-fixes", { + mediaType: { + previews: ["london"] + } + }], + disableVulnerabilityAlerts: ["DELETE /repos/{owner}/{repo}/vulnerability-alerts", { + mediaType: { + previews: ["dorian"] + } + }], + 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", { + mediaType: { + previews: ["london"] + } + }], + enableVulnerabilityAlerts: ["PUT /repos/{owner}/{repo}/vulnerability-alerts", { + mediaType: { + previews: ["dorian"] + } + }], + get: ["GET /repos/{owner}/{repo}"], + getAccessRestrictions: ["GET /repos/{owner}/{repo}/branches/{branch}/protection/restrictions"], + getAdminBranchProtection: ["GET /repos/{owner}/{repo}/branches/{branch}/protection/enforce_admins"], + getAllEnvironments: ["GET /repos/{owner}/{repo}/environments"], + getAllStatusCheckContexts: ["GET /repos/{owner}/{repo}/branches/{branch}/protection/required_status_checks/contexts"], + getAllTopics: ["GET /repos/{owner}/{repo}/topics", { + mediaType: { + previews: ["mercy"] + } + }], + getAppsWithAccessToProtectedBranch: ["GET /repos/{owner}/{repo}/branches/{branch}/protection/restrictions/apps"], + 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", { + mediaType: { + previews: ["zzzax"] + } + }], + 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", { + mediaType: { + previews: ["groot"] + } + }], + 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", { + mediaType: { + previews: ["groot"] + } + }], + listReleaseAssets: ["GET /repos/{owner}/{repo}/releases/{release_id}/assets"], + listReleases: ["GET /repos/{owner}/{repo}/releases"], + 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"], + 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", { + mediaType: { + previews: ["mercy"] + } + }], + 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", { + mediaType: { + previews: ["cloak"] + } + }], + issuesAndPullRequests: ["GET /search/issues"], + labels: ["GET /search/labels"], + repos: ["GET /search/repositories"], + topics: ["GET /search/topics", { + mediaType: { + previews: ["mercy"] + } + }], + users: ["GET /search/users"] + }, + secretScanning: { + getAlert: ["GET /repos/{owner}/{repo}/secret-scanning/alerts/{alert_number}"], + listAlertsForRepo: ["GET /repos/{owner}/{repo}/secret-scanning/alerts"], + 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}", { + mediaType: { + previews: ["inertia"] + } + }], + addOrUpdateRepoPermissionsInOrg: ["PUT /orgs/{org}/teams/{team_slug}/repos/{owner}/{repo}"], + checkPermissionsForProjectInOrg: ["GET /orgs/{org}/teams/{team_slug}/projects/{project_id}", { + mediaType: { + previews: ["inertia"] + } + }], + checkPermissionsForRepoInOrg: ["GET /orgs/{org}/teams/{team_slug}/repos/{owner}/{repo}"], + create: ["POST /orgs/{org}/teams"], + createDiscussionCommentInOrg: ["POST /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/comments"], + createDiscussionInOrg: ["POST /orgs/{org}/teams/{team_slug}/discussions"], + deleteDiscussionCommentInOrg: ["DELETE /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/comments/{comment_number}"], + deleteDiscussionInOrg: ["DELETE /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}"], + deleteInOrg: ["DELETE /orgs/{org}/teams/{team_slug}"], + getByName: ["GET /orgs/{org}/teams/{team_slug}"], + getDiscussionCommentInOrg: ["GET /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/comments/{comment_number}"], + getDiscussionInOrg: ["GET /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}"], + getMembershipForUserInOrg: ["GET /orgs/{org}/teams/{team_slug}/memberships/{username}"], + list: ["GET /orgs/{org}/teams"], + listChildInOrg: ["GET /orgs/{org}/teams/{team_slug}/teams"], + listDiscussionCommentsInOrg: ["GET /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/comments"], + listDiscussionsInOrg: ["GET /orgs/{org}/teams/{team_slug}/discussions"], + listForAuthenticatedUser: ["GET /user/teams"], + listMembersInOrg: ["GET /orgs/{org}/teams/{team_slug}/members"], + listPendingInvitationsInOrg: ["GET /orgs/{org}/teams/{team_slug}/invitations"], + listProjectsInOrg: ["GET /orgs/{org}/teams/{team_slug}/projects", { + mediaType: { + previews: ["inertia"] + } + }], + listReposInOrg: ["GET /orgs/{org}/teams/{team_slug}/repos"], + removeMembershipForUserInOrg: ["DELETE /orgs/{org}/teams/{team_slug}/memberships/{username}"], + 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"], + 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"], + createPublicSshKeyForAuthenticated: ["POST /user/keys"], + deleteEmailForAuthenticated: ["DELETE /user/emails"], + deleteGpgKeyForAuthenticated: ["DELETE /user/gpg_keys/{gpg_key_id}"], + deletePublicSshKeyForAuthenticated: ["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}"], + getPublicSshKeyForAuthenticated: ["GET /user/keys/{key_id}"], + list: ["GET /users"], + listBlockedByAuthenticated: ["GET /user/blocks"], + listEmailsForAuthenticated: ["GET /user/emails"], + listFollowedByAuthenticated: ["GET /user/following"], + listFollowersForAuthenticatedUser: ["GET /user/followers"], + listFollowersForUser: ["GET /users/{username}/followers"], + listFollowingForUser: ["GET /users/{username}/following"], + listGpgKeysForAuthenticated: ["GET /user/gpg_keys"], + listGpgKeysForUser: ["GET /users/{username}/gpg_keys"], + listPublicEmailsForAuthenticated: ["GET /user/public_emails"], + listPublicKeysForUser: ["GET /users/{username}/keys"], + listPublicSshKeysForAuthenticated: ["GET /user/keys"], + setPrimaryEmailVisibilityForAuthenticated: ["PATCH /user/email/visibility"], + unblock: ["DELETE /user/blocks/{username}"], + unfollow: ["DELETE /user/following/{username}"], + updateAuthenticated: ["PATCH /user"] + } +}; + +const VERSION = "5.7.0"; + +function endpointsToMethods(octokit, endpointsMap) { + const newMethods = {}; + + for (const [scope, endpoints] of Object.entries(endpointsMap)) { + for (const [methodName, endpoint] of Object.entries(endpoints)) { + const [route, defaults, decorations] = endpoint; + const [method, url] = route.split(/ /); + const endpointDefaults = Object.assign({ + method, + url + }, defaults); + + if (!newMethods[scope]) { + newMethods[scope] = {}; + } + + const scopeMethods = newMethods[scope]; + + if (decorations) { + scopeMethods[methodName] = decorate(octokit, scope, methodName, endpointDefaults, decorations); + continue; + } + + scopeMethods[methodName] = octokit.request.defaults(endpointDefaults); + } + } + + return newMethods; +} + +function decorate(octokit, scope, methodName, defaults, decorations) { + const requestWithDefaults = octokit.request.defaults(defaults); + /* 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 + + +/***/ }), + +/***/ 10537: +/***/ ((__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__(58932); +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 + + +/***/ }), + +/***/ 36234: +/***/ ((__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__(59440); +var universalUserAgent = __nccwpck_require__(45030); +var isPlainObject = __nccwpck_require__(63287); +var nodeFetch = _interopDefault(__nccwpck_require__(80467)); +var requestError = __nccwpck_require__(10537); + +const VERSION = "5.6.1"; + +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 + + +/***/ }), + +/***/ 83682: +/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { + +var register = __nccwpck_require__(44670) +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, + }); +} + + +/***/ }), + +/***/ 44670: +/***/ ((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); +} + + +/***/ }), + +/***/ 28222: +/***/ ((module, exports, __nccwpck_require__) => { + +/* eslint-env browser */ + +/** + * This is the web browser implementation of `debug()`. + */ + +exports.log = log; +exports.formatArgs = formatArgs; +exports.save = save; +exports.load = load; +exports.useColors = useColors; +exports.storage = localstorage(); + +/** + * Colors. + */ + +exports.colors = [ + '#0000CC', + '#0000FF', + '#0033CC', + '#0033FF', + '#0066CC', + '#0066FF', + '#0099CC', + '#0099FF', + '#00CC00', + '#00CC33', + '#00CC66', + '#00CC99', + '#00CCCC', + '#00CCFF', + '#3300CC', + '#3300FF', + '#3333CC', + '#3333FF', + '#3366CC', + '#3366FF', + '#3399CC', + '#3399FF', + '#33CC00', + '#33CC33', + '#33CC66', + '#33CC99', + '#33CCCC', + '#33CCFF', + '#6600CC', + '#6600FF', + '#6633CC', + '#6633FF', + '#66CC00', + '#66CC33', + '#9900CC', + '#9900FF', + '#9933CC', + '#9933FF', + '#99CC00', + '#99CC33', + '#CC0000', + '#CC0033', + '#CC0066', + '#CC0099', + '#CC00CC', + '#CC00FF', + '#CC3300', + '#CC3333', + '#CC3366', + '#CC3399', + '#CC33CC', + '#CC33FF', + '#CC6600', + '#CC6633', + '#CC9900', + '#CC9933', + '#CCCC00', + '#CCCC33', + '#FF0000', + '#FF0033', + '#FF0066', + '#FF0099', + '#FF00CC', + '#FF00FF', + '#FF3300', + '#FF3333', + '#FF3366', + '#FF3399', + '#FF33CC', + '#FF33FF', + '#FF6600', + '#FF6633', + '#FF9900', + '#FF9933', + '#FFCC00', + '#FFCC33' +]; + +/** + * Currently only WebKit-based Web Inspectors, Firefox >= v31, + * and the Firebug extension (any Firefox version) are known + * to support "%c" CSS customizations. + * + * TODO: add a `localStorage` variable to explicitly enable/disable colors + */ + +// eslint-disable-next-line complexity +function useColors() { + // NB: In an Electron preload script, document will be defined but not fully + // initialized. Since we know we're in Chrome, we'll just detect this case + // explicitly + if (typeof window !== 'undefined' && window.process && (window.process.type === 'renderer' || window.process.__nwjs)) { + return true; + } + + // Internet Explorer and Edge do not support colors. + if (typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/(edge|trident)\/(\d+)/)) { + return false; + } + + // Is webkit? http://stackoverflow.com/a/16459606/376773 + // document is undefined in react-native: https://github.com/facebook/react-native/pull/1632 + return (typeof document !== 'undefined' && document.documentElement && document.documentElement.style && document.documentElement.style.WebkitAppearance) || + // Is firebug? http://stackoverflow.com/a/398120/376773 + (typeof window !== 'undefined' && window.console && (window.console.firebug || (window.console.exception && window.console.table))) || + // Is firefox >= v31? + // https://developer.mozilla.org/en-US/docs/Tools/Web_Console#Styling_messages + (typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/firefox\/(\d+)/) && parseInt(RegExp.$1, 10) >= 31) || + // Double check webkit in userAgent just in case we are in a worker + (typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/applewebkit\/(\d+)/)); +} + +/** + * Colorize log arguments if enabled. + * + * @api public + */ + +function formatArgs(args) { + args[0] = (this.useColors ? '%c' : '') + + this.namespace + + (this.useColors ? ' %c' : ' ') + + args[0] + + (this.useColors ? '%c ' : ' ') + + '+' + module.exports.humanize(this.diff); + + if (!this.useColors) { + return; + } + + const c = 'color: ' + this.color; + args.splice(1, 0, c, 'color: inherit'); + + // The final "%c" is somewhat tricky, because there could be other + // arguments passed either before or after the %c, so we need to + // figure out the correct index to insert the CSS into + let index = 0; + let lastC = 0; + args[0].replace(/%[a-zA-Z%]/g, match => { + if (match === '%%') { + return; + } + index++; + if (match === '%c') { + // We only are interested in the *last* %c + // (the user may have provided their own) + lastC = index; + } + }); + + args.splice(lastC, 0, c); +} + +/** + * Invokes `console.log()` when available. + * No-op when `console.log` is not a "function". + * + * @api public + */ +function log(...args) { + // This hackery is required for IE8/9, where + // the `console.log` function doesn't have 'apply' + return typeof console === 'object' && + console.log && + console.log(...args); +} + +/** + * Save `namespaces`. + * + * @param {String} namespaces + * @api private + */ +function save(namespaces) { + try { + if (namespaces) { + exports.storage.setItem('debug', namespaces); + } else { + exports.storage.removeItem('debug'); + } + } catch (error) { + // Swallow + // XXX (@Qix-) should we be logging these? + } +} + +/** + * Load `namespaces`. + * + * @return {String} returns the previously persisted debug modes + * @api private + */ +function load() { + let r; + try { + r = exports.storage.getItem('debug'); + } catch (error) { + // Swallow + // XXX (@Qix-) should we be logging these? + } + + // If debug isn't set in LS, and we're in Electron, try to load $DEBUG + if (!r && typeof process !== 'undefined' && 'env' in process) { + r = process.env.DEBUG; + } + + return r; +} + +/** + * Localstorage attempts to return the localstorage. + * + * This is necessary because safari throws + * when a user disables cookies/localstorage + * and you attempt to access it. + * + * @return {LocalStorage} + * @api private + */ + +function localstorage() { + try { + // TVMLKit (Apple TV JS Runtime) does not have a window object, just localStorage in the global context + // The Browser also has localStorage in the global context. + return localStorage; + } catch (error) { + // Swallow + // XXX (@Qix-) should we be logging these? + } +} + +module.exports = __nccwpck_require__(46243)(exports); + +const {formatters} = module.exports; + +/** + * Map %j to `JSON.stringify()`, since no Web Inspectors do that by default. + */ + +formatters.j = function (v) { + try { + return JSON.stringify(v); + } catch (error) { + return '[UnexpectedJSONParseError]: ' + error.message; + } +}; + + +/***/ }), + +/***/ 46243: +/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { + + +/** + * This is the common logic for both the Node.js and web browser + * implementations of `debug()`. + */ + +function setup(env) { + createDebug.debug = createDebug; + createDebug.default = createDebug; + createDebug.coerce = coerce; + createDebug.disable = disable; + createDebug.enable = enable; + createDebug.enabled = enabled; + createDebug.humanize = __nccwpck_require__(80900); + + Object.keys(env).forEach(key => { + createDebug[key] = env[key]; + }); + + /** + * Active `debug` instances. + */ + createDebug.instances = []; + + /** + * The currently active debug mode names, and names to skip. + */ + + createDebug.names = []; + createDebug.skips = []; + + /** + * Map of special "%n" handling functions, for the debug "format" argument. + * + * Valid key names are a single, lower or upper-case letter, i.e. "n" and "N". + */ + createDebug.formatters = {}; + + /** + * Selects a color for a debug namespace + * @param {String} namespace The namespace string for the for the debug instance to be colored + * @return {Number|String} An ANSI color code for the given namespace + * @api private + */ + function selectColor(namespace) { + let hash = 0; + + for (let i = 0; i < namespace.length; i++) { + hash = ((hash << 5) - hash) + namespace.charCodeAt(i); + hash |= 0; // Convert to 32bit integer + } + + return createDebug.colors[Math.abs(hash) % createDebug.colors.length]; + } + createDebug.selectColor = selectColor; + + /** + * Create a debugger with the given `namespace`. + * + * @param {String} namespace + * @return {Function} + * @api public + */ + function createDebug(namespace) { + let prevTime; + + function debug(...args) { + // Disabled? + if (!debug.enabled) { + return; + } + + const self = debug; + + // Set `diff` timestamp + const curr = Number(new Date()); + const ms = curr - (prevTime || curr); + self.diff = ms; + self.prev = prevTime; + self.curr = curr; + prevTime = curr; + + args[0] = createDebug.coerce(args[0]); + + if (typeof args[0] !== 'string') { + // Anything else let's inspect with %O + args.unshift('%O'); + } + + // Apply any `formatters` transformations + let index = 0; + args[0] = args[0].replace(/%([a-zA-Z%])/g, (match, format) => { + // If we encounter an escaped % then don't increase the array index + if (match === '%%') { + return match; + } + index++; + const formatter = createDebug.formatters[format]; + if (typeof formatter === 'function') { + const val = args[index]; + match = formatter.call(self, val); + + // Now we need to remove `args[index]` since it's inlined in the `format` + args.splice(index, 1); + index--; + } + return match; + }); + + // Apply env-specific formatting (colors, etc.) + createDebug.formatArgs.call(self, args); + + const logFn = self.log || createDebug.log; + logFn.apply(self, args); + } + + debug.namespace = namespace; + debug.enabled = createDebug.enabled(namespace); + debug.useColors = createDebug.useColors(); + debug.color = selectColor(namespace); + debug.destroy = destroy; + debug.extend = extend; + // Debug.formatArgs = formatArgs; + // debug.rawLog = rawLog; + + // env-specific initialization logic for debug instances + if (typeof createDebug.init === 'function') { + createDebug.init(debug); + } + + createDebug.instances.push(debug); + + return debug; + } + + function destroy() { + const index = createDebug.instances.indexOf(this); + if (index !== -1) { + createDebug.instances.splice(index, 1); + return true; + } + return false; + } + + function extend(namespace, delimiter) { + const newDebug = createDebug(this.namespace + (typeof delimiter === 'undefined' ? ':' : delimiter) + namespace); + newDebug.log = this.log; + return newDebug; + } + + /** + * Enables a debug mode by namespaces. This can include modes + * separated by a colon and wildcards. + * + * @param {String} namespaces + * @api public + */ + function enable(namespaces) { + createDebug.save(namespaces); + + createDebug.names = []; + createDebug.skips = []; + + let i; + const split = (typeof namespaces === 'string' ? namespaces : '').split(/[\s,]+/); + const len = split.length; + + for (i = 0; i < len; i++) { + if (!split[i]) { + // ignore empty strings + continue; + } + + namespaces = split[i].replace(/\*/g, '.*?'); + + if (namespaces[0] === '-') { + createDebug.skips.push(new RegExp('^' + namespaces.substr(1) + '$')); + } else { + createDebug.names.push(new RegExp('^' + namespaces + '$')); + } + } + + for (i = 0; i < createDebug.instances.length; i++) { + const instance = createDebug.instances[i]; + instance.enabled = createDebug.enabled(instance.namespace); + } + } + + /** + * Disable debug output. + * + * @return {String} namespaces + * @api public + */ + function disable() { + const namespaces = [ + ...createDebug.names.map(toNamespace), + ...createDebug.skips.map(toNamespace).map(namespace => '-' + namespace) + ].join(','); + createDebug.enable(''); + return namespaces; + } + + /** + * Returns true if the given mode name is enabled, false otherwise. + * + * @param {String} name + * @return {Boolean} + * @api public + */ + function enabled(name) { + if (name[name.length - 1] === '*') { + return true; + } + + let i; + let len; + + for (i = 0, len = createDebug.skips.length; i < len; i++) { + if (createDebug.skips[i].test(name)) { + return false; + } + } + + for (i = 0, len = createDebug.names.length; i < len; i++) { + if (createDebug.names[i].test(name)) { + return true; + } + } + + return false; + } + + /** + * Convert regexp to namespace + * + * @param {RegExp} regxep + * @return {String} namespace + * @api private + */ + function toNamespace(regexp) { + return regexp.toString() + .substring(2, regexp.toString().length - 2) + .replace(/\.\*\?$/, '*'); + } + + /** + * Coerce `val`. + * + * @param {Mixed} val + * @return {Mixed} + * @api private + */ + function coerce(val) { + if (val instanceof Error) { + return val.stack || val.message; + } + return val; + } + + createDebug.enable(createDebug.load()); + + return createDebug; +} + +module.exports = setup; + + +/***/ }), + +/***/ 38237: +/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { + +/** + * Detect Electron renderer / nwjs process, which is node, but we should + * treat as a browser. + */ + +if (typeof process === 'undefined' || process.type === 'renderer' || process.browser === true || process.__nwjs) { + module.exports = __nccwpck_require__(28222); +} else { + module.exports = __nccwpck_require__(35332); +} + + +/***/ }), + +/***/ 35332: +/***/ ((module, exports, __nccwpck_require__) => { + +/** + * Module dependencies. + */ + +const tty = __nccwpck_require__(33867); +const util = __nccwpck_require__(31669); + +/** + * This is the Node.js implementation of `debug()`. + */ + +exports.init = init; +exports.log = log; +exports.formatArgs = formatArgs; +exports.save = save; +exports.load = load; +exports.useColors = useColors; + +/** + * Colors. + */ + +exports.colors = [6, 2, 3, 4, 5, 1]; + +try { + // Optional dependency (as in, doesn't need to be installed, NOT like optionalDependencies in package.json) + // eslint-disable-next-line import/no-extraneous-dependencies + const supportsColor = __nccwpck_require__(59318); + + if (supportsColor && (supportsColor.stderr || supportsColor).level >= 2) { + exports.colors = [ + 20, + 21, + 26, + 27, + 32, + 33, + 38, + 39, + 40, + 41, + 42, + 43, + 44, + 45, + 56, + 57, + 62, + 63, + 68, + 69, + 74, + 75, + 76, + 77, + 78, + 79, + 80, + 81, + 92, + 93, + 98, + 99, + 112, + 113, + 128, + 129, + 134, + 135, + 148, + 149, + 160, + 161, + 162, + 163, + 164, + 165, + 166, + 167, + 168, + 169, + 170, + 171, + 172, + 173, + 178, + 179, + 184, + 185, + 196, + 197, + 198, + 199, + 200, + 201, + 202, + 203, + 204, + 205, + 206, + 207, + 208, + 209, + 214, + 215, + 220, + 221 + ]; + } +} catch (error) { + // Swallow - we only care if `supports-color` is available; it doesn't have to be. +} + +/** + * Build up the default `inspectOpts` object from the environment variables. + * + * $ DEBUG_COLORS=no DEBUG_DEPTH=10 DEBUG_SHOW_HIDDEN=enabled node script.js + */ + +exports.inspectOpts = Object.keys(process.env).filter(key => { + return /^debug_/i.test(key); +}).reduce((obj, key) => { + // Camel-case + const prop = key + .substring(6) + .toLowerCase() + .replace(/_([a-z])/g, (_, k) => { + return k.toUpperCase(); + }); + + // Coerce string value into JS value + let val = process.env[key]; + if (/^(yes|on|true|enabled)$/i.test(val)) { + val = true; + } else if (/^(no|off|false|disabled)$/i.test(val)) { + val = false; + } else if (val === 'null') { + val = null; + } else { + val = Number(val); + } + + obj[prop] = val; + return obj; +}, {}); + +/** + * Is stdout a TTY? Colored output is enabled when `true`. + */ + +function useColors() { + return 'colors' in exports.inspectOpts ? + Boolean(exports.inspectOpts.colors) : + tty.isatty(process.stderr.fd); +} + +/** + * Adds ANSI color escape codes if enabled. + * + * @api public + */ + +function formatArgs(args) { + const {namespace: name, useColors} = this; + + if (useColors) { + const c = this.color; + const colorCode = '\u001B[3' + (c < 8 ? c : '8;5;' + c); + const prefix = ` ${colorCode};1m${name} \u001B[0m`; + + args[0] = prefix + args[0].split('\n').join('\n' + prefix); + args.push(colorCode + 'm+' + module.exports.humanize(this.diff) + '\u001B[0m'); + } else { + args[0] = getDate() + name + ' ' + args[0]; + } +} + +function getDate() { + if (exports.inspectOpts.hideDate) { + return ''; + } + return new Date().toISOString() + ' '; +} + +/** + * Invokes `util.format()` with the specified arguments and writes to stderr. + */ + +function log(...args) { + return process.stderr.write(util.format(...args) + '\n'); +} + +/** + * Save `namespaces`. + * + * @param {String} namespaces + * @api private + */ +function save(namespaces) { + if (namespaces) { + process.env.DEBUG = namespaces; + } else { + // If you set a process.env field to null or undefined, it gets cast to the + // string 'null' or 'undefined'. Just delete instead. + delete process.env.DEBUG; + } +} + +/** + * Load `namespaces`. + * + * @return {String} returns the previously persisted debug modes + * @api private + */ + +function load() { + return process.env.DEBUG; +} + +/** + * Init logic for `debug` instances. + * + * Create a new `inspectOpts` object in case `useColors` is set + * differently for a particular `debug` instance. + */ + +function init(debug) { + debug.inspectOpts = {}; + + const keys = Object.keys(exports.inspectOpts); + for (let i = 0; i < keys.length; i++) { + debug.inspectOpts[keys[i]] = exports.inspectOpts[keys[i]]; + } +} + +module.exports = __nccwpck_require__(46243)(exports); + +const {formatters} = module.exports; + +/** + * Map %o to `util.inspect()`, all on a single line. + */ + +formatters.o = function (v) { + this.inspectOpts.colors = this.useColors; + return util.inspect(v, this.inspectOpts) + .replace(/\s*\n\s*/g, ' '); +}; + +/** + * Map %O to `util.inspect()`, allowing multiple lines if needed. + */ + +formatters.O = function (v) { + this.inspectOpts.colors = this.useColors; + return util.inspect(v, this.inspectOpts); +}; + + +/***/ }), + +/***/ 58932: +/***/ ((__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; + + +/***/ }), + +/***/ 31621: +/***/ ((module) => { + +"use strict"; + +module.exports = (flag, argv) => { + argv = argv || process.argv; + const prefix = flag.startsWith('-') ? '' : (flag.length === 1 ? '-' : '--'); + const pos = argv.indexOf(prefix + flag); + const terminatorPos = argv.indexOf('--'); + return pos !== -1 && (terminatorPos === -1 ? true : pos < terminatorPos); +}; + + +/***/ }), + +/***/ 63287: +/***/ ((__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; + + +/***/ }), + +/***/ 21917: +/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { + +"use strict"; + + + +var loader = __nccwpck_require__(51161); +var dumper = __nccwpck_require__(68866); + + +function renamed(from, to) { + return function () { + throw new Error('Function yaml.' + from + ' is removed in js-yaml 4. ' + + 'Use yaml.' + to + ' instead, which is now safe by default.'); + }; +} + + +module.exports.Type = __nccwpck_require__(6073); +module.exports.Schema = __nccwpck_require__(21082); +module.exports.FAILSAFE_SCHEMA = __nccwpck_require__(28562); +module.exports.JSON_SCHEMA = __nccwpck_require__(1035); +module.exports.CORE_SCHEMA = __nccwpck_require__(12011); +module.exports.DEFAULT_SCHEMA = __nccwpck_require__(18759); +module.exports.load = loader.load; +module.exports.loadAll = loader.loadAll; +module.exports.dump = dumper.dump; +module.exports.YAMLException = __nccwpck_require__(68179); + +// Re-export all types in case user wants to create custom schema +module.exports.types = { + binary: __nccwpck_require__(77900), + float: __nccwpck_require__(42705), + map: __nccwpck_require__(86150), + null: __nccwpck_require__(20721), + pairs: __nccwpck_require__(96860), + set: __nccwpck_require__(79548), + timestamp: __nccwpck_require__(99212), + bool: __nccwpck_require__(64993), + int: __nccwpck_require__(11615), + merge: __nccwpck_require__(86104), + omap: __nccwpck_require__(19046), + seq: __nccwpck_require__(67283), + str: __nccwpck_require__(23619) +}; + +// Removed functions from JS-YAML 3.0.x +module.exports.safeLoad = renamed('safeLoad', 'load'); +module.exports.safeLoadAll = renamed('safeLoadAll', 'loadAll'); +module.exports.safeDump = renamed('safeDump', 'dump'); + + +/***/ }), + +/***/ 26829: +/***/ ((module) => { + +"use strict"; + + + +function isNothing(subject) { + return (typeof subject === 'undefined') || (subject === null); +} + + +function isObject(subject) { + return (typeof subject === 'object') && (subject !== null); +} + + +function toArray(sequence) { + if (Array.isArray(sequence)) return sequence; + else if (isNothing(sequence)) return []; + + return [ sequence ]; +} + + +function extend(target, source) { + var index, length, key, sourceKeys; + + if (source) { + sourceKeys = Object.keys(source); + + for (index = 0, length = sourceKeys.length; index < length; index += 1) { + key = sourceKeys[index]; + target[key] = source[key]; + } + } + + return target; +} + + +function repeat(string, count) { + var result = '', cycle; + + for (cycle = 0; cycle < count; cycle += 1) { + result += string; + } + + return result; +} + + +function isNegativeZero(number) { + return (number === 0) && (Number.NEGATIVE_INFINITY === 1 / number); +} + + +module.exports.isNothing = isNothing; +module.exports.isObject = isObject; +module.exports.toArray = toArray; +module.exports.repeat = repeat; +module.exports.isNegativeZero = isNegativeZero; +module.exports.extend = extend; + + +/***/ }), + +/***/ 68866: +/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { + +"use strict"; + + +/*eslint-disable no-use-before-define*/ + +var common = __nccwpck_require__(26829); +var YAMLException = __nccwpck_require__(68179); +var DEFAULT_SCHEMA = __nccwpck_require__(18759); + +var _toString = Object.prototype.toString; +var _hasOwnProperty = Object.prototype.hasOwnProperty; + +var CHAR_BOM = 0xFEFF; +var CHAR_TAB = 0x09; /* Tab */ +var CHAR_LINE_FEED = 0x0A; /* LF */ +var CHAR_CARRIAGE_RETURN = 0x0D; /* CR */ +var CHAR_SPACE = 0x20; /* Space */ +var CHAR_EXCLAMATION = 0x21; /* ! */ +var CHAR_DOUBLE_QUOTE = 0x22; /* " */ +var CHAR_SHARP = 0x23; /* # */ +var CHAR_PERCENT = 0x25; /* % */ +var CHAR_AMPERSAND = 0x26; /* & */ +var CHAR_SINGLE_QUOTE = 0x27; /* ' */ +var CHAR_ASTERISK = 0x2A; /* * */ +var CHAR_COMMA = 0x2C; /* , */ +var CHAR_MINUS = 0x2D; /* - */ +var CHAR_COLON = 0x3A; /* : */ +var CHAR_EQUALS = 0x3D; /* = */ +var CHAR_GREATER_THAN = 0x3E; /* > */ +var CHAR_QUESTION = 0x3F; /* ? */ +var CHAR_COMMERCIAL_AT = 0x40; /* @ */ +var CHAR_LEFT_SQUARE_BRACKET = 0x5B; /* [ */ +var CHAR_RIGHT_SQUARE_BRACKET = 0x5D; /* ] */ +var CHAR_GRAVE_ACCENT = 0x60; /* ` */ +var CHAR_LEFT_CURLY_BRACKET = 0x7B; /* { */ +var CHAR_VERTICAL_LINE = 0x7C; /* | */ +var CHAR_RIGHT_CURLY_BRACKET = 0x7D; /* } */ + +var ESCAPE_SEQUENCES = {}; + +ESCAPE_SEQUENCES[0x00] = '\\0'; +ESCAPE_SEQUENCES[0x07] = '\\a'; +ESCAPE_SEQUENCES[0x08] = '\\b'; +ESCAPE_SEQUENCES[0x09] = '\\t'; +ESCAPE_SEQUENCES[0x0A] = '\\n'; +ESCAPE_SEQUENCES[0x0B] = '\\v'; +ESCAPE_SEQUENCES[0x0C] = '\\f'; +ESCAPE_SEQUENCES[0x0D] = '\\r'; +ESCAPE_SEQUENCES[0x1B] = '\\e'; +ESCAPE_SEQUENCES[0x22] = '\\"'; +ESCAPE_SEQUENCES[0x5C] = '\\\\'; +ESCAPE_SEQUENCES[0x85] = '\\N'; +ESCAPE_SEQUENCES[0xA0] = '\\_'; +ESCAPE_SEQUENCES[0x2028] = '\\L'; +ESCAPE_SEQUENCES[0x2029] = '\\P'; + +var DEPRECATED_BOOLEANS_SYNTAX = [ + 'y', 'Y', 'yes', 'Yes', 'YES', 'on', 'On', 'ON', + 'n', 'N', 'no', 'No', 'NO', 'off', 'Off', 'OFF' +]; + +var DEPRECATED_BASE60_SYNTAX = /^[-+]?[0-9_]+(?::[0-9_]+)+(?:\.[0-9_]*)?$/; + +function compileStyleMap(schema, map) { + var result, keys, index, length, tag, style, type; + + if (map === null) return {}; + + result = {}; + keys = Object.keys(map); + + for (index = 0, length = keys.length; index < length; index += 1) { + tag = keys[index]; + style = String(map[tag]); + + if (tag.slice(0, 2) === '!!') { + tag = 'tag:yaml.org,2002:' + tag.slice(2); + } + type = schema.compiledTypeMap['fallback'][tag]; + + if (type && _hasOwnProperty.call(type.styleAliases, style)) { + style = type.styleAliases[style]; + } + + result[tag] = style; + } + + return result; +} + +function encodeHex(character) { + var string, handle, length; + + string = character.toString(16).toUpperCase(); + + if (character <= 0xFF) { + handle = 'x'; + length = 2; + } else if (character <= 0xFFFF) { + handle = 'u'; + length = 4; + } else if (character <= 0xFFFFFFFF) { + handle = 'U'; + length = 8; + } else { + throw new YAMLException('code point within a string may not be greater than 0xFFFFFFFF'); + } + + return '\\' + handle + common.repeat('0', length - string.length) + string; +} + + +var QUOTING_TYPE_SINGLE = 1, + QUOTING_TYPE_DOUBLE = 2; + +function State(options) { + this.schema = options['schema'] || DEFAULT_SCHEMA; + this.indent = Math.max(1, (options['indent'] || 2)); + this.noArrayIndent = options['noArrayIndent'] || false; + this.skipInvalid = options['skipInvalid'] || false; + this.flowLevel = (common.isNothing(options['flowLevel']) ? -1 : options['flowLevel']); + this.styleMap = compileStyleMap(this.schema, options['styles'] || null); + this.sortKeys = options['sortKeys'] || false; + this.lineWidth = options['lineWidth'] || 80; + this.noRefs = options['noRefs'] || false; + this.noCompatMode = options['noCompatMode'] || false; + this.condenseFlow = options['condenseFlow'] || false; + this.quotingType = options['quotingType'] === '"' ? QUOTING_TYPE_DOUBLE : QUOTING_TYPE_SINGLE; + this.forceQuotes = options['forceQuotes'] || false; + this.replacer = typeof options['replacer'] === 'function' ? options['replacer'] : null; + + this.implicitTypes = this.schema.compiledImplicit; + this.explicitTypes = this.schema.compiledExplicit; + + this.tag = null; + this.result = ''; + + this.duplicates = []; + this.usedDuplicates = null; +} + +// Indents every line in a string. Empty lines (\n only) are not indented. +function indentString(string, spaces) { + var ind = common.repeat(' ', spaces), + position = 0, + next = -1, + result = '', + line, + length = string.length; + + while (position < length) { + next = string.indexOf('\n', position); + if (next === -1) { + line = string.slice(position); + position = length; + } else { + line = string.slice(position, next + 1); + position = next + 1; + } + + if (line.length && line !== '\n') result += ind; + + result += line; + } + + return result; +} + +function generateNextLine(state, level) { + return '\n' + common.repeat(' ', state.indent * level); +} + +function testImplicitResolving(state, str) { + var index, length, type; + + for (index = 0, length = state.implicitTypes.length; index < length; index += 1) { + type = state.implicitTypes[index]; + + if (type.resolve(str)) { + return true; + } + } + + return false; +} + +// [33] s-white ::= s-space | s-tab +function isWhitespace(c) { + return c === CHAR_SPACE || c === CHAR_TAB; +} + +// Returns true if the character can be printed without escaping. +// From YAML 1.2: "any allowed characters known to be non-printable +// should also be escaped. [However,] This isn’t mandatory" +// Derived from nb-char - \t - #x85 - #xA0 - #x2028 - #x2029. +function isPrintable(c) { + return (0x00020 <= c && c <= 0x00007E) + || ((0x000A1 <= c && c <= 0x00D7FF) && c !== 0x2028 && c !== 0x2029) + || ((0x0E000 <= c && c <= 0x00FFFD) && c !== CHAR_BOM) + || (0x10000 <= c && c <= 0x10FFFF); +} + +// [34] ns-char ::= nb-char - s-white +// [27] nb-char ::= c-printable - b-char - c-byte-order-mark +// [26] b-char ::= b-line-feed | b-carriage-return +// Including s-white (for some reason, examples doesn't match specs in this aspect) +// ns-char ::= c-printable - b-line-feed - b-carriage-return - c-byte-order-mark +function isNsCharOrWhitespace(c) { + return isPrintable(c) + && c !== CHAR_BOM + // - b-char + && c !== CHAR_CARRIAGE_RETURN + && c !== CHAR_LINE_FEED; +} + +// [127] ns-plain-safe(c) ::= c = flow-out ⇒ ns-plain-safe-out +// c = flow-in ⇒ ns-plain-safe-in +// c = block-key ⇒ ns-plain-safe-out +// c = flow-key ⇒ ns-plain-safe-in +// [128] ns-plain-safe-out ::= ns-char +// [129] ns-plain-safe-in ::= ns-char - c-flow-indicator +// [130] ns-plain-char(c) ::= ( ns-plain-safe(c) - “:” - “#” ) +// | ( /* An ns-char preceding */ “#” ) +// | ( “:” /* Followed by an ns-plain-safe(c) */ ) +function isPlainSafe(c, prev, inblock) { + var cIsNsCharOrWhitespace = isNsCharOrWhitespace(c); + var cIsNsChar = cIsNsCharOrWhitespace && !isWhitespace(c); + return ( + // ns-plain-safe + inblock ? // c = flow-in + cIsNsCharOrWhitespace + : cIsNsCharOrWhitespace + // - c-flow-indicator + && c !== CHAR_COMMA + && c !== CHAR_LEFT_SQUARE_BRACKET + && c !== CHAR_RIGHT_SQUARE_BRACKET + && c !== CHAR_LEFT_CURLY_BRACKET + && c !== CHAR_RIGHT_CURLY_BRACKET + ) + // ns-plain-char + && c !== CHAR_SHARP // false on '#' + && !(prev === CHAR_COLON && !cIsNsChar) // false on ': ' + || (isNsCharOrWhitespace(prev) && !isWhitespace(prev) && c === CHAR_SHARP) // change to true on '[^ ]#' + || (prev === CHAR_COLON && cIsNsChar); // change to true on ':[^ ]' +} + +// Simplified test for values allowed as the first character in plain style. +function isPlainSafeFirst(c) { + // Uses a subset of ns-char - c-indicator + // where ns-char = nb-char - s-white. + // No support of ( ( “?” | “:” | “-” ) /* Followed by an ns-plain-safe(c)) */ ) part + return isPrintable(c) && c !== CHAR_BOM + && !isWhitespace(c) // - s-white + // - (c-indicator ::= + // “-” | “?” | “:” | “,” | “[” | “]” | “{” | “}” + && c !== CHAR_MINUS + && c !== CHAR_QUESTION + && c !== CHAR_COLON + && c !== CHAR_COMMA + && c !== CHAR_LEFT_SQUARE_BRACKET + && c !== CHAR_RIGHT_SQUARE_BRACKET + && c !== CHAR_LEFT_CURLY_BRACKET + && c !== CHAR_RIGHT_CURLY_BRACKET + // | “#” | “&” | “*” | “!” | “|” | “=” | “>” | “'” | “"” + && c !== CHAR_SHARP + && c !== CHAR_AMPERSAND + && c !== CHAR_ASTERISK + && c !== CHAR_EXCLAMATION + && c !== CHAR_VERTICAL_LINE + && c !== CHAR_EQUALS + && c !== CHAR_GREATER_THAN + && c !== CHAR_SINGLE_QUOTE + && c !== CHAR_DOUBLE_QUOTE + // | “%” | “@” | “`”) + && c !== CHAR_PERCENT + && c !== CHAR_COMMERCIAL_AT + && c !== CHAR_GRAVE_ACCENT; +} + +// Simplified test for values allowed as the last character in plain style. +function isPlainSafeLast(c) { + // just not whitespace or colon, it will be checked to be plain character later + return !isWhitespace(c) && c !== CHAR_COLON; +} + +// Same as 'string'.codePointAt(pos), but works in older browsers. +function codePointAt(string, pos) { + var first = string.charCodeAt(pos), second; + if (first >= 0xD800 && first <= 0xDBFF && pos + 1 < string.length) { + second = string.charCodeAt(pos + 1); + if (second >= 0xDC00 && second <= 0xDFFF) { + // https://mathiasbynens.be/notes/javascript-encoding#surrogate-formulae + return (first - 0xD800) * 0x400 + second - 0xDC00 + 0x10000; + } + } + return first; +} + +// Determines whether block indentation indicator is required. +function needIndentIndicator(string) { + var leadingSpaceRe = /^\n* /; + return leadingSpaceRe.test(string); +} + +var STYLE_PLAIN = 1, + STYLE_SINGLE = 2, + STYLE_LITERAL = 3, + STYLE_FOLDED = 4, + STYLE_DOUBLE = 5; + +// Determines which scalar styles are possible and returns the preferred style. +// lineWidth = -1 => no limit. +// Pre-conditions: str.length > 0. +// Post-conditions: +// STYLE_PLAIN or STYLE_SINGLE => no \n are in the string. +// STYLE_LITERAL => no lines are suitable for folding (or lineWidth is -1). +// STYLE_FOLDED => a line > lineWidth and can be folded (and lineWidth != -1). +function chooseScalarStyle(string, singleLineOnly, indentPerLevel, lineWidth, + testAmbiguousType, quotingType, forceQuotes, inblock) { + + var i; + var char = 0; + var prevChar = null; + var hasLineBreak = false; + var hasFoldableLine = false; // only checked if shouldTrackWidth + var shouldTrackWidth = lineWidth !== -1; + var previousLineBreak = -1; // count the first line correctly + var plain = isPlainSafeFirst(codePointAt(string, 0)) + && isPlainSafeLast(codePointAt(string, string.length - 1)); + + if (singleLineOnly || forceQuotes) { + // Case: no block styles. + // Check for disallowed characters to rule out plain and single. + for (i = 0; i < string.length; char >= 0x10000 ? i += 2 : i++) { + char = codePointAt(string, i); + if (!isPrintable(char)) { + return STYLE_DOUBLE; + } + plain = plain && isPlainSafe(char, prevChar, inblock); + prevChar = char; + } + } else { + // Case: block styles permitted. + for (i = 0; i < string.length; char >= 0x10000 ? i += 2 : i++) { + char = codePointAt(string, i); + if (char === CHAR_LINE_FEED) { + hasLineBreak = true; + // Check if any line can be folded. + if (shouldTrackWidth) { + hasFoldableLine = hasFoldableLine || + // Foldable line = too long, and not more-indented. + (i - previousLineBreak - 1 > lineWidth && + string[previousLineBreak + 1] !== ' '); + previousLineBreak = i; + } + } else if (!isPrintable(char)) { + return STYLE_DOUBLE; + } + plain = plain && isPlainSafe(char, prevChar, inblock); + prevChar = char; + } + // in case the end is missing a \n + hasFoldableLine = hasFoldableLine || (shouldTrackWidth && + (i - previousLineBreak - 1 > lineWidth && + string[previousLineBreak + 1] !== ' ')); + } + // Although every style can represent \n without escaping, prefer block styles + // for multiline, since they're more readable and they don't add empty lines. + // Also prefer folding a super-long line. + if (!hasLineBreak && !hasFoldableLine) { + // Strings interpretable as another type have to be quoted; + // e.g. the string 'true' vs. the boolean true. + if (plain && !forceQuotes && !testAmbiguousType(string)) { + return STYLE_PLAIN; + } + return quotingType === QUOTING_TYPE_DOUBLE ? STYLE_DOUBLE : STYLE_SINGLE; + } + // Edge case: block indentation indicator can only have one digit. + if (indentPerLevel > 9 && needIndentIndicator(string)) { + return STYLE_DOUBLE; + } + // At this point we know block styles are valid. + // Prefer literal style unless we want to fold. + if (!forceQuotes) { + return hasFoldableLine ? STYLE_FOLDED : STYLE_LITERAL; + } + return quotingType === QUOTING_TYPE_DOUBLE ? STYLE_DOUBLE : STYLE_SINGLE; +} + +// Note: line breaking/folding is implemented for only the folded style. +// NB. We drop the last trailing newline (if any) of a returned block scalar +// since the dumper adds its own newline. This always works: +// • No ending newline => unaffected; already using strip "-" chomping. +// • Ending newline => removed then restored. +// Importantly, this keeps the "+" chomp indicator from gaining an extra line. +function writeScalar(state, string, level, iskey, inblock) { + state.dump = (function () { + if (string.length === 0) { + return state.quotingType === QUOTING_TYPE_DOUBLE ? '""' : "''"; + } + if (!state.noCompatMode) { + if (DEPRECATED_BOOLEANS_SYNTAX.indexOf(string) !== -1 || DEPRECATED_BASE60_SYNTAX.test(string)) { + return state.quotingType === QUOTING_TYPE_DOUBLE ? ('"' + string + '"') : ("'" + string + "'"); + } + } + + var indent = state.indent * Math.max(1, level); // no 0-indent scalars + // As indentation gets deeper, let the width decrease monotonically + // to the lower bound min(state.lineWidth, 40). + // Note that this implies + // state.lineWidth ≤ 40 + state.indent: width is fixed at the lower bound. + // state.lineWidth > 40 + state.indent: width decreases until the lower bound. + // This behaves better than a constant minimum width which disallows narrower options, + // or an indent threshold which causes the width to suddenly increase. + var lineWidth = state.lineWidth === -1 + ? -1 : Math.max(Math.min(state.lineWidth, 40), state.lineWidth - indent); + + // Without knowing if keys are implicit/explicit, assume implicit for safety. + var singleLineOnly = iskey + // No block styles in flow mode. + || (state.flowLevel > -1 && level >= state.flowLevel); + function testAmbiguity(string) { + return testImplicitResolving(state, string); + } + + switch (chooseScalarStyle(string, singleLineOnly, state.indent, lineWidth, + testAmbiguity, state.quotingType, state.forceQuotes && !iskey, inblock)) { + + case STYLE_PLAIN: + return string; + case STYLE_SINGLE: + return "'" + string.replace(/'/g, "''") + "'"; + case STYLE_LITERAL: + return '|' + blockHeader(string, state.indent) + + dropEndingNewline(indentString(string, indent)); + case STYLE_FOLDED: + return '>' + blockHeader(string, state.indent) + + dropEndingNewline(indentString(foldString(string, lineWidth), indent)); + case STYLE_DOUBLE: + return '"' + escapeString(string, lineWidth) + '"'; + default: + throw new YAMLException('impossible error: invalid scalar style'); + } + }()); +} + +// Pre-conditions: string is valid for a block scalar, 1 <= indentPerLevel <= 9. +function blockHeader(string, indentPerLevel) { + var indentIndicator = needIndentIndicator(string) ? String(indentPerLevel) : ''; + + // note the special case: the string '\n' counts as a "trailing" empty line. + var clip = string[string.length - 1] === '\n'; + var keep = clip && (string[string.length - 2] === '\n' || string === '\n'); + var chomp = keep ? '+' : (clip ? '' : '-'); + + return indentIndicator + chomp + '\n'; +} + +// (See the note for writeScalar.) +function dropEndingNewline(string) { + return string[string.length - 1] === '\n' ? string.slice(0, -1) : string; +} + +// Note: a long line without a suitable break point will exceed the width limit. +// Pre-conditions: every char in str isPrintable, str.length > 0, width > 0. +function foldString(string, width) { + // In folded style, $k$ consecutive newlines output as $k+1$ newlines— + // unless they're before or after a more-indented line, or at the very + // beginning or end, in which case $k$ maps to $k$. + // Therefore, parse each chunk as newline(s) followed by a content line. + var lineRe = /(\n+)([^\n]*)/g; + + // first line (possibly an empty line) + var result = (function () { + var nextLF = string.indexOf('\n'); + nextLF = nextLF !== -1 ? nextLF : string.length; + lineRe.lastIndex = nextLF; + return foldLine(string.slice(0, nextLF), width); + }()); + // If we haven't reached the first content line yet, don't add an extra \n. + var prevMoreIndented = string[0] === '\n' || string[0] === ' '; + var moreIndented; + + // rest of the lines + var match; + while ((match = lineRe.exec(string))) { + var prefix = match[1], line = match[2]; + moreIndented = (line[0] === ' '); + result += prefix + + (!prevMoreIndented && !moreIndented && line !== '' + ? '\n' : '') + + foldLine(line, width); + prevMoreIndented = moreIndented; + } + + return result; +} + +// Greedy line breaking. +// Picks the longest line under the limit each time, +// otherwise settles for the shortest line over the limit. +// NB. More-indented lines *cannot* be folded, as that would add an extra \n. +function foldLine(line, width) { + if (line === '' || line[0] === ' ') return line; + + // Since a more-indented line adds a \n, breaks can't be followed by a space. + var breakRe = / [^ ]/g; // note: the match index will always be <= length-2. + var match; + // start is an inclusive index. end, curr, and next are exclusive. + var start = 0, end, curr = 0, next = 0; + var result = ''; + + // Invariants: 0 <= start <= length-1. + // 0 <= curr <= next <= max(0, length-2). curr - start <= width. + // Inside the loop: + // A match implies length >= 2, so curr and next are <= length-2. + while ((match = breakRe.exec(line))) { + next = match.index; + // maintain invariant: curr - start <= width + if (next - start > width) { + end = (curr > start) ? curr : next; // derive end <= length-2 + result += '\n' + line.slice(start, end); + // skip the space that was output as \n + start = end + 1; // derive start <= length-1 + } + curr = next; + } + + // By the invariants, start <= length-1, so there is something left over. + // It is either the whole string or a part starting from non-whitespace. + result += '\n'; + // Insert a break if the remainder is too long and there is a break available. + if (line.length - start > width && curr > start) { + result += line.slice(start, curr) + '\n' + line.slice(curr + 1); + } else { + result += line.slice(start); + } + + return result.slice(1); // drop extra \n joiner +} + +// Escapes a double-quoted string. +function escapeString(string) { + var result = ''; + var char = 0; + var escapeSeq; + + for (var i = 0; i < string.length; char >= 0x10000 ? i += 2 : i++) { + char = codePointAt(string, i); + escapeSeq = ESCAPE_SEQUENCES[char]; + + if (!escapeSeq && isPrintable(char)) { + result += string[i]; + if (char >= 0x10000) result += string[i + 1]; + } else { + result += escapeSeq || encodeHex(char); + } + } + + return result; +} + +function writeFlowSequence(state, level, object) { + var _result = '', + _tag = state.tag, + index, + length, + value; + + for (index = 0, length = object.length; index < length; index += 1) { + value = object[index]; + + if (state.replacer) { + value = state.replacer.call(object, String(index), value); + } + + // Write only valid elements, put null instead of invalid elements. + if (writeNode(state, level, value, false, false) || + (typeof value === 'undefined' && + writeNode(state, level, null, false, false))) { + + if (_result !== '') _result += ',' + (!state.condenseFlow ? ' ' : ''); + _result += state.dump; + } + } + + state.tag = _tag; + state.dump = '[' + _result + ']'; +} + +function writeBlockSequence(state, level, object, compact) { + var _result = '', + _tag = state.tag, + index, + length, + value; + + for (index = 0, length = object.length; index < length; index += 1) { + value = object[index]; + + if (state.replacer) { + value = state.replacer.call(object, String(index), value); + } + + // Write only valid elements, put null instead of invalid elements. + if (writeNode(state, level + 1, value, true, true, false, true) || + (typeof value === 'undefined' && + writeNode(state, level + 1, null, true, true, false, true))) { + + if (!compact || _result !== '') { + _result += generateNextLine(state, level); + } + + if (state.dump && CHAR_LINE_FEED === state.dump.charCodeAt(0)) { + _result += '-'; + } else { + _result += '- '; + } + + _result += state.dump; + } + } + + state.tag = _tag; + state.dump = _result || '[]'; // Empty sequence if no valid values. +} + +function writeFlowMapping(state, level, object) { + var _result = '', + _tag = state.tag, + objectKeyList = Object.keys(object), + index, + length, + objectKey, + objectValue, + pairBuffer; + + for (index = 0, length = objectKeyList.length; index < length; index += 1) { + + pairBuffer = ''; + if (_result !== '') pairBuffer += ', '; + + if (state.condenseFlow) pairBuffer += '"'; + + objectKey = objectKeyList[index]; + objectValue = object[objectKey]; + + if (state.replacer) { + objectValue = state.replacer.call(object, objectKey, objectValue); + } + + if (!writeNode(state, level, objectKey, false, false)) { + continue; // Skip this pair because of invalid key; + } + + if (state.dump.length > 1024) pairBuffer += '? '; + + pairBuffer += state.dump + (state.condenseFlow ? '"' : '') + ':' + (state.condenseFlow ? '' : ' '); + + if (!writeNode(state, level, objectValue, false, false)) { + continue; // Skip this pair because of invalid value. + } + + pairBuffer += state.dump; + + // Both key and value are valid. + _result += pairBuffer; + } + + state.tag = _tag; + state.dump = '{' + _result + '}'; +} + +function writeBlockMapping(state, level, object, compact) { + var _result = '', + _tag = state.tag, + objectKeyList = Object.keys(object), + index, + length, + objectKey, + objectValue, + explicitPair, + pairBuffer; + + // Allow sorting keys so that the output file is deterministic + if (state.sortKeys === true) { + // Default sorting + objectKeyList.sort(); + } else if (typeof state.sortKeys === 'function') { + // Custom sort function + objectKeyList.sort(state.sortKeys); + } else if (state.sortKeys) { + // Something is wrong + throw new YAMLException('sortKeys must be a boolean or a function'); + } + + for (index = 0, length = objectKeyList.length; index < length; index += 1) { + pairBuffer = ''; + + if (!compact || _result !== '') { + pairBuffer += generateNextLine(state, level); + } + + objectKey = objectKeyList[index]; + objectValue = object[objectKey]; + + if (state.replacer) { + objectValue = state.replacer.call(object, objectKey, objectValue); + } + + if (!writeNode(state, level + 1, objectKey, true, true, true)) { + continue; // Skip this pair because of invalid key. + } + + explicitPair = (state.tag !== null && state.tag !== '?') || + (state.dump && state.dump.length > 1024); + + if (explicitPair) { + if (state.dump && CHAR_LINE_FEED === state.dump.charCodeAt(0)) { + pairBuffer += '?'; + } else { + pairBuffer += '? '; + } + } + + pairBuffer += state.dump; + + if (explicitPair) { + pairBuffer += generateNextLine(state, level); + } + + if (!writeNode(state, level + 1, objectValue, true, explicitPair)) { + continue; // Skip this pair because of invalid value. + } + + if (state.dump && CHAR_LINE_FEED === state.dump.charCodeAt(0)) { + pairBuffer += ':'; + } else { + pairBuffer += ': '; + } + + pairBuffer += state.dump; + + // Both key and value are valid. + _result += pairBuffer; + } + + state.tag = _tag; + state.dump = _result || '{}'; // Empty mapping if no valid pairs. +} + +function detectType(state, object, explicit) { + var _result, typeList, index, length, type, style; + + typeList = explicit ? state.explicitTypes : state.implicitTypes; + + for (index = 0, length = typeList.length; index < length; index += 1) { + type = typeList[index]; + + if ((type.instanceOf || type.predicate) && + (!type.instanceOf || ((typeof object === 'object') && (object instanceof type.instanceOf))) && + (!type.predicate || type.predicate(object))) { + + if (explicit) { + if (type.multi && type.representName) { + state.tag = type.representName(object); + } else { + state.tag = type.tag; + } + } else { + state.tag = '?'; + } + + if (type.represent) { + style = state.styleMap[type.tag] || type.defaultStyle; + + if (_toString.call(type.represent) === '[object Function]') { + _result = type.represent(object, style); + } else if (_hasOwnProperty.call(type.represent, style)) { + _result = type.represent[style](object, style); + } else { + throw new YAMLException('!<' + type.tag + '> tag resolver accepts not "' + style + '" style'); + } + + state.dump = _result; + } + + return true; + } + } + + return false; +} + +// Serializes `object` and writes it to global `result`. +// Returns true on success, or false on invalid object. +// +function writeNode(state, level, object, block, compact, iskey, isblockseq) { + state.tag = null; + state.dump = object; + + if (!detectType(state, object, false)) { + detectType(state, object, true); + } + + var type = _toString.call(state.dump); + var inblock = block; + var tagStr; + + if (block) { + block = (state.flowLevel < 0 || state.flowLevel > level); + } + + var objectOrArray = type === '[object Object]' || type === '[object Array]', + duplicateIndex, + duplicate; + + if (objectOrArray) { + duplicateIndex = state.duplicates.indexOf(object); + duplicate = duplicateIndex !== -1; + } + + if ((state.tag !== null && state.tag !== '?') || duplicate || (state.indent !== 2 && level > 0)) { + compact = false; + } + + if (duplicate && state.usedDuplicates[duplicateIndex]) { + state.dump = '*ref_' + duplicateIndex; + } else { + if (objectOrArray && duplicate && !state.usedDuplicates[duplicateIndex]) { + state.usedDuplicates[duplicateIndex] = true; + } + if (type === '[object Object]') { + if (block && (Object.keys(state.dump).length !== 0)) { + writeBlockMapping(state, level, state.dump, compact); + if (duplicate) { + state.dump = '&ref_' + duplicateIndex + state.dump; + } + } else { + writeFlowMapping(state, level, state.dump); + if (duplicate) { + state.dump = '&ref_' + duplicateIndex + ' ' + state.dump; + } + } + } else if (type === '[object Array]') { + if (block && (state.dump.length !== 0)) { + if (state.noArrayIndent && !isblockseq && level > 0) { + writeBlockSequence(state, level - 1, state.dump, compact); + } else { + writeBlockSequence(state, level, state.dump, compact); + } + if (duplicate) { + state.dump = '&ref_' + duplicateIndex + state.dump; + } + } else { + writeFlowSequence(state, level, state.dump); + if (duplicate) { + state.dump = '&ref_' + duplicateIndex + ' ' + state.dump; + } + } + } else if (type === '[object String]') { + if (state.tag !== '?') { + writeScalar(state, state.dump, level, iskey, inblock); + } + } else if (type === '[object Undefined]') { + return false; + } else { + if (state.skipInvalid) return false; + throw new YAMLException('unacceptable kind of an object to dump ' + type); + } + + if (state.tag !== null && state.tag !== '?') { + // Need to encode all characters except those allowed by the spec: + // + // [35] ns-dec-digit ::= [#x30-#x39] /* 0-9 */ + // [36] ns-hex-digit ::= ns-dec-digit + // | [#x41-#x46] /* A-F */ | [#x61-#x66] /* a-f */ + // [37] ns-ascii-letter ::= [#x41-#x5A] /* A-Z */ | [#x61-#x7A] /* a-z */ + // [38] ns-word-char ::= ns-dec-digit | ns-ascii-letter | “-” + // [39] ns-uri-char ::= “%” ns-hex-digit ns-hex-digit | ns-word-char | “#” + // | “;” | “/” | “?” | “:” | “@” | “&” | “=” | “+” | “$” | “,” + // | “_” | “.” | “!” | “~” | “*” | “'” | “(” | “)” | “[” | “]” + // + // Also need to encode '!' because it has special meaning (end of tag prefix). + // + tagStr = encodeURI( + state.tag[0] === '!' ? state.tag.slice(1) : state.tag + ).replace(/!/g, '%21'); + + if (state.tag[0] === '!') { + tagStr = '!' + tagStr; + } else if (tagStr.slice(0, 18) === 'tag:yaml.org,2002:') { + tagStr = '!!' + tagStr.slice(18); + } else { + tagStr = '!<' + tagStr + '>'; + } + + state.dump = tagStr + ' ' + state.dump; + } + } + + return true; +} + +function getDuplicateReferences(object, state) { + var objects = [], + duplicatesIndexes = [], + index, + length; + + inspectNode(object, objects, duplicatesIndexes); + + for (index = 0, length = duplicatesIndexes.length; index < length; index += 1) { + state.duplicates.push(objects[duplicatesIndexes[index]]); + } + state.usedDuplicates = new Array(length); +} + +function inspectNode(object, objects, duplicatesIndexes) { + var objectKeyList, + index, + length; + + if (object !== null && typeof object === 'object') { + index = objects.indexOf(object); + if (index !== -1) { + if (duplicatesIndexes.indexOf(index) === -1) { + duplicatesIndexes.push(index); + } + } else { + objects.push(object); + + if (Array.isArray(object)) { + for (index = 0, length = object.length; index < length; index += 1) { + inspectNode(object[index], objects, duplicatesIndexes); + } + } else { + objectKeyList = Object.keys(object); + + for (index = 0, length = objectKeyList.length; index < length; index += 1) { + inspectNode(object[objectKeyList[index]], objects, duplicatesIndexes); + } + } + } + } +} + +function dump(input, options) { + options = options || {}; + + var state = new State(options); + + if (!state.noRefs) getDuplicateReferences(input, state); + + var value = input; + + if (state.replacer) { + value = state.replacer.call({ '': value }, '', value); + } + + if (writeNode(state, 0, value, true, true)) return state.dump + '\n'; + + return ''; +} + +module.exports.dump = dump; + + +/***/ }), + +/***/ 68179: +/***/ ((module) => { + +"use strict"; +// YAML error class. http://stackoverflow.com/questions/8458984 +// + + + +function formatError(exception, compact) { + var where = '', message = exception.reason || '(unknown reason)'; + + if (!exception.mark) return message; + + if (exception.mark.name) { + where += 'in "' + exception.mark.name + '" '; + } + + where += '(' + (exception.mark.line + 1) + ':' + (exception.mark.column + 1) + ')'; + + if (!compact && exception.mark.snippet) { + where += '\n\n' + exception.mark.snippet; + } + + return message + ' ' + where; +} + + +function YAMLException(reason, mark) { + // Super constructor + Error.call(this); + + this.name = 'YAMLException'; + this.reason = reason; + this.mark = mark; + this.message = formatError(this, false); + + // Include stack trace in error object + if (Error.captureStackTrace) { + // Chrome and NodeJS + Error.captureStackTrace(this, this.constructor); + } else { + // FF, IE 10+ and Safari 6+. Fallback for others + this.stack = (new Error()).stack || ''; + } +} + + +// Inherit from Error +YAMLException.prototype = Object.create(Error.prototype); +YAMLException.prototype.constructor = YAMLException; + + +YAMLException.prototype.toString = function toString(compact) { + return this.name + ': ' + formatError(this, compact); +}; + + +module.exports = YAMLException; + + +/***/ }), + +/***/ 51161: +/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { + +"use strict"; + + +/*eslint-disable max-len,no-use-before-define*/ + +var common = __nccwpck_require__(26829); +var YAMLException = __nccwpck_require__(68179); +var makeSnippet = __nccwpck_require__(96975); +var DEFAULT_SCHEMA = __nccwpck_require__(18759); + + +var _hasOwnProperty = Object.prototype.hasOwnProperty; + + +var CONTEXT_FLOW_IN = 1; +var CONTEXT_FLOW_OUT = 2; +var CONTEXT_BLOCK_IN = 3; +var CONTEXT_BLOCK_OUT = 4; + + +var CHOMPING_CLIP = 1; +var CHOMPING_STRIP = 2; +var CHOMPING_KEEP = 3; + + +var PATTERN_NON_PRINTABLE = /[\x00-\x08\x0B\x0C\x0E-\x1F\x7F-\x84\x86-\x9F\uFFFE\uFFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF]/; +var PATTERN_NON_ASCII_LINE_BREAKS = /[\x85\u2028\u2029]/; +var PATTERN_FLOW_INDICATORS = /[,\[\]\{\}]/; +var PATTERN_TAG_HANDLE = /^(?:!|!!|![a-z\-]+!)$/i; +var PATTERN_TAG_URI = /^(?:!|[^,\[\]\{\}])(?:%[0-9a-f]{2}|[0-9a-z\-#;\/\?:@&=\+\$,_\.!~\*'\(\)\[\]])*$/i; + + +function _class(obj) { return Object.prototype.toString.call(obj); } + +function is_EOL(c) { + return (c === 0x0A/* LF */) || (c === 0x0D/* CR */); +} + +function is_WHITE_SPACE(c) { + return (c === 0x09/* Tab */) || (c === 0x20/* Space */); +} + +function is_WS_OR_EOL(c) { + return (c === 0x09/* Tab */) || + (c === 0x20/* Space */) || + (c === 0x0A/* LF */) || + (c === 0x0D/* CR */); +} + +function is_FLOW_INDICATOR(c) { + return c === 0x2C/* , */ || + c === 0x5B/* [ */ || + c === 0x5D/* ] */ || + c === 0x7B/* { */ || + c === 0x7D/* } */; +} + +function fromHexCode(c) { + var lc; + + if ((0x30/* 0 */ <= c) && (c <= 0x39/* 9 */)) { + return c - 0x30; + } + + /*eslint-disable no-bitwise*/ + lc = c | 0x20; + + if ((0x61/* a */ <= lc) && (lc <= 0x66/* f */)) { + return lc - 0x61 + 10; + } + + return -1; +} + +function escapedHexLen(c) { + if (c === 0x78/* x */) { return 2; } + if (c === 0x75/* u */) { return 4; } + if (c === 0x55/* U */) { return 8; } + return 0; +} + +function fromDecimalCode(c) { + if ((0x30/* 0 */ <= c) && (c <= 0x39/* 9 */)) { + return c - 0x30; + } + + return -1; +} + +function simpleEscapeSequence(c) { + /* eslint-disable indent */ + return (c === 0x30/* 0 */) ? '\x00' : + (c === 0x61/* a */) ? '\x07' : + (c === 0x62/* b */) ? '\x08' : + (c === 0x74/* t */) ? '\x09' : + (c === 0x09/* Tab */) ? '\x09' : + (c === 0x6E/* n */) ? '\x0A' : + (c === 0x76/* v */) ? '\x0B' : + (c === 0x66/* f */) ? '\x0C' : + (c === 0x72/* r */) ? '\x0D' : + (c === 0x65/* e */) ? '\x1B' : + (c === 0x20/* Space */) ? ' ' : + (c === 0x22/* " */) ? '\x22' : + (c === 0x2F/* / */) ? '/' : + (c === 0x5C/* \ */) ? '\x5C' : + (c === 0x4E/* N */) ? '\x85' : + (c === 0x5F/* _ */) ? '\xA0' : + (c === 0x4C/* L */) ? '\u2028' : + (c === 0x50/* P */) ? '\u2029' : ''; +} + +function charFromCodepoint(c) { + if (c <= 0xFFFF) { + return String.fromCharCode(c); + } + // Encode UTF-16 surrogate pair + // https://en.wikipedia.org/wiki/UTF-16#Code_points_U.2B010000_to_U.2B10FFFF + return String.fromCharCode( + ((c - 0x010000) >> 10) + 0xD800, + ((c - 0x010000) & 0x03FF) + 0xDC00 + ); +} + +var simpleEscapeCheck = new Array(256); // integer, for fast access +var simpleEscapeMap = new Array(256); +for (var i = 0; i < 256; i++) { + simpleEscapeCheck[i] = simpleEscapeSequence(i) ? 1 : 0; + simpleEscapeMap[i] = simpleEscapeSequence(i); +} + + +function State(input, options) { + this.input = input; + + this.filename = options['filename'] || null; + this.schema = options['schema'] || DEFAULT_SCHEMA; + this.onWarning = options['onWarning'] || null; + // (Hidden) Remove? makes the loader to expect YAML 1.1 documents + // if such documents have no explicit %YAML directive + this.legacy = options['legacy'] || false; + + this.json = options['json'] || false; + this.listener = options['listener'] || null; + + this.implicitTypes = this.schema.compiledImplicit; + this.typeMap = this.schema.compiledTypeMap; + + this.length = input.length; + this.position = 0; + this.line = 0; + this.lineStart = 0; + this.lineIndent = 0; + + // position of first leading tab in the current line, + // used to make sure there are no tabs in the indentation + this.firstTabInLine = -1; + + this.documents = []; + + /* + this.version; + this.checkLineBreaks; + this.tagMap; + this.anchorMap; + this.tag; + this.anchor; + this.kind; + this.result;*/ + +} + + +function generateError(state, message) { + var mark = { + name: state.filename, + buffer: state.input.slice(0, -1), // omit trailing \0 + position: state.position, + line: state.line, + column: state.position - state.lineStart + }; + + mark.snippet = makeSnippet(mark); + + return new YAMLException(message, mark); +} + +function throwError(state, message) { + throw generateError(state, message); +} + +function throwWarning(state, message) { + if (state.onWarning) { + state.onWarning.call(null, generateError(state, message)); + } +} + + +var directiveHandlers = { + + YAML: function handleYamlDirective(state, name, args) { + + var match, major, minor; + + if (state.version !== null) { + throwError(state, 'duplication of %YAML directive'); + } + + if (args.length !== 1) { + throwError(state, 'YAML directive accepts exactly one argument'); + } + + match = /^([0-9]+)\.([0-9]+)$/.exec(args[0]); + + if (match === null) { + throwError(state, 'ill-formed argument of the YAML directive'); + } + + major = parseInt(match[1], 10); + minor = parseInt(match[2], 10); + + if (major !== 1) { + throwError(state, 'unacceptable YAML version of the document'); + } + + state.version = args[0]; + state.checkLineBreaks = (minor < 2); + + if (minor !== 1 && minor !== 2) { + throwWarning(state, 'unsupported YAML version of the document'); + } + }, + + TAG: function handleTagDirective(state, name, args) { + + var handle, prefix; + + if (args.length !== 2) { + throwError(state, 'TAG directive accepts exactly two arguments'); + } + + handle = args[0]; + prefix = args[1]; + + if (!PATTERN_TAG_HANDLE.test(handle)) { + throwError(state, 'ill-formed tag handle (first argument) of the TAG directive'); + } + + if (_hasOwnProperty.call(state.tagMap, handle)) { + throwError(state, 'there is a previously declared suffix for "' + handle + '" tag handle'); + } + + if (!PATTERN_TAG_URI.test(prefix)) { + throwError(state, 'ill-formed tag prefix (second argument) of the TAG directive'); + } + + try { + prefix = decodeURIComponent(prefix); + } catch (err) { + throwError(state, 'tag prefix is malformed: ' + prefix); + } + + state.tagMap[handle] = prefix; + } +}; + + +function captureSegment(state, start, end, checkJson) { + var _position, _length, _character, _result; + + if (start < end) { + _result = state.input.slice(start, end); + + if (checkJson) { + for (_position = 0, _length = _result.length; _position < _length; _position += 1) { + _character = _result.charCodeAt(_position); + if (!(_character === 0x09 || + (0x20 <= _character && _character <= 0x10FFFF))) { + throwError(state, 'expected valid JSON character'); + } + } + } else if (PATTERN_NON_PRINTABLE.test(_result)) { + throwError(state, 'the stream contains non-printable characters'); + } + + state.result += _result; + } +} + +function mergeMappings(state, destination, source, overridableKeys) { + var sourceKeys, key, index, quantity; + + if (!common.isObject(source)) { + throwError(state, 'cannot merge mappings; the provided source object is unacceptable'); + } + + sourceKeys = Object.keys(source); + + for (index = 0, quantity = sourceKeys.length; index < quantity; index += 1) { + key = sourceKeys[index]; + + if (!_hasOwnProperty.call(destination, key)) { + destination[key] = source[key]; + overridableKeys[key] = true; + } + } +} + +function storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, valueNode, + startLine, startLineStart, startPos) { + + var index, quantity; + + // The output is a plain object here, so keys can only be strings. + // We need to convert keyNode to a string, but doing so can hang the process + // (deeply nested arrays that explode exponentially using aliases). + if (Array.isArray(keyNode)) { + keyNode = Array.prototype.slice.call(keyNode); + + for (index = 0, quantity = keyNode.length; index < quantity; index += 1) { + if (Array.isArray(keyNode[index])) { + throwError(state, 'nested arrays are not supported inside keys'); + } + + if (typeof keyNode === 'object' && _class(keyNode[index]) === '[object Object]') { + keyNode[index] = '[object Object]'; + } + } + } + + // Avoid code execution in load() via toString property + // (still use its own toString for arrays, timestamps, + // and whatever user schema extensions happen to have @@toStringTag) + if (typeof keyNode === 'object' && _class(keyNode) === '[object Object]') { + keyNode = '[object Object]'; + } + + + keyNode = String(keyNode); + + if (_result === null) { + _result = {}; + } + + if (keyTag === 'tag:yaml.org,2002:merge') { + if (Array.isArray(valueNode)) { + for (index = 0, quantity = valueNode.length; index < quantity; index += 1) { + mergeMappings(state, _result, valueNode[index], overridableKeys); + } + } else { + mergeMappings(state, _result, valueNode, overridableKeys); + } + } else { + if (!state.json && + !_hasOwnProperty.call(overridableKeys, keyNode) && + _hasOwnProperty.call(_result, keyNode)) { + state.line = startLine || state.line; + state.lineStart = startLineStart || state.lineStart; + state.position = startPos || state.position; + throwError(state, 'duplicated mapping key'); + } + + // used for this specific key only because Object.defineProperty is slow + if (keyNode === '__proto__') { + Object.defineProperty(_result, keyNode, { + configurable: true, + enumerable: true, + writable: true, + value: valueNode + }); + } else { + _result[keyNode] = valueNode; + } + delete overridableKeys[keyNode]; + } + + return _result; +} + +function readLineBreak(state) { + var ch; + + ch = state.input.charCodeAt(state.position); + + if (ch === 0x0A/* LF */) { + state.position++; + } else if (ch === 0x0D/* CR */) { + state.position++; + if (state.input.charCodeAt(state.position) === 0x0A/* LF */) { + state.position++; + } + } else { + throwError(state, 'a line break is expected'); + } + + state.line += 1; + state.lineStart = state.position; + state.firstTabInLine = -1; +} + +function skipSeparationSpace(state, allowComments, checkIndent) { + var lineBreaks = 0, + ch = state.input.charCodeAt(state.position); + + while (ch !== 0) { + while (is_WHITE_SPACE(ch)) { + if (ch === 0x09/* Tab */ && state.firstTabInLine === -1) { + state.firstTabInLine = state.position; + } + ch = state.input.charCodeAt(++state.position); + } + + if (allowComments && ch === 0x23/* # */) { + do { + ch = state.input.charCodeAt(++state.position); + } while (ch !== 0x0A/* LF */ && ch !== 0x0D/* CR */ && ch !== 0); + } + + if (is_EOL(ch)) { + readLineBreak(state); + + ch = state.input.charCodeAt(state.position); + lineBreaks++; + state.lineIndent = 0; + + while (ch === 0x20/* Space */) { + state.lineIndent++; + ch = state.input.charCodeAt(++state.position); + } + } else { + break; + } + } + + if (checkIndent !== -1 && lineBreaks !== 0 && state.lineIndent < checkIndent) { + throwWarning(state, 'deficient indentation'); + } + + return lineBreaks; +} + +function testDocumentSeparator(state) { + var _position = state.position, + ch; + + ch = state.input.charCodeAt(_position); + + // Condition state.position === state.lineStart is tested + // in parent on each call, for efficiency. No needs to test here again. + if ((ch === 0x2D/* - */ || ch === 0x2E/* . */) && + ch === state.input.charCodeAt(_position + 1) && + ch === state.input.charCodeAt(_position + 2)) { + + _position += 3; + + ch = state.input.charCodeAt(_position); + + if (ch === 0 || is_WS_OR_EOL(ch)) { + return true; + } + } + + return false; +} + +function writeFoldedLines(state, count) { + if (count === 1) { + state.result += ' '; + } else if (count > 1) { + state.result += common.repeat('\n', count - 1); + } +} + + +function readPlainScalar(state, nodeIndent, withinFlowCollection) { + var preceding, + following, + captureStart, + captureEnd, + hasPendingContent, + _line, + _lineStart, + _lineIndent, + _kind = state.kind, + _result = state.result, + ch; + + ch = state.input.charCodeAt(state.position); + + if (is_WS_OR_EOL(ch) || + is_FLOW_INDICATOR(ch) || + ch === 0x23/* # */ || + ch === 0x26/* & */ || + ch === 0x2A/* * */ || + ch === 0x21/* ! */ || + ch === 0x7C/* | */ || + ch === 0x3E/* > */ || + ch === 0x27/* ' */ || + ch === 0x22/* " */ || + ch === 0x25/* % */ || + ch === 0x40/* @ */ || + ch === 0x60/* ` */) { + return false; + } + + if (ch === 0x3F/* ? */ || ch === 0x2D/* - */) { + following = state.input.charCodeAt(state.position + 1); + + if (is_WS_OR_EOL(following) || + withinFlowCollection && is_FLOW_INDICATOR(following)) { + return false; + } + } + + state.kind = 'scalar'; + state.result = ''; + captureStart = captureEnd = state.position; + hasPendingContent = false; + + while (ch !== 0) { + if (ch === 0x3A/* : */) { + following = state.input.charCodeAt(state.position + 1); + + if (is_WS_OR_EOL(following) || + withinFlowCollection && is_FLOW_INDICATOR(following)) { + break; + } + + } else if (ch === 0x23/* # */) { + preceding = state.input.charCodeAt(state.position - 1); + + if (is_WS_OR_EOL(preceding)) { + break; + } + + } else if ((state.position === state.lineStart && testDocumentSeparator(state)) || + withinFlowCollection && is_FLOW_INDICATOR(ch)) { + break; + + } else if (is_EOL(ch)) { + _line = state.line; + _lineStart = state.lineStart; + _lineIndent = state.lineIndent; + skipSeparationSpace(state, false, -1); + + if (state.lineIndent >= nodeIndent) { + hasPendingContent = true; + ch = state.input.charCodeAt(state.position); + continue; + } else { + state.position = captureEnd; + state.line = _line; + state.lineStart = _lineStart; + state.lineIndent = _lineIndent; + break; + } + } + + if (hasPendingContent) { + captureSegment(state, captureStart, captureEnd, false); + writeFoldedLines(state, state.line - _line); + captureStart = captureEnd = state.position; + hasPendingContent = false; + } + + if (!is_WHITE_SPACE(ch)) { + captureEnd = state.position + 1; + } + + ch = state.input.charCodeAt(++state.position); + } + + captureSegment(state, captureStart, captureEnd, false); + + if (state.result) { + return true; + } + + state.kind = _kind; + state.result = _result; + return false; +} + +function readSingleQuotedScalar(state, nodeIndent) { + var ch, + captureStart, captureEnd; + + ch = state.input.charCodeAt(state.position); + + if (ch !== 0x27/* ' */) { + return false; + } + + state.kind = 'scalar'; + state.result = ''; + state.position++; + captureStart = captureEnd = state.position; + + while ((ch = state.input.charCodeAt(state.position)) !== 0) { + if (ch === 0x27/* ' */) { + captureSegment(state, captureStart, state.position, true); + ch = state.input.charCodeAt(++state.position); + + if (ch === 0x27/* ' */) { + captureStart = state.position; + state.position++; + captureEnd = state.position; + } else { + return true; + } + + } else if (is_EOL(ch)) { + captureSegment(state, captureStart, captureEnd, true); + writeFoldedLines(state, skipSeparationSpace(state, false, nodeIndent)); + captureStart = captureEnd = state.position; + + } else if (state.position === state.lineStart && testDocumentSeparator(state)) { + throwError(state, 'unexpected end of the document within a single quoted scalar'); + + } else { + state.position++; + captureEnd = state.position; + } + } + + throwError(state, 'unexpected end of the stream within a single quoted scalar'); +} + +function readDoubleQuotedScalar(state, nodeIndent) { + var captureStart, + captureEnd, + hexLength, + hexResult, + tmp, + ch; + + ch = state.input.charCodeAt(state.position); + + if (ch !== 0x22/* " */) { + return false; + } + + state.kind = 'scalar'; + state.result = ''; + state.position++; + captureStart = captureEnd = state.position; + + while ((ch = state.input.charCodeAt(state.position)) !== 0) { + if (ch === 0x22/* " */) { + captureSegment(state, captureStart, state.position, true); + state.position++; + return true; + + } else if (ch === 0x5C/* \ */) { + captureSegment(state, captureStart, state.position, true); + ch = state.input.charCodeAt(++state.position); + + if (is_EOL(ch)) { + skipSeparationSpace(state, false, nodeIndent); + + // TODO: rework to inline fn with no type cast? + } else if (ch < 256 && simpleEscapeCheck[ch]) { + state.result += simpleEscapeMap[ch]; + state.position++; + + } else if ((tmp = escapedHexLen(ch)) > 0) { + hexLength = tmp; + hexResult = 0; + + for (; hexLength > 0; hexLength--) { + ch = state.input.charCodeAt(++state.position); + + if ((tmp = fromHexCode(ch)) >= 0) { + hexResult = (hexResult << 4) + tmp; + + } else { + throwError(state, 'expected hexadecimal character'); + } + } + + state.result += charFromCodepoint(hexResult); + + state.position++; + + } else { + throwError(state, 'unknown escape sequence'); + } + + captureStart = captureEnd = state.position; + + } else if (is_EOL(ch)) { + captureSegment(state, captureStart, captureEnd, true); + writeFoldedLines(state, skipSeparationSpace(state, false, nodeIndent)); + captureStart = captureEnd = state.position; + + } else if (state.position === state.lineStart && testDocumentSeparator(state)) { + throwError(state, 'unexpected end of the document within a double quoted scalar'); + + } else { + state.position++; + captureEnd = state.position; + } + } + + throwError(state, 'unexpected end of the stream within a double quoted scalar'); +} + +function readFlowCollection(state, nodeIndent) { + var readNext = true, + _line, + _lineStart, + _pos, + _tag = state.tag, + _result, + _anchor = state.anchor, + following, + terminator, + isPair, + isExplicitPair, + isMapping, + overridableKeys = Object.create(null), + keyNode, + keyTag, + valueNode, + ch; + + ch = state.input.charCodeAt(state.position); + + if (ch === 0x5B/* [ */) { + terminator = 0x5D;/* ] */ + isMapping = false; + _result = []; + } else if (ch === 0x7B/* { */) { + terminator = 0x7D;/* } */ + isMapping = true; + _result = {}; + } else { + return false; + } + + if (state.anchor !== null) { + state.anchorMap[state.anchor] = _result; + } + + ch = state.input.charCodeAt(++state.position); + + while (ch !== 0) { + skipSeparationSpace(state, true, nodeIndent); + + ch = state.input.charCodeAt(state.position); + + if (ch === terminator) { + state.position++; + state.tag = _tag; + state.anchor = _anchor; + state.kind = isMapping ? 'mapping' : 'sequence'; + state.result = _result; + return true; + } else if (!readNext) { + throwError(state, 'missed comma between flow collection entries'); + } else if (ch === 0x2C/* , */) { + // "flow collection entries can never be completely empty", as per YAML 1.2, section 7.4 + throwError(state, "expected the node content, but found ','"); + } + + keyTag = keyNode = valueNode = null; + isPair = isExplicitPair = false; + + if (ch === 0x3F/* ? */) { + following = state.input.charCodeAt(state.position + 1); + + if (is_WS_OR_EOL(following)) { + isPair = isExplicitPair = true; + state.position++; + skipSeparationSpace(state, true, nodeIndent); + } + } + + _line = state.line; // Save the current line. + _lineStart = state.lineStart; + _pos = state.position; + composeNode(state, nodeIndent, CONTEXT_FLOW_IN, false, true); + keyTag = state.tag; + keyNode = state.result; + skipSeparationSpace(state, true, nodeIndent); + + ch = state.input.charCodeAt(state.position); + + if ((isExplicitPair || state.line === _line) && ch === 0x3A/* : */) { + isPair = true; + ch = state.input.charCodeAt(++state.position); + skipSeparationSpace(state, true, nodeIndent); + composeNode(state, nodeIndent, CONTEXT_FLOW_IN, false, true); + valueNode = state.result; + } + + if (isMapping) { + storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, valueNode, _line, _lineStart, _pos); + } else if (isPair) { + _result.push(storeMappingPair(state, null, overridableKeys, keyTag, keyNode, valueNode, _line, _lineStart, _pos)); + } else { + _result.push(keyNode); + } + + skipSeparationSpace(state, true, nodeIndent); + + ch = state.input.charCodeAt(state.position); + + if (ch === 0x2C/* , */) { + readNext = true; + ch = state.input.charCodeAt(++state.position); + } else { + readNext = false; + } + } + + throwError(state, 'unexpected end of the stream within a flow collection'); +} + +function readBlockScalar(state, nodeIndent) { + var captureStart, + folding, + chomping = CHOMPING_CLIP, + didReadContent = false, + detectedIndent = false, + textIndent = nodeIndent, + emptyLines = 0, + atMoreIndented = false, + tmp, + ch; + + ch = state.input.charCodeAt(state.position); + + if (ch === 0x7C/* | */) { + folding = false; + } else if (ch === 0x3E/* > */) { + folding = true; + } else { + return false; + } + + state.kind = 'scalar'; + state.result = ''; + + while (ch !== 0) { + ch = state.input.charCodeAt(++state.position); + + if (ch === 0x2B/* + */ || ch === 0x2D/* - */) { + if (CHOMPING_CLIP === chomping) { + chomping = (ch === 0x2B/* + */) ? CHOMPING_KEEP : CHOMPING_STRIP; + } else { + throwError(state, 'repeat of a chomping mode identifier'); + } + + } else if ((tmp = fromDecimalCode(ch)) >= 0) { + if (tmp === 0) { + throwError(state, 'bad explicit indentation width of a block scalar; it cannot be less than one'); + } else if (!detectedIndent) { + textIndent = nodeIndent + tmp - 1; + detectedIndent = true; + } else { + throwError(state, 'repeat of an indentation width identifier'); + } + + } else { + break; + } + } + + if (is_WHITE_SPACE(ch)) { + do { ch = state.input.charCodeAt(++state.position); } + while (is_WHITE_SPACE(ch)); + + if (ch === 0x23/* # */) { + do { ch = state.input.charCodeAt(++state.position); } + while (!is_EOL(ch) && (ch !== 0)); + } + } + + while (ch !== 0) { + readLineBreak(state); + state.lineIndent = 0; + + ch = state.input.charCodeAt(state.position); + + while ((!detectedIndent || state.lineIndent < textIndent) && + (ch === 0x20/* Space */)) { + state.lineIndent++; + ch = state.input.charCodeAt(++state.position); + } + + if (!detectedIndent && state.lineIndent > textIndent) { + textIndent = state.lineIndent; + } + + if (is_EOL(ch)) { + emptyLines++; + continue; + } + + // End of the scalar. + if (state.lineIndent < textIndent) { + + // Perform the chomping. + if (chomping === CHOMPING_KEEP) { + state.result += common.repeat('\n', didReadContent ? 1 + emptyLines : emptyLines); + } else if (chomping === CHOMPING_CLIP) { + if (didReadContent) { // i.e. only if the scalar is not empty. + state.result += '\n'; + } + } + + // Break this `while` cycle and go to the funciton's epilogue. + break; + } + + // Folded style: use fancy rules to handle line breaks. + if (folding) { + + // Lines starting with white space characters (more-indented lines) are not folded. + if (is_WHITE_SPACE(ch)) { + atMoreIndented = true; + // except for the first content line (cf. Example 8.1) + state.result += common.repeat('\n', didReadContent ? 1 + emptyLines : emptyLines); + + // End of more-indented block. + } else if (atMoreIndented) { + atMoreIndented = false; + state.result += common.repeat('\n', emptyLines + 1); + + // Just one line break - perceive as the same line. + } else if (emptyLines === 0) { + if (didReadContent) { // i.e. only if we have already read some scalar content. + state.result += ' '; + } + + // Several line breaks - perceive as different lines. + } else { + state.result += common.repeat('\n', emptyLines); + } + + // Literal style: just add exact number of line breaks between content lines. + } else { + // Keep all line breaks except the header line break. + state.result += common.repeat('\n', didReadContent ? 1 + emptyLines : emptyLines); + } + + didReadContent = true; + detectedIndent = true; + emptyLines = 0; + captureStart = state.position; + + while (!is_EOL(ch) && (ch !== 0)) { + ch = state.input.charCodeAt(++state.position); + } + + captureSegment(state, captureStart, state.position, false); + } + + return true; +} + +function readBlockSequence(state, nodeIndent) { + var _line, + _tag = state.tag, + _anchor = state.anchor, + _result = [], + following, + detected = false, + ch; + + // there is a leading tab before this token, so it can't be a block sequence/mapping; + // it can still be flow sequence/mapping or a scalar + if (state.firstTabInLine !== -1) return false; + + if (state.anchor !== null) { + state.anchorMap[state.anchor] = _result; + } + + ch = state.input.charCodeAt(state.position); + + while (ch !== 0) { + if (state.firstTabInLine !== -1) { + state.position = state.firstTabInLine; + throwError(state, 'tab characters must not be used in indentation'); + } + + if (ch !== 0x2D/* - */) { + break; + } + + following = state.input.charCodeAt(state.position + 1); + + if (!is_WS_OR_EOL(following)) { + break; + } + + detected = true; + state.position++; + + if (skipSeparationSpace(state, true, -1)) { + if (state.lineIndent <= nodeIndent) { + _result.push(null); + ch = state.input.charCodeAt(state.position); + continue; + } + } + + _line = state.line; + composeNode(state, nodeIndent, CONTEXT_BLOCK_IN, false, true); + _result.push(state.result); + skipSeparationSpace(state, true, -1); + + ch = state.input.charCodeAt(state.position); + + if ((state.line === _line || state.lineIndent > nodeIndent) && (ch !== 0)) { + throwError(state, 'bad indentation of a sequence entry'); + } else if (state.lineIndent < nodeIndent) { + break; + } + } + + if (detected) { + state.tag = _tag; + state.anchor = _anchor; + state.kind = 'sequence'; + state.result = _result; + return true; + } + return false; +} + +function readBlockMapping(state, nodeIndent, flowIndent) { + var following, + allowCompact, + _line, + _keyLine, + _keyLineStart, + _keyPos, + _tag = state.tag, + _anchor = state.anchor, + _result = {}, + overridableKeys = Object.create(null), + keyTag = null, + keyNode = null, + valueNode = null, + atExplicitKey = false, + detected = false, + ch; + + // there is a leading tab before this token, so it can't be a block sequence/mapping; + // it can still be flow sequence/mapping or a scalar + if (state.firstTabInLine !== -1) return false; + + if (state.anchor !== null) { + state.anchorMap[state.anchor] = _result; + } + + ch = state.input.charCodeAt(state.position); + + while (ch !== 0) { + if (!atExplicitKey && state.firstTabInLine !== -1) { + state.position = state.firstTabInLine; + throwError(state, 'tab characters must not be used in indentation'); + } + + following = state.input.charCodeAt(state.position + 1); + _line = state.line; // Save the current line. + + // + // Explicit notation case. There are two separate blocks: + // first for the key (denoted by "?") and second for the value (denoted by ":") + // + if ((ch === 0x3F/* ? */ || ch === 0x3A/* : */) && is_WS_OR_EOL(following)) { + + if (ch === 0x3F/* ? */) { + if (atExplicitKey) { + storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, null, _keyLine, _keyLineStart, _keyPos); + keyTag = keyNode = valueNode = null; + } + + detected = true; + atExplicitKey = true; + allowCompact = true; + + } else if (atExplicitKey) { + // i.e. 0x3A/* : */ === character after the explicit key. + atExplicitKey = false; + allowCompact = true; + + } else { + throwError(state, 'incomplete explicit mapping pair; a key node is missed; or followed by a non-tabulated empty line'); + } + + state.position += 1; + ch = following; + + // + // Implicit notation case. Flow-style node as the key first, then ":", and the value. + // + } else { + _keyLine = state.line; + _keyLineStart = state.lineStart; + _keyPos = state.position; + + if (!composeNode(state, flowIndent, CONTEXT_FLOW_OUT, false, true)) { + // Neither implicit nor explicit notation. + // Reading is done. Go to the epilogue. + break; + } + + if (state.line === _line) { + ch = state.input.charCodeAt(state.position); + + while (is_WHITE_SPACE(ch)) { + ch = state.input.charCodeAt(++state.position); + } + + if (ch === 0x3A/* : */) { + ch = state.input.charCodeAt(++state.position); + + if (!is_WS_OR_EOL(ch)) { + throwError(state, 'a whitespace character is expected after the key-value separator within a block mapping'); + } + + if (atExplicitKey) { + storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, null, _keyLine, _keyLineStart, _keyPos); + keyTag = keyNode = valueNode = null; + } + + detected = true; + atExplicitKey = false; + allowCompact = false; + keyTag = state.tag; + keyNode = state.result; + + } else if (detected) { + throwError(state, 'can not read an implicit mapping pair; a colon is missed'); + + } else { + state.tag = _tag; + state.anchor = _anchor; + return true; // Keep the result of `composeNode`. + } + + } else if (detected) { + throwError(state, 'can not read a block mapping entry; a multiline key may not be an implicit key'); + + } else { + state.tag = _tag; + state.anchor = _anchor; + return true; // Keep the result of `composeNode`. + } + } + + // + // Common reading code for both explicit and implicit notations. + // + if (state.line === _line || state.lineIndent > nodeIndent) { + if (atExplicitKey) { + _keyLine = state.line; + _keyLineStart = state.lineStart; + _keyPos = state.position; + } + + if (composeNode(state, nodeIndent, CONTEXT_BLOCK_OUT, true, allowCompact)) { + if (atExplicitKey) { + keyNode = state.result; + } else { + valueNode = state.result; + } + } + + if (!atExplicitKey) { + storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, valueNode, _keyLine, _keyLineStart, _keyPos); + keyTag = keyNode = valueNode = null; + } + + skipSeparationSpace(state, true, -1); + ch = state.input.charCodeAt(state.position); + } + + if ((state.line === _line || state.lineIndent > nodeIndent) && (ch !== 0)) { + throwError(state, 'bad indentation of a mapping entry'); + } else if (state.lineIndent < nodeIndent) { + break; + } + } + + // + // Epilogue. + // + + // Special case: last mapping's node contains only the key in explicit notation. + if (atExplicitKey) { + storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, null, _keyLine, _keyLineStart, _keyPos); + } + + // Expose the resulting mapping. + if (detected) { + state.tag = _tag; + state.anchor = _anchor; + state.kind = 'mapping'; + state.result = _result; + } + + return detected; +} + +function readTagProperty(state) { + var _position, + isVerbatim = false, + isNamed = false, + tagHandle, + tagName, + ch; + + ch = state.input.charCodeAt(state.position); + + if (ch !== 0x21/* ! */) return false; + + if (state.tag !== null) { + throwError(state, 'duplication of a tag property'); + } + + ch = state.input.charCodeAt(++state.position); + + if (ch === 0x3C/* < */) { + isVerbatim = true; + ch = state.input.charCodeAt(++state.position); + + } else if (ch === 0x21/* ! */) { + isNamed = true; + tagHandle = '!!'; + ch = state.input.charCodeAt(++state.position); + + } else { + tagHandle = '!'; + } + + _position = state.position; + + if (isVerbatim) { + do { ch = state.input.charCodeAt(++state.position); } + while (ch !== 0 && ch !== 0x3E/* > */); + + if (state.position < state.length) { + tagName = state.input.slice(_position, state.position); + ch = state.input.charCodeAt(++state.position); + } else { + throwError(state, 'unexpected end of the stream within a verbatim tag'); + } + } else { + while (ch !== 0 && !is_WS_OR_EOL(ch)) { + + if (ch === 0x21/* ! */) { + if (!isNamed) { + tagHandle = state.input.slice(_position - 1, state.position + 1); + + if (!PATTERN_TAG_HANDLE.test(tagHandle)) { + throwError(state, 'named tag handle cannot contain such characters'); + } + + isNamed = true; + _position = state.position + 1; + } else { + throwError(state, 'tag suffix cannot contain exclamation marks'); + } + } + + ch = state.input.charCodeAt(++state.position); + } + + tagName = state.input.slice(_position, state.position); + + if (PATTERN_FLOW_INDICATORS.test(tagName)) { + throwError(state, 'tag suffix cannot contain flow indicator characters'); + } + } + + if (tagName && !PATTERN_TAG_URI.test(tagName)) { + throwError(state, 'tag name cannot contain such characters: ' + tagName); + } + + try { + tagName = decodeURIComponent(tagName); + } catch (err) { + throwError(state, 'tag name is malformed: ' + tagName); + } + + if (isVerbatim) { + state.tag = tagName; + + } else if (_hasOwnProperty.call(state.tagMap, tagHandle)) { + state.tag = state.tagMap[tagHandle] + tagName; + + } else if (tagHandle === '!') { + state.tag = '!' + tagName; + + } else if (tagHandle === '!!') { + state.tag = 'tag:yaml.org,2002:' + tagName; + + } else { + throwError(state, 'undeclared tag handle "' + tagHandle + '"'); + } + + return true; +} + +function readAnchorProperty(state) { + var _position, + ch; + + ch = state.input.charCodeAt(state.position); + + if (ch !== 0x26/* & */) return false; + + if (state.anchor !== null) { + throwError(state, 'duplication of an anchor property'); + } + + ch = state.input.charCodeAt(++state.position); + _position = state.position; + + while (ch !== 0 && !is_WS_OR_EOL(ch) && !is_FLOW_INDICATOR(ch)) { + ch = state.input.charCodeAt(++state.position); + } + + if (state.position === _position) { + throwError(state, 'name of an anchor node must contain at least one character'); + } + + state.anchor = state.input.slice(_position, state.position); + return true; +} + +function readAlias(state) { + var _position, alias, + ch; + + ch = state.input.charCodeAt(state.position); + + if (ch !== 0x2A/* * */) return false; + + ch = state.input.charCodeAt(++state.position); + _position = state.position; + + while (ch !== 0 && !is_WS_OR_EOL(ch) && !is_FLOW_INDICATOR(ch)) { + ch = state.input.charCodeAt(++state.position); + } + + if (state.position === _position) { + throwError(state, 'name of an alias node must contain at least one character'); + } + + alias = state.input.slice(_position, state.position); + + if (!_hasOwnProperty.call(state.anchorMap, alias)) { + throwError(state, 'unidentified alias "' + alias + '"'); + } + + state.result = state.anchorMap[alias]; + skipSeparationSpace(state, true, -1); + return true; +} + +function composeNode(state, parentIndent, nodeContext, allowToSeek, allowCompact) { + var allowBlockStyles, + allowBlockScalars, + allowBlockCollections, + indentStatus = 1, // 1: this>parent, 0: this=parent, -1: this parentIndent) { + indentStatus = 1; + } else if (state.lineIndent === parentIndent) { + indentStatus = 0; + } else if (state.lineIndent < parentIndent) { + indentStatus = -1; + } + } + } + + if (indentStatus === 1) { + while (readTagProperty(state) || readAnchorProperty(state)) { + if (skipSeparationSpace(state, true, -1)) { + atNewLine = true; + allowBlockCollections = allowBlockStyles; + + if (state.lineIndent > parentIndent) { + indentStatus = 1; + } else if (state.lineIndent === parentIndent) { + indentStatus = 0; + } else if (state.lineIndent < parentIndent) { + indentStatus = -1; + } + } else { + allowBlockCollections = false; + } + } + } + + if (allowBlockCollections) { + allowBlockCollections = atNewLine || allowCompact; + } + + if (indentStatus === 1 || CONTEXT_BLOCK_OUT === nodeContext) { + if (CONTEXT_FLOW_IN === nodeContext || CONTEXT_FLOW_OUT === nodeContext) { + flowIndent = parentIndent; + } else { + flowIndent = parentIndent + 1; + } + + blockIndent = state.position - state.lineStart; + + if (indentStatus === 1) { + if (allowBlockCollections && + (readBlockSequence(state, blockIndent) || + readBlockMapping(state, blockIndent, flowIndent)) || + readFlowCollection(state, flowIndent)) { + hasContent = true; + } else { + if ((allowBlockScalars && readBlockScalar(state, flowIndent)) || + readSingleQuotedScalar(state, flowIndent) || + readDoubleQuotedScalar(state, flowIndent)) { + hasContent = true; + + } else if (readAlias(state)) { + hasContent = true; + + if (state.tag !== null || state.anchor !== null) { + throwError(state, 'alias node should not have any properties'); + } + + } else if (readPlainScalar(state, flowIndent, CONTEXT_FLOW_IN === nodeContext)) { + hasContent = true; + + if (state.tag === null) { + state.tag = '?'; + } + } + + if (state.anchor !== null) { + state.anchorMap[state.anchor] = state.result; + } + } + } else if (indentStatus === 0) { + // Special case: block sequences are allowed to have same indentation level as the parent. + // http://www.yaml.org/spec/1.2/spec.html#id2799784 + hasContent = allowBlockCollections && readBlockSequence(state, blockIndent); + } + } + + if (state.tag === null) { + if (state.anchor !== null) { + state.anchorMap[state.anchor] = state.result; + } + + } else if (state.tag === '?') { + // Implicit resolving is not allowed for non-scalar types, and '?' + // non-specific tag is only automatically assigned to plain scalars. + // + // We only need to check kind conformity in case user explicitly assigns '?' + // tag, for example like this: "! [0]" + // + if (state.result !== null && state.kind !== 'scalar') { + throwError(state, 'unacceptable node kind for ! tag; it should be "scalar", not "' + state.kind + '"'); + } + + for (typeIndex = 0, typeQuantity = state.implicitTypes.length; typeIndex < typeQuantity; typeIndex += 1) { + type = state.implicitTypes[typeIndex]; + + if (type.resolve(state.result)) { // `state.result` updated in resolver if matched + state.result = type.construct(state.result); + state.tag = type.tag; + if (state.anchor !== null) { + state.anchorMap[state.anchor] = state.result; + } + break; + } + } + } else if (state.tag !== '!') { + if (_hasOwnProperty.call(state.typeMap[state.kind || 'fallback'], state.tag)) { + type = state.typeMap[state.kind || 'fallback'][state.tag]; + } else { + // looking for multi type + type = null; + typeList = state.typeMap.multi[state.kind || 'fallback']; + + for (typeIndex = 0, typeQuantity = typeList.length; typeIndex < typeQuantity; typeIndex += 1) { + if (state.tag.slice(0, typeList[typeIndex].tag.length) === typeList[typeIndex].tag) { + type = typeList[typeIndex]; + break; + } + } + } + + if (!type) { + throwError(state, 'unknown tag !<' + state.tag + '>'); + } + + if (state.result !== null && type.kind !== state.kind) { + throwError(state, 'unacceptable node kind for !<' + state.tag + '> tag; it should be "' + type.kind + '", not "' + state.kind + '"'); + } + + if (!type.resolve(state.result, state.tag)) { // `state.result` updated in resolver if matched + throwError(state, 'cannot resolve a node with !<' + state.tag + '> explicit tag'); + } else { + state.result = type.construct(state.result, state.tag); + if (state.anchor !== null) { + state.anchorMap[state.anchor] = state.result; + } + } + } + + if (state.listener !== null) { + state.listener('close', state); + } + return state.tag !== null || state.anchor !== null || hasContent; +} + +function readDocument(state) { + var documentStart = state.position, + _position, + directiveName, + directiveArgs, + hasDirectives = false, + ch; + + state.version = null; + state.checkLineBreaks = state.legacy; + state.tagMap = Object.create(null); + state.anchorMap = Object.create(null); + + while ((ch = state.input.charCodeAt(state.position)) !== 0) { + skipSeparationSpace(state, true, -1); + + ch = state.input.charCodeAt(state.position); + + if (state.lineIndent > 0 || ch !== 0x25/* % */) { + break; + } + + hasDirectives = true; + ch = state.input.charCodeAt(++state.position); + _position = state.position; + + while (ch !== 0 && !is_WS_OR_EOL(ch)) { + ch = state.input.charCodeAt(++state.position); + } + + directiveName = state.input.slice(_position, state.position); + directiveArgs = []; + + if (directiveName.length < 1) { + throwError(state, 'directive name must not be less than one character in length'); + } + + while (ch !== 0) { + while (is_WHITE_SPACE(ch)) { + ch = state.input.charCodeAt(++state.position); + } + + if (ch === 0x23/* # */) { + do { ch = state.input.charCodeAt(++state.position); } + while (ch !== 0 && !is_EOL(ch)); + break; + } + + if (is_EOL(ch)) break; + + _position = state.position; + + while (ch !== 0 && !is_WS_OR_EOL(ch)) { + ch = state.input.charCodeAt(++state.position); + } + + directiveArgs.push(state.input.slice(_position, state.position)); + } + + if (ch !== 0) readLineBreak(state); + + if (_hasOwnProperty.call(directiveHandlers, directiveName)) { + directiveHandlers[directiveName](state, directiveName, directiveArgs); + } else { + throwWarning(state, 'unknown document directive "' + directiveName + '"'); + } + } + + skipSeparationSpace(state, true, -1); + + if (state.lineIndent === 0 && + state.input.charCodeAt(state.position) === 0x2D/* - */ && + state.input.charCodeAt(state.position + 1) === 0x2D/* - */ && + state.input.charCodeAt(state.position + 2) === 0x2D/* - */) { + state.position += 3; + skipSeparationSpace(state, true, -1); + + } else if (hasDirectives) { + throwError(state, 'directives end mark is expected'); + } + + composeNode(state, state.lineIndent - 1, CONTEXT_BLOCK_OUT, false, true); + skipSeparationSpace(state, true, -1); + + if (state.checkLineBreaks && + PATTERN_NON_ASCII_LINE_BREAKS.test(state.input.slice(documentStart, state.position))) { + throwWarning(state, 'non-ASCII line breaks are interpreted as content'); + } + + state.documents.push(state.result); + + if (state.position === state.lineStart && testDocumentSeparator(state)) { + + if (state.input.charCodeAt(state.position) === 0x2E/* . */) { + state.position += 3; + skipSeparationSpace(state, true, -1); + } + return; + } + + if (state.position < (state.length - 1)) { + throwError(state, 'end of the stream or a document separator is expected'); + } else { + return; + } +} + + +function loadDocuments(input, options) { + input = String(input); + options = options || {}; + + if (input.length !== 0) { + + // Add tailing `\n` if not exists + if (input.charCodeAt(input.length - 1) !== 0x0A/* LF */ && + input.charCodeAt(input.length - 1) !== 0x0D/* CR */) { + input += '\n'; + } + + // Strip BOM + if (input.charCodeAt(0) === 0xFEFF) { + input = input.slice(1); + } + } + + var state = new State(input, options); + + var nullpos = input.indexOf('\0'); + + if (nullpos !== -1) { + state.position = nullpos; + throwError(state, 'null byte is not allowed in input'); + } + + // Use 0 as string terminator. That significantly simplifies bounds check. + state.input += '\0'; + + while (state.input.charCodeAt(state.position) === 0x20/* Space */) { + state.lineIndent += 1; + state.position += 1; + } + + while (state.position < (state.length - 1)) { + readDocument(state); + } + + return state.documents; +} + + +function loadAll(input, iterator, options) { + if (iterator !== null && typeof iterator === 'object' && typeof options === 'undefined') { + options = iterator; + iterator = null; + } + + var documents = loadDocuments(input, options); + + if (typeof iterator !== 'function') { + return documents; + } + + for (var index = 0, length = documents.length; index < length; index += 1) { + iterator(documents[index]); + } +} + + +function load(input, options) { + var documents = loadDocuments(input, options); + + if (documents.length === 0) { + /*eslint-disable no-undefined*/ + return undefined; + } else if (documents.length === 1) { + return documents[0]; + } + throw new YAMLException('expected a single document in the stream, but found more'); +} + + +module.exports.loadAll = loadAll; +module.exports.load = load; + + +/***/ }), + +/***/ 21082: +/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { + +"use strict"; + + +/*eslint-disable max-len*/ + +var YAMLException = __nccwpck_require__(68179); +var Type = __nccwpck_require__(6073); + + +function compileList(schema, name) { + var result = []; + + schema[name].forEach(function (currentType) { + var newIndex = result.length; + + result.forEach(function (previousType, previousIndex) { + if (previousType.tag === currentType.tag && + previousType.kind === currentType.kind && + previousType.multi === currentType.multi) { + + newIndex = previousIndex; + } + }); + + result[newIndex] = currentType; + }); + + return result; +} + + +function compileMap(/* lists... */) { + var result = { + scalar: {}, + sequence: {}, + mapping: {}, + fallback: {}, + multi: { + scalar: [], + sequence: [], + mapping: [], + fallback: [] + } + }, index, length; + + function collectType(type) { + if (type.multi) { + result.multi[type.kind].push(type); + result.multi['fallback'].push(type); + } else { + result[type.kind][type.tag] = result['fallback'][type.tag] = type; + } + } + + for (index = 0, length = arguments.length; index < length; index += 1) { + arguments[index].forEach(collectType); + } + return result; +} + + +function Schema(definition) { + return this.extend(definition); +} + + +Schema.prototype.extend = function extend(definition) { + var implicit = []; + var explicit = []; + + if (definition instanceof Type) { + // Schema.extend(type) + explicit.push(definition); + + } else if (Array.isArray(definition)) { + // Schema.extend([ type1, type2, ... ]) + explicit = explicit.concat(definition); + + } else if (definition && (Array.isArray(definition.implicit) || Array.isArray(definition.explicit))) { + // Schema.extend({ explicit: [ type1, type2, ... ], implicit: [ type1, type2, ... ] }) + if (definition.implicit) implicit = implicit.concat(definition.implicit); + if (definition.explicit) explicit = explicit.concat(definition.explicit); + + } else { + throw new YAMLException('Schema.extend argument should be a Type, [ Type ], ' + + 'or a schema definition ({ implicit: [...], explicit: [...] })'); + } + + implicit.forEach(function (type) { + if (!(type instanceof Type)) { + throw new YAMLException('Specified list of YAML types (or a single Type object) contains a non-Type object.'); + } + + if (type.loadKind && type.loadKind !== 'scalar') { + throw new YAMLException('There is a non-scalar type in the implicit list of a schema. Implicit resolving of such types is not supported.'); + } + + if (type.multi) { + throw new YAMLException('There is a multi type in the implicit list of a schema. Multi tags can only be listed as explicit.'); + } + }); + + explicit.forEach(function (type) { + if (!(type instanceof Type)) { + throw new YAMLException('Specified list of YAML types (or a single Type object) contains a non-Type object.'); + } + }); + + var result = Object.create(Schema.prototype); + + result.implicit = (this.implicit || []).concat(implicit); + result.explicit = (this.explicit || []).concat(explicit); + + result.compiledImplicit = compileList(result, 'implicit'); + result.compiledExplicit = compileList(result, 'explicit'); + result.compiledTypeMap = compileMap(result.compiledImplicit, result.compiledExplicit); + + return result; +}; + + +module.exports = Schema; + + +/***/ }), + +/***/ 12011: +/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { + +"use strict"; +// Standard YAML's Core schema. +// http://www.yaml.org/spec/1.2/spec.html#id2804923 +// +// NOTE: JS-YAML does not support schema-specific tag resolution restrictions. +// So, Core schema has no distinctions from JSON schema is JS-YAML. + + + + + +module.exports = __nccwpck_require__(1035); + + +/***/ }), + +/***/ 18759: +/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { + +"use strict"; +// JS-YAML's default schema for `safeLoad` function. +// It is not described in the YAML specification. +// +// This schema is based on standard YAML's Core schema and includes most of +// extra types described at YAML tag repository. (http://yaml.org/type/) + + + + + +module.exports = __nccwpck_require__(12011).extend({ + implicit: [ + __nccwpck_require__(99212), + __nccwpck_require__(86104) + ], + explicit: [ + __nccwpck_require__(77900), + __nccwpck_require__(19046), + __nccwpck_require__(96860), + __nccwpck_require__(79548) + ] +}); + + +/***/ }), + +/***/ 28562: +/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { + +"use strict"; +// Standard YAML's Failsafe schema. +// http://www.yaml.org/spec/1.2/spec.html#id2802346 + + + + + +var Schema = __nccwpck_require__(21082); + + +module.exports = new Schema({ + explicit: [ + __nccwpck_require__(23619), + __nccwpck_require__(67283), + __nccwpck_require__(86150) + ] +}); + + +/***/ }), + +/***/ 1035: +/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { + +"use strict"; +// Standard YAML's JSON schema. +// http://www.yaml.org/spec/1.2/spec.html#id2803231 +// +// NOTE: JS-YAML does not support schema-specific tag resolution restrictions. +// So, this schema is not such strict as defined in the YAML specification. +// It allows numbers in binary notaion, use `Null` and `NULL` as `null`, etc. + + + + + +module.exports = __nccwpck_require__(28562).extend({ + implicit: [ + __nccwpck_require__(20721), + __nccwpck_require__(64993), + __nccwpck_require__(11615), + __nccwpck_require__(42705) + ] +}); + + +/***/ }), + +/***/ 96975: +/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { + +"use strict"; + + + +var common = __nccwpck_require__(26829); + + +// get snippet for a single line, respecting maxLength +function getLine(buffer, lineStart, lineEnd, position, maxLineLength) { + var head = ''; + var tail = ''; + var maxHalfLength = Math.floor(maxLineLength / 2) - 1; + + if (position - lineStart > maxHalfLength) { + head = ' ... '; + lineStart = position - maxHalfLength + head.length; + } + + if (lineEnd - position > maxHalfLength) { + tail = ' ...'; + lineEnd = position + maxHalfLength - tail.length; + } + + return { + str: head + buffer.slice(lineStart, lineEnd).replace(/\t/g, '→') + tail, + pos: position - lineStart + head.length // relative position + }; +} + + +function padStart(string, max) { + return common.repeat(' ', max - string.length) + string; +} + + +function makeSnippet(mark, options) { + options = Object.create(options || null); + + if (!mark.buffer) return null; + + if (!options.maxLength) options.maxLength = 79; + if (typeof options.indent !== 'number') options.indent = 1; + if (typeof options.linesBefore !== 'number') options.linesBefore = 3; + if (typeof options.linesAfter !== 'number') options.linesAfter = 2; + + var re = /\r?\n|\r|\0/g; + var lineStarts = [ 0 ]; + var lineEnds = []; + var match; + var foundLineNo = -1; + + while ((match = re.exec(mark.buffer))) { + lineEnds.push(match.index); + lineStarts.push(match.index + match[0].length); + + if (mark.position <= match.index && foundLineNo < 0) { + foundLineNo = lineStarts.length - 2; + } + } + + if (foundLineNo < 0) foundLineNo = lineStarts.length - 1; + + var result = '', i, line; + var lineNoLength = Math.min(mark.line + options.linesAfter, lineEnds.length).toString().length; + var maxLineLength = options.maxLength - (options.indent + lineNoLength + 3); + + for (i = 1; i <= options.linesBefore; i++) { + if (foundLineNo - i < 0) break; + line = getLine( + mark.buffer, + lineStarts[foundLineNo - i], + lineEnds[foundLineNo - i], + mark.position - (lineStarts[foundLineNo] - lineStarts[foundLineNo - i]), + maxLineLength + ); + result = common.repeat(' ', options.indent) + padStart((mark.line - i + 1).toString(), lineNoLength) + + ' | ' + line.str + '\n' + result; + } + + line = getLine(mark.buffer, lineStarts[foundLineNo], lineEnds[foundLineNo], mark.position, maxLineLength); + result += common.repeat(' ', options.indent) + padStart((mark.line + 1).toString(), lineNoLength) + + ' | ' + line.str + '\n'; + result += common.repeat('-', options.indent + lineNoLength + 3 + line.pos) + '^' + '\n'; + + for (i = 1; i <= options.linesAfter; i++) { + if (foundLineNo + i >= lineEnds.length) break; + line = getLine( + mark.buffer, + lineStarts[foundLineNo + i], + lineEnds[foundLineNo + i], + mark.position - (lineStarts[foundLineNo] - lineStarts[foundLineNo + i]), + maxLineLength + ); + result += common.repeat(' ', options.indent) + padStart((mark.line + i + 1).toString(), lineNoLength) + + ' | ' + line.str + '\n'; + } + + return result.replace(/\n$/, ''); +} + + +module.exports = makeSnippet; + + +/***/ }), + +/***/ 6073: +/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { + +"use strict"; + + +var YAMLException = __nccwpck_require__(68179); + +var TYPE_CONSTRUCTOR_OPTIONS = [ + 'kind', + 'multi', + 'resolve', + 'construct', + 'instanceOf', + 'predicate', + 'represent', + 'representName', + 'defaultStyle', + 'styleAliases' +]; + +var YAML_NODE_KINDS = [ + 'scalar', + 'sequence', + 'mapping' +]; + +function compileStyleAliases(map) { + var result = {}; + + if (map !== null) { + Object.keys(map).forEach(function (style) { + map[style].forEach(function (alias) { + result[String(alias)] = style; + }); + }); + } + + return result; +} + +function Type(tag, options) { + options = options || {}; + + Object.keys(options).forEach(function (name) { + if (TYPE_CONSTRUCTOR_OPTIONS.indexOf(name) === -1) { + throw new YAMLException('Unknown option "' + name + '" is met in definition of "' + tag + '" YAML type.'); + } + }); + + // TODO: Add tag format check. + this.options = options; // keep original options in case user wants to extend this type later + this.tag = tag; + this.kind = options['kind'] || null; + this.resolve = options['resolve'] || function () { return true; }; + this.construct = options['construct'] || function (data) { return data; }; + this.instanceOf = options['instanceOf'] || null; + this.predicate = options['predicate'] || null; + this.represent = options['represent'] || null; + this.representName = options['representName'] || null; + this.defaultStyle = options['defaultStyle'] || null; + this.multi = options['multi'] || false; + this.styleAliases = compileStyleAliases(options['styleAliases'] || null); + + if (YAML_NODE_KINDS.indexOf(this.kind) === -1) { + throw new YAMLException('Unknown kind "' + this.kind + '" is specified for "' + tag + '" YAML type.'); + } +} + +module.exports = Type; + + +/***/ }), + +/***/ 77900: +/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { + +"use strict"; + + +/*eslint-disable no-bitwise*/ + + +var Type = __nccwpck_require__(6073); + + +// [ 64, 65, 66 ] -> [ padding, CR, LF ] +var BASE64_MAP = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=\n\r'; + + +function resolveYamlBinary(data) { + if (data === null) return false; + + var code, idx, bitlen = 0, max = data.length, map = BASE64_MAP; + + // Convert one by one. + for (idx = 0; idx < max; idx++) { + code = map.indexOf(data.charAt(idx)); + + // Skip CR/LF + if (code > 64) continue; + + // Fail on illegal characters + if (code < 0) return false; + + bitlen += 6; + } + + // If there are any bits left, source was corrupted + return (bitlen % 8) === 0; +} + +function constructYamlBinary(data) { + var idx, tailbits, + input = data.replace(/[\r\n=]/g, ''), // remove CR/LF & padding to simplify scan + max = input.length, + map = BASE64_MAP, + bits = 0, + result = []; + + // Collect by 6*4 bits (3 bytes) + + for (idx = 0; idx < max; idx++) { + if ((idx % 4 === 0) && idx) { + result.push((bits >> 16) & 0xFF); + result.push((bits >> 8) & 0xFF); + result.push(bits & 0xFF); + } + + bits = (bits << 6) | map.indexOf(input.charAt(idx)); + } + + // Dump tail + + tailbits = (max % 4) * 6; + + if (tailbits === 0) { + result.push((bits >> 16) & 0xFF); + result.push((bits >> 8) & 0xFF); + result.push(bits & 0xFF); + } else if (tailbits === 18) { + result.push((bits >> 10) & 0xFF); + result.push((bits >> 2) & 0xFF); + } else if (tailbits === 12) { + result.push((bits >> 4) & 0xFF); + } + + return new Uint8Array(result); +} + +function representYamlBinary(object /*, style*/) { + var result = '', bits = 0, idx, tail, + max = object.length, + map = BASE64_MAP; + + // Convert every three bytes to 4 ASCII characters. + + for (idx = 0; idx < max; idx++) { + if ((idx % 3 === 0) && idx) { + result += map[(bits >> 18) & 0x3F]; + result += map[(bits >> 12) & 0x3F]; + result += map[(bits >> 6) & 0x3F]; + result += map[bits & 0x3F]; + } + + bits = (bits << 8) + object[idx]; + } + + // Dump tail + + tail = max % 3; + + if (tail === 0) { + result += map[(bits >> 18) & 0x3F]; + result += map[(bits >> 12) & 0x3F]; + result += map[(bits >> 6) & 0x3F]; + result += map[bits & 0x3F]; + } else if (tail === 2) { + result += map[(bits >> 10) & 0x3F]; + result += map[(bits >> 4) & 0x3F]; + result += map[(bits << 2) & 0x3F]; + result += map[64]; + } else if (tail === 1) { + result += map[(bits >> 2) & 0x3F]; + result += map[(bits << 4) & 0x3F]; + result += map[64]; + result += map[64]; + } + + return result; +} + +function isBinary(obj) { + return Object.prototype.toString.call(obj) === '[object Uint8Array]'; +} + +module.exports = new Type('tag:yaml.org,2002:binary', { + kind: 'scalar', + resolve: resolveYamlBinary, + construct: constructYamlBinary, + predicate: isBinary, + represent: representYamlBinary +}); + + +/***/ }), + +/***/ 64993: +/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { + +"use strict"; + + +var Type = __nccwpck_require__(6073); + +function resolveYamlBoolean(data) { + if (data === null) return false; + + var max = data.length; + + return (max === 4 && (data === 'true' || data === 'True' || data === 'TRUE')) || + (max === 5 && (data === 'false' || data === 'False' || data === 'FALSE')); +} + +function constructYamlBoolean(data) { + return data === 'true' || + data === 'True' || + data === 'TRUE'; +} + +function isBoolean(object) { + return Object.prototype.toString.call(object) === '[object Boolean]'; +} + +module.exports = new Type('tag:yaml.org,2002:bool', { + kind: 'scalar', + resolve: resolveYamlBoolean, + construct: constructYamlBoolean, + predicate: isBoolean, + represent: { + lowercase: function (object) { return object ? 'true' : 'false'; }, + uppercase: function (object) { return object ? 'TRUE' : 'FALSE'; }, + camelcase: function (object) { return object ? 'True' : 'False'; } + }, + defaultStyle: 'lowercase' +}); + + +/***/ }), + +/***/ 42705: +/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { + +"use strict"; + + +var common = __nccwpck_require__(26829); +var Type = __nccwpck_require__(6073); + +var YAML_FLOAT_PATTERN = new RegExp( + // 2.5e4, 2.5 and integers + '^(?:[-+]?(?:[0-9][0-9_]*)(?:\\.[0-9_]*)?(?:[eE][-+]?[0-9]+)?' + + // .2e4, .2 + // special case, seems not from spec + '|\\.[0-9_]+(?:[eE][-+]?[0-9]+)?' + + // .inf + '|[-+]?\\.(?:inf|Inf|INF)' + + // .nan + '|\\.(?:nan|NaN|NAN))$'); + +function resolveYamlFloat(data) { + if (data === null) return false; + + if (!YAML_FLOAT_PATTERN.test(data) || + // Quick hack to not allow integers end with `_` + // Probably should update regexp & check speed + data[data.length - 1] === '_') { + return false; + } + + return true; +} + +function constructYamlFloat(data) { + var value, sign; + + value = data.replace(/_/g, '').toLowerCase(); + sign = value[0] === '-' ? -1 : 1; + + if ('+-'.indexOf(value[0]) >= 0) { + value = value.slice(1); + } + + if (value === '.inf') { + return (sign === 1) ? Number.POSITIVE_INFINITY : Number.NEGATIVE_INFINITY; + + } else if (value === '.nan') { + return NaN; + } + return sign * parseFloat(value, 10); +} + + +var SCIENTIFIC_WITHOUT_DOT = /^[-+]?[0-9]+e/; + +function representYamlFloat(object, style) { + var res; + + if (isNaN(object)) { + switch (style) { + case 'lowercase': return '.nan'; + case 'uppercase': return '.NAN'; + case 'camelcase': return '.NaN'; + } + } else if (Number.POSITIVE_INFINITY === object) { + switch (style) { + case 'lowercase': return '.inf'; + case 'uppercase': return '.INF'; + case 'camelcase': return '.Inf'; + } + } else if (Number.NEGATIVE_INFINITY === object) { + switch (style) { + case 'lowercase': return '-.inf'; + case 'uppercase': return '-.INF'; + case 'camelcase': return '-.Inf'; + } + } else if (common.isNegativeZero(object)) { + return '-0.0'; + } + + res = object.toString(10); + + // JS stringifier can build scientific format without dots: 5e-100, + // while YAML requres dot: 5.e-100. Fix it with simple hack + + return SCIENTIFIC_WITHOUT_DOT.test(res) ? res.replace('e', '.e') : res; +} + +function isFloat(object) { + return (Object.prototype.toString.call(object) === '[object Number]') && + (object % 1 !== 0 || common.isNegativeZero(object)); +} + +module.exports = new Type('tag:yaml.org,2002:float', { + kind: 'scalar', + resolve: resolveYamlFloat, + construct: constructYamlFloat, + predicate: isFloat, + represent: representYamlFloat, + defaultStyle: 'lowercase' +}); + + +/***/ }), + +/***/ 11615: +/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { + +"use strict"; + + +var common = __nccwpck_require__(26829); +var Type = __nccwpck_require__(6073); + +function isHexCode(c) { + return ((0x30/* 0 */ <= c) && (c <= 0x39/* 9 */)) || + ((0x41/* A */ <= c) && (c <= 0x46/* F */)) || + ((0x61/* a */ <= c) && (c <= 0x66/* f */)); +} + +function isOctCode(c) { + return ((0x30/* 0 */ <= c) && (c <= 0x37/* 7 */)); +} + +function isDecCode(c) { + return ((0x30/* 0 */ <= c) && (c <= 0x39/* 9 */)); +} + +function resolveYamlInteger(data) { + if (data === null) return false; + + var max = data.length, + index = 0, + hasDigits = false, + ch; + + if (!max) return false; + + ch = data[index]; + + // sign + if (ch === '-' || ch === '+') { + ch = data[++index]; + } + + if (ch === '0') { + // 0 + if (index + 1 === max) return true; + ch = data[++index]; + + // base 2, base 8, base 16 + + if (ch === 'b') { + // base 2 + index++; + + for (; index < max; index++) { + ch = data[index]; + if (ch === '_') continue; + if (ch !== '0' && ch !== '1') return false; + hasDigits = true; + } + return hasDigits && ch !== '_'; + } + + + if (ch === 'x') { + // base 16 + index++; + + for (; index < max; index++) { + ch = data[index]; + if (ch === '_') continue; + if (!isHexCode(data.charCodeAt(index))) return false; + hasDigits = true; + } + return hasDigits && ch !== '_'; + } + + + if (ch === 'o') { + // base 8 + index++; + + for (; index < max; index++) { + ch = data[index]; + if (ch === '_') continue; + if (!isOctCode(data.charCodeAt(index))) return false; + hasDigits = true; + } + return hasDigits && ch !== '_'; + } + } + + // base 10 (except 0) + + // value should not start with `_`; + if (ch === '_') return false; + + for (; index < max; index++) { + ch = data[index]; + if (ch === '_') continue; + if (!isDecCode(data.charCodeAt(index))) { + return false; + } + hasDigits = true; + } + + // Should have digits and should not end with `_` + if (!hasDigits || ch === '_') return false; + + return true; +} + +function constructYamlInteger(data) { + var value = data, sign = 1, ch; + + if (value.indexOf('_') !== -1) { + value = value.replace(/_/g, ''); + } + + ch = value[0]; + + if (ch === '-' || ch === '+') { + if (ch === '-') sign = -1; + value = value.slice(1); + ch = value[0]; + } + + if (value === '0') return 0; + + if (ch === '0') { + if (value[1] === 'b') return sign * parseInt(value.slice(2), 2); + if (value[1] === 'x') return sign * parseInt(value.slice(2), 16); + if (value[1] === 'o') return sign * parseInt(value.slice(2), 8); + } + + return sign * parseInt(value, 10); +} + +function isInteger(object) { + return (Object.prototype.toString.call(object)) === '[object Number]' && + (object % 1 === 0 && !common.isNegativeZero(object)); +} + +module.exports = new Type('tag:yaml.org,2002:int', { + kind: 'scalar', + resolve: resolveYamlInteger, + construct: constructYamlInteger, + predicate: isInteger, + represent: { + binary: function (obj) { return obj >= 0 ? '0b' + obj.toString(2) : '-0b' + obj.toString(2).slice(1); }, + octal: function (obj) { return obj >= 0 ? '0o' + obj.toString(8) : '-0o' + obj.toString(8).slice(1); }, + decimal: function (obj) { return obj.toString(10); }, + /* eslint-disable max-len */ + hexadecimal: function (obj) { return obj >= 0 ? '0x' + obj.toString(16).toUpperCase() : '-0x' + obj.toString(16).toUpperCase().slice(1); } + }, + defaultStyle: 'decimal', + styleAliases: { + binary: [ 2, 'bin' ], + octal: [ 8, 'oct' ], + decimal: [ 10, 'dec' ], + hexadecimal: [ 16, 'hex' ] + } +}); + + +/***/ }), + +/***/ 86150: +/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { + +"use strict"; + + +var Type = __nccwpck_require__(6073); + +module.exports = new Type('tag:yaml.org,2002:map', { + kind: 'mapping', + construct: function (data) { return data !== null ? data : {}; } +}); + + +/***/ }), + +/***/ 86104: +/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { + +"use strict"; + + +var Type = __nccwpck_require__(6073); + +function resolveYamlMerge(data) { + return data === '<<' || data === null; +} + +module.exports = new Type('tag:yaml.org,2002:merge', { + kind: 'scalar', + resolve: resolveYamlMerge +}); + + +/***/ }), + +/***/ 20721: +/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { + +"use strict"; + + +var Type = __nccwpck_require__(6073); + +function resolveYamlNull(data) { + if (data === null) return true; + + var max = data.length; + + return (max === 1 && data === '~') || + (max === 4 && (data === 'null' || data === 'Null' || data === 'NULL')); +} + +function constructYamlNull() { + return null; +} + +function isNull(object) { + return object === null; +} + +module.exports = new Type('tag:yaml.org,2002:null', { + kind: 'scalar', + resolve: resolveYamlNull, + construct: constructYamlNull, + predicate: isNull, + represent: { + canonical: function () { return '~'; }, + lowercase: function () { return 'null'; }, + uppercase: function () { return 'NULL'; }, + camelcase: function () { return 'Null'; }, + empty: function () { return ''; } + }, + defaultStyle: 'lowercase' +}); + + +/***/ }), + +/***/ 19046: +/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { + +"use strict"; + + +var Type = __nccwpck_require__(6073); + +var _hasOwnProperty = Object.prototype.hasOwnProperty; +var _toString = Object.prototype.toString; + +function resolveYamlOmap(data) { + if (data === null) return true; + + var objectKeys = [], index, length, pair, pairKey, pairHasKey, + object = data; + + for (index = 0, length = object.length; index < length; index += 1) { + pair = object[index]; + pairHasKey = false; + + if (_toString.call(pair) !== '[object Object]') return false; + + for (pairKey in pair) { + if (_hasOwnProperty.call(pair, pairKey)) { + if (!pairHasKey) pairHasKey = true; + else return false; + } + } + + if (!pairHasKey) return false; + + if (objectKeys.indexOf(pairKey) === -1) objectKeys.push(pairKey); + else return false; + } + + return true; +} + +function constructYamlOmap(data) { + return data !== null ? data : []; +} + +module.exports = new Type('tag:yaml.org,2002:omap', { + kind: 'sequence', + resolve: resolveYamlOmap, + construct: constructYamlOmap +}); + + +/***/ }), + +/***/ 96860: +/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { + +"use strict"; + + +var Type = __nccwpck_require__(6073); + +var _toString = Object.prototype.toString; + +function resolveYamlPairs(data) { + if (data === null) return true; + + var index, length, pair, keys, result, + object = data; + + result = new Array(object.length); + + for (index = 0, length = object.length; index < length; index += 1) { + pair = object[index]; + + if (_toString.call(pair) !== '[object Object]') return false; + + keys = Object.keys(pair); + + if (keys.length !== 1) return false; + + result[index] = [ keys[0], pair[keys[0]] ]; + } + + return true; +} + +function constructYamlPairs(data) { + if (data === null) return []; + + var index, length, pair, keys, result, + object = data; + + result = new Array(object.length); + + for (index = 0, length = object.length; index < length; index += 1) { + pair = object[index]; + + keys = Object.keys(pair); + + result[index] = [ keys[0], pair[keys[0]] ]; + } + + return result; +} + +module.exports = new Type('tag:yaml.org,2002:pairs', { + kind: 'sequence', + resolve: resolveYamlPairs, + construct: constructYamlPairs +}); + + +/***/ }), + +/***/ 67283: +/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { + +"use strict"; + + +var Type = __nccwpck_require__(6073); + +module.exports = new Type('tag:yaml.org,2002:seq', { + kind: 'sequence', + construct: function (data) { return data !== null ? data : []; } +}); + + +/***/ }), + +/***/ 79548: +/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { + +"use strict"; + + +var Type = __nccwpck_require__(6073); + +var _hasOwnProperty = Object.prototype.hasOwnProperty; + +function resolveYamlSet(data) { + if (data === null) return true; + + var key, object = data; + + for (key in object) { + if (_hasOwnProperty.call(object, key)) { + if (object[key] !== null) return false; + } + } + + return true; +} + +function constructYamlSet(data) { + return data !== null ? data : {}; +} + +module.exports = new Type('tag:yaml.org,2002:set', { + kind: 'mapping', + resolve: resolveYamlSet, + construct: constructYamlSet +}); + + +/***/ }), + +/***/ 23619: +/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { + +"use strict"; + + +var Type = __nccwpck_require__(6073); + +module.exports = new Type('tag:yaml.org,2002:str', { + kind: 'scalar', + construct: function (data) { return data !== null ? data : ''; } +}); + + +/***/ }), + +/***/ 99212: +/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { + +"use strict"; + + +var Type = __nccwpck_require__(6073); + +var YAML_DATE_REGEXP = new RegExp( + '^([0-9][0-9][0-9][0-9])' + // [1] year + '-([0-9][0-9])' + // [2] month + '-([0-9][0-9])$'); // [3] day + +var YAML_TIMESTAMP_REGEXP = new RegExp( + '^([0-9][0-9][0-9][0-9])' + // [1] year + '-([0-9][0-9]?)' + // [2] month + '-([0-9][0-9]?)' + // [3] day + '(?:[Tt]|[ \\t]+)' + // ... + '([0-9][0-9]?)' + // [4] hour + ':([0-9][0-9])' + // [5] minute + ':([0-9][0-9])' + // [6] second + '(?:\\.([0-9]*))?' + // [7] fraction + '(?:[ \\t]*(Z|([-+])([0-9][0-9]?)' + // [8] tz [9] tz_sign [10] tz_hour + '(?::([0-9][0-9]))?))?$'); // [11] tz_minute + +function resolveYamlTimestamp(data) { + if (data === null) return false; + if (YAML_DATE_REGEXP.exec(data) !== null) return true; + if (YAML_TIMESTAMP_REGEXP.exec(data) !== null) return true; + return false; +} + +function constructYamlTimestamp(data) { + var match, year, month, day, hour, minute, second, fraction = 0, + delta = null, tz_hour, tz_minute, date; + + match = YAML_DATE_REGEXP.exec(data); + if (match === null) match = YAML_TIMESTAMP_REGEXP.exec(data); + + if (match === null) throw new Error('Date resolve error'); + + // match: [1] year [2] month [3] day + + year = +(match[1]); + month = +(match[2]) - 1; // JS month starts with 0 + day = +(match[3]); + + if (!match[4]) { // no hour + return new Date(Date.UTC(year, month, day)); + } + + // match: [4] hour [5] minute [6] second [7] fraction + + hour = +(match[4]); + minute = +(match[5]); + second = +(match[6]); + + if (match[7]) { + fraction = match[7].slice(0, 3); + while (fraction.length < 3) { // milli-seconds + fraction += '0'; + } + fraction = +fraction; + } + + // match: [8] tz [9] tz_sign [10] tz_hour [11] tz_minute + + if (match[9]) { + tz_hour = +(match[10]); + tz_minute = +(match[11] || 0); + delta = (tz_hour * 60 + tz_minute) * 60000; // delta in mili-seconds + if (match[9] === '-') delta = -delta; + } + + date = new Date(Date.UTC(year, month, day, hour, minute, second, fraction)); + + if (delta) date.setTime(date.getTime() - delta); + + return date; +} + +function representYamlTimestamp(object /*, style*/) { + return object.toISOString(); +} + +module.exports = new Type('tag:yaml.org,2002:timestamp', { + kind: 'scalar', + resolve: resolveYamlTimestamp, + construct: constructYamlTimestamp, + instanceOf: Date, + represent: representYamlTimestamp +}); + + +/***/ }), + +/***/ 87563: +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + +/* eslint-disable @typescript-eslint/no-empty-interface */ +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.BasicAsyncEnumerable = void 0; +/* eslint-disable @typescript-eslint/naming-convention */ +/** + * The class behind IAsyncEnumerable + * @private + */ +class BasicAsyncEnumerable { + constructor(iterator) { + this.iterator = iterator; + // + } + [Symbol.asyncIterator]() { + return this.iterator(); + } +} +exports.BasicAsyncEnumerable = BasicAsyncEnumerable; + + +/***/ }), + +/***/ 42485: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.OrderedAsyncEnumerable = void 0; +const asAsyncSortedKeyValues_1 = __nccwpck_require__(72428); +const asAsyncSortedKeyValuesSync_1 = __nccwpck_require__(12652); +const asSortedKeyValues_1 = __nccwpck_require__(703); +const asSortedKeyValuesSync_1 = __nccwpck_require__(88775); +const BasicAsyncEnumerable_1 = __nccwpck_require__(87563); +/** + * Ordered Async Enumerable + */ +class OrderedAsyncEnumerable extends BasicAsyncEnumerable_1.BasicAsyncEnumerable { + constructor(orderedPairs) { + super(async function* () { + for await (const orderedPair of orderedPairs()) { + yield* orderedPair; + } + }); + this.orderedPairs = orderedPairs; + } + static generateAsync(source, keySelector, ascending, comparer) { + let orderedPairs; + if (source instanceof OrderedAsyncEnumerable) { + orderedPairs = async function* () { + for await (const pair of source.orderedPairs()) { + yield* asAsyncSortedKeyValuesSync_1.asAsyncSortedKeyValuesSync(pair, keySelector, ascending, comparer); + } + }; + } + else { + orderedPairs = () => asAsyncSortedKeyValues_1.asAsyncSortedKeyValues(source, keySelector, ascending, comparer); + } + return new OrderedAsyncEnumerable(orderedPairs); + } + static generate(source, keySelector, ascending, comparer) { + let orderedPairs; + if (source instanceof OrderedAsyncEnumerable) { + orderedPairs = async function* () { + for await (const pair of source.orderedPairs()) { + yield* asSortedKeyValuesSync_1.asSortedKeyValuesSync(pair, keySelector, ascending, comparer); + } + }; + } + else { + orderedPairs = () => asSortedKeyValues_1.asSortedKeyValues(source, keySelector, ascending, comparer); + } + return new OrderedAsyncEnumerable(orderedPairs); + } + thenBy(keySelector, comparer) { + return OrderedAsyncEnumerable.generate(this, keySelector, true, comparer); + } + thenByAsync(keySelector, comparer) { + return OrderedAsyncEnumerable.generateAsync(this, keySelector, true, comparer); + } + thenByDescending(keySelector, comparer) { + return OrderedAsyncEnumerable.generate(this, keySelector, false, comparer); + } + thenByDescendingAsync(keySelector, comparer) { + return OrderedAsyncEnumerable.generateAsync(this, keySelector, false, comparer); + } +} +exports.OrderedAsyncEnumerable = OrderedAsyncEnumerable; + + +/***/ }), + +/***/ 37346: +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.asAsyncKeyMap = void 0; +/** + * Converts values to a key values map. + * @param source Async Iterable + * @param keySelector Async Key Selector for Map + * @returns Promise for a Map for Key to Values + */ +exports.asAsyncKeyMap = async (source, keySelector) => { + const map = new Map(); + for await (const item of source) { + const key = await keySelector(item); + const currentMapping = map.get(key); + if (currentMapping) { + currentMapping.push(item); + } + else { + map.set(key, [item]); + } + } + return map; +}; + + +/***/ }), + +/***/ 61018: +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.asAsyncKeyMapSync = void 0; +/** + * Converts values to a key values map. + * @param source Iterable + * @param keySelector Async Key Selector for Map + * @returns Promise for a Map for Key to Values + */ +exports.asAsyncKeyMapSync = async (source, keySelector) => { + const map = new Map(); + for (const item of source) { + const key = await keySelector(item); + const currentMapping = map.get(key); + if (currentMapping) { + currentMapping.push(item); + } + else { + map.set(key, [item]); + } + } + return map; +}; + + +/***/ }), + +/***/ 72428: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.asAsyncSortedKeyValues = void 0; +const asAsyncKeyMap_1 = __nccwpck_require__(37346); +/** + * Sorts values in an Async Iterable based on key and a key comparer. + * @param source Async Iterable + * @param keySelector Async Key Selector + * @param ascending Ascending or Descending Sort + * @param comparer Key Comparer for Sorting. Optional. + * @returns Async Iterable Iterator of arrays + */ +async function* asAsyncSortedKeyValues(source, keySelector, ascending, comparer) { + const map = await asAsyncKeyMap_1.asAsyncKeyMap(source, keySelector); + const sortedKeys = [...map.keys()].sort(comparer ? comparer : undefined); + if (ascending) { + for (let i = 0; i < sortedKeys.length; i++) { + yield map.get(sortedKeys[i]); + } + } + else { + for (let i = sortedKeys.length - 1; i >= 0; i--) { + yield map.get(sortedKeys[i]); + } + } +} +exports.asAsyncSortedKeyValues = asAsyncSortedKeyValues; + + +/***/ }), + +/***/ 12652: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.asAsyncSortedKeyValuesSync = void 0; +const asAsyncKeyMapSync_1 = __nccwpck_require__(61018); +/** + * Sorts values in an Async Iterable based on key and a key comparer. + * @param source Iterable + * @param keySelector Async Key Selector + * @param ascending Ascending or Descending Sort + * @param comparer Key Comparer for Sorting. Optional. + * @returns Async Iterable Iterator of arrays + */ +async function* asAsyncSortedKeyValuesSync(source, keySelector, ascending, comparer) { + const map = await asAsyncKeyMapSync_1.asAsyncKeyMapSync(source, keySelector); + const sortedKeys = [...map.keys()].sort(comparer ? comparer : undefined); + if (ascending) { + for (let i = 0; i < sortedKeys.length; i++) { + yield map.get(sortedKeys[i]); + } + } + else { + for (let i = sortedKeys.length - 1; i >= 0; i--) { + yield map.get(sortedKeys[i]); + } + } +} +exports.asAsyncSortedKeyValuesSync = asAsyncSortedKeyValuesSync; + + +/***/ }), + +/***/ 98636: +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.asKeyMap = void 0; +/** + * Converts values to a key values map. + * @param source Async Iterable + * @param keySelector Key Selector for Map + * @returns Promise for a Map for Key to Values + */ +exports.asKeyMap = async (source, keySelector) => { + const map = new Map(); + for await (const item of source) { + const key = keySelector(item); + const currentMapping = map.get(key); + if (currentMapping) { + currentMapping.push(item); + } + else { + map.set(key, [item]); + } + } + return map; +}; + + +/***/ }), + +/***/ 40623: +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.asKeyMapSync = void 0; +/** + * Converts values to a key values map. + * @param source Iterable + * @param keySelector Key Selector for Map + * @returns Map for Key to Values + */ +exports.asKeyMapSync = (source, keySelector) => { + const map = new Map(); + for (const item of source) { + const key = keySelector(item); + const currentMapping = map.get(key); + if (currentMapping) { + currentMapping.push(item); + } + else { + map.set(key, [item]); + } + } + return map; +}; + + +/***/ }), + +/***/ 703: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.asSortedKeyValues = void 0; +const asKeyMap_1 = __nccwpck_require__(98636); +/** + * Sorts values in an Iterable based on key and a key comparer. + * @param source Async Iterable + * @param keySelector Key Selector + * @param ascending Ascending or Descending Sort + * @param comparer Key Comparer for Sorting. Optional. + * @returns Async Iterable Iterator + */ +async function* asSortedKeyValues(source, keySelector, ascending, comparer) { + const map = await asKeyMap_1.asKeyMap(source, keySelector); + const sortedKeys = [...map.keys()].sort(comparer ? comparer : undefined); + if (ascending) { + for (let i = 0; i < sortedKeys.length; i++) { + yield map.get(sortedKeys[i]); + } + } + else { + for (let i = sortedKeys.length - 1; i >= 0; i--) { + yield map.get(sortedKeys[i]); + } + } +} +exports.asSortedKeyValues = asSortedKeyValues; + + +/***/ }), + +/***/ 88775: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.asSortedKeyValuesSync = void 0; +const asKeyMapSync_1 = __nccwpck_require__(40623); +/** + * Sorts values in an Iterable based on key and a key comparer. + * @param source Iterable + * @param keySelector Key Selector + * @param ascending Ascending or Descending Sort + * @param comparer Key Comparer for Sorting. Optional. + */ +function* asSortedKeyValuesSync(source, keySelector, ascending, comparer) { + const map = asKeyMapSync_1.asKeyMapSync(source, keySelector); + const sortedKeys = [...map.keys()].sort(comparer ? comparer : undefined); + if (ascending) { + for (let i = 0; i < sortedKeys.length; i++) { + yield map.get(sortedKeys[i]); + } + } + else { + for (let i = sortedKeys.length - 1; i >= 0; i--) { + yield map.get(sortedKeys[i]); + } + } +} +exports.asSortedKeyValuesSync = asSortedKeyValuesSync; + + +/***/ }), + +/***/ 83822: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.aggregate = void 0; +const shared_1 = __nccwpck_require__(25897); +function aggregate(source, seedOrFunc, func, resultSelector) { + if (resultSelector) { + if (!func) { + throw new ReferenceError(`TAccumulate function is undefined`); + } + return aggregate3(source, seedOrFunc, func, resultSelector); + } + else if (func) { + return aggregate2(source, seedOrFunc, func); + } + else { + return aggregate1(source, seedOrFunc); + } +} +exports.aggregate = aggregate; +const aggregate1 = async (source, func) => { + let aggregateValue; + for await (const value of source) { + if (aggregateValue) { + aggregateValue = func(aggregateValue, value); + } + else { + aggregateValue = value; + } + } + if (aggregateValue === undefined) { + throw new shared_1.InvalidOperationException(shared_1.ErrorString.NoElements); + } + return aggregateValue; +}; +const aggregate2 = async (source, seed, func) => { + let aggregateValue = seed; + for await (const value of source) { + aggregateValue = func(aggregateValue, value); + } + return aggregateValue; +}; +const aggregate3 = async (source, seed, func, resultSelector) => { + let aggregateValue = seed; + for await (const value of source) { + aggregateValue = func(aggregateValue, value); + } + return resultSelector(aggregateValue); +}; + + +/***/ }), + +/***/ 81383: +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.all = void 0; +/** + * Determines whether all elements of a sequence satisfy a condition. + * @param source An AsyncIterable that contains the elements to apply the predicate to. + * @param predicate A function to test each element for a condition. + * @returns ``true`` if every element of the source sequence passes the test in the specified predicate, + * or if the sequence is empty; otherwise, ``false``. + */ +exports.all = async (source, predicate) => { + for await (const item of source) { + if (predicate(item) === false) { + return false; + } + } + return true; +}; + + +/***/ }), + +/***/ 34380: +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.allAsync = void 0; +/** + * Determines whether all elements of a sequence satisfy a condition. + * @param source An AsyncIterable that contains the elements to apply the predicate to. + * @param predicate A function to test each element for a condition. + * @returns Whether all elements of a sequence satisfy the condition. + */ +exports.allAsync = async (source, predicate) => { + for await (const item of source) { + if (await predicate(item) === false) { + return false; + } + } + return true; +}; + + +/***/ }), + +/***/ 57112: +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.any = void 0; +/** + * Determines whether a sequence contains any elements. + * If predicate is specified, determines whether any element of a sequence satisfies a condition. + * @param source The AsyncIterable to check for emptiness or apply the predicate to. + * @param predicate A function to test each element for a condition. + * @returns ``true`` if every element of the source sequence passes the test in the specified predicate, + * or if the sequence is empty; otherwise, ``false``. + */ +exports.any = (source, predicate) => { + if (predicate) { + return any2(source, predicate); + } + else { + return any1(source); + } +}; +const any1 = async (source) => { + // eslint-disable-next-line @typescript-eslint/no-unused-vars + for await (const _ of source) { + return true; + } + return false; +}; +const any2 = async (source, predicate) => { + for await (const item of source) { + if (predicate(item) === true) { + return true; + } + } + return false; +}; + + +/***/ }), + +/***/ 76897: +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.anyAsync = void 0; +/** + * Determines whether any element of a sequence satisfies a condition. + * @param source An AsyncIterable whose elements to apply the predicate to. + * @param predicate A function to test each element for a condition. + * @returns ``true`` if every element of the source sequence passes the test in the specified predicate, + * or if the sequence is empty; otherwise, ``false``. + */ +async function anyAsync(source, predicate) { + for await (const item of source) { + if (await predicate(item) === true) { + return true; + } + } + return false; +} +exports.anyAsync = anyAsync; + + +/***/ }), + +/***/ 10441: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.asParallel = void 0; +const fromParallel_1 = __nccwpck_require__(83709); +/** + * Converts an async iterable to a Parallel Enumerable. + * @param source AsyncIterable to convert to IParallelEnumerable + * @returns Parallel Enumerable of source + */ +function asParallel(source) { + async function generator() { + const data = []; + for await (const value of source) { + data.push(value); + } + return data; + } + return fromParallel_1.fromParallel(0 /* PromiseToArray */, generator); +} +exports.asParallel = asParallel; + + +/***/ }), + +/***/ 8261: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.average = void 0; +const shared_1 = __nccwpck_require__(25897); +function average(source, selector) { + if (selector) { + return average2(source, selector); + } + else { + return average1(source); + } +} +exports.average = average; +const average1 = async (source) => { + let value; + let count; + for await (const item of source) { + value = (value || 0) + item; + count = (count || 0) + 1; + } + if (value === undefined) { + throw new shared_1.InvalidOperationException(shared_1.ErrorString.NoElements); + } + return value / count; +}; +const average2 = async (source, func) => { + let value; + let count; + for await (const item of source) { + value = (value || 0) + func(item); + count = (count || 0) + 1; + } + if (value === undefined) { + throw new shared_1.InvalidOperationException(shared_1.ErrorString.NoElements); + } + return value / count; +}; + + +/***/ }), + +/***/ 71525: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.averageAsync = void 0; +const shared_1 = __nccwpck_require__(25897); +/** + * Computes the average of a sequence of values + * that are obtained by invoking an async transform function on each element of the input sequence. + * @param source A sequence of values to calculate the average of. + * @param selector A transform function to apply to each element. + * @throws {InvalidOperationException} source contains no elements. + * @returns The average value (from the selector) of the specified async sequence + */ +exports.averageAsync = async (source, selector) => { + let value; + let count; + for await (const item of source) { + value = (value || 0) + await selector(item); + count = (count || 0) + 1; + } + if (value === undefined) { + throw new shared_1.InvalidOperationException(shared_1.ErrorString.NoElements); + } + return value / count; +}; + + +/***/ }), + +/***/ 42548: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.concatenate = void 0; +const BasicAsyncEnumerable_1 = __nccwpck_require__(87563); +/** + * Concatenates two sequences. + * @param first The first sequence to concatenate. + * @param second The sequence to concatenate to the first sequence. + * @returns An IAsyncEnumerable that contains the concatenated elements of the two input sequences. + */ +function concatenate(first, second) { + async function* iterator() { + yield* first; + yield* second; + } + return new BasicAsyncEnumerable_1.BasicAsyncEnumerable(iterator); +} +exports.concatenate = concatenate; + + +/***/ }), + +/***/ 69498: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.contains = void 0; +const shared_1 = __nccwpck_require__(25897); +/** + * Determines whether a sequence contains a specified element by using the specified or default IEqualityComparer. + * @param source A sequence in which to locate a value. + * @param value The value to locate in the sequence. + * @param comparer An equality comparer to compare values. Optional. + * @returns Whether a sequence contains a specified element + */ +async function contains(source, value, comparer = shared_1.StrictEqualityComparer) { + for await (const item of source) { + if (comparer(value, item)) { + return true; + } + } + return false; +} +exports.contains = contains; + + +/***/ }), + +/***/ 16486: +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.containsAsync = void 0; +/** + * Determines whether a sequence contains a specified element by using the specified or default IEqualityComparer. + * @param source A sequence in which to locate a value. + * @param value The value to locate in the sequence. + * @param comparer An equality comparer to compare values. Optional. + * @returns Whether or not the async sequence contains the specified value + */ +exports.containsAsync = async (source, value, comparer) => { + for await (const item of source) { + if (await comparer(value, item)) { + return true; + } + } + return false; +}; + + +/***/ }), + +/***/ 71283: +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.count = void 0; +/** + * Returns the number of elements in a sequence + * or represents how many elements in the specified sequence satisfy a condition + * if the predicate is specified. + * @param source A sequence that contains elements to be counted. + * @param predicate A function to test each element for a condition. Optional. + * @returns The number of elements in the input sequence. + */ +exports.count = (source, predicate) => { + if (predicate) { + return count2(source, predicate); + } + else { + return count1(source); + } +}; +const count1 = async (source) => { + let total = 0; + // eslint-disable-next-line @typescript-eslint/no-unused-vars + for await (const _ of source) { + total++; + } + return total; +}; +const count2 = async (source, predicate) => { + let total = 0; + for await (const value of source) { + if (predicate(value) === true) { + total++; + } + } + return total; +}; + + +/***/ }), + +/***/ 44686: +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.countAsync = void 0; +/** + * Returns the number of elements in a sequence + * or represents how many elements in the specified sequence satisfy a condition + * if the predicate is specified. + * @param source A sequence that contains elements to be counted. + * @param predicate A function to test each element for a condition. Optional. + * @returns The number of elements in the sequence. + */ +exports.countAsync = async (source, predicate) => { + let count = 0; + for await (const value of source) { + if (await predicate(value) === true) { + count++; + } + } + return count; +}; + + +/***/ }), + +/***/ 81289: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.distinct = void 0; +const shared_1 = __nccwpck_require__(25897); +const BasicAsyncEnumerable_1 = __nccwpck_require__(87563); +/** + * Returns distinct elements from a sequence by using the default or specified equality comparer to compare values. + * @param source The sequence to remove duplicate elements from. + * @param comparer An IEqualityComparer to compare values. Optional. Defaults to Strict Equality Comparison. + * @returns An IAsyncEnumerable that contains distinct elements from the source sequence. + */ +function distinct(source, comparer = shared_1.StrictEqualityComparer) { + async function* iterator() { + const distinctElements = []; + for await (const item of source) { + const foundItem = distinctElements.find((x) => comparer(x, item)); + if (!foundItem) { + distinctElements.push(item); + yield item; + } + } + } + return new BasicAsyncEnumerable_1.BasicAsyncEnumerable(iterator); +} +exports.distinct = distinct; + + +/***/ }), + +/***/ 29106: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.distinctAsync = void 0; +const BasicAsyncEnumerable_1 = __nccwpck_require__(87563); +/** + * Returns distinct elements from a sequence by using the specified equality comparer to compare values. + * @param source The sequence to remove duplicate elements from. + * @param comparer An IAsyncEqualityComparer to compare values. + * @returns An IAsyncEnumerable that contains distinct elements from the source sequence. + */ +exports.distinctAsync = (source, comparer) => { + async function* iterator() { + const distinctElements = []; + outerLoop: for await (const item of source) { + for (const distinctElement of distinctElements) { + const found = await comparer(distinctElement, item); + if (found) { + continue outerLoop; + } + } + distinctElements.push(item); + yield item; + } + } + return new BasicAsyncEnumerable_1.BasicAsyncEnumerable(iterator); +}; + + +/***/ }), + +/***/ 92763: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.each = void 0; +const BasicAsyncEnumerable_1 = __nccwpck_require__(87563); +/** + * Performs a specified action on each element of the Iterable + * @param source The source to iterate + * @param action The action to take an each element + * @returns A new IAsyncEnumerable that executes the action lazily as you iterate. + */ +exports.each = (source, action) => { + async function* iterator() { + for await (const value of source) { + action(value); + yield value; + } + } + return new BasicAsyncEnumerable_1.BasicAsyncEnumerable(iterator); +}; + + +/***/ }), + +/***/ 2610: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.eachAsync = void 0; +const BasicAsyncEnumerable_1 = __nccwpck_require__(87563); +/** + * Performs a specified action on each element of the AsyncIterable + * @param source The source to iterate + * @param action The action to take an each element + * @returns A new IAsyncEnumerable that executes the action lazily as you iterate. + */ +exports.eachAsync = (source, action) => { + async function* iterator() { + for await (const value of source) { + await action(value); + yield value; + } + } + return new BasicAsyncEnumerable_1.BasicAsyncEnumerable(iterator); +}; + + +/***/ }), + +/***/ 5484: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.elementAt = void 0; +const shared_1 = __nccwpck_require__(25897); +/** + * Returns the element at a specified index in a sequence. + * @param source An IEnumerable to return an element from. + * @param index The zero-based index of the element to retrieve. + * @throws {ArgumentOutOfRangeException} + * index is less than 0 or greater than or equal to the number of elements in source. + * @returns Element at the specified index in the sequence. + */ +exports.elementAt = async (source, index) => { + if (index < 0) { + throw new shared_1.ArgumentOutOfRangeException("index"); + } + let i = 0; + for await (const item of source) { + if (index === i++) { + return item; + } + } + throw new shared_1.ArgumentOutOfRangeException("index"); +}; + + +/***/ }), + +/***/ 407: +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.elementAtOrDefault = void 0; +/** + * Returns the element at a specified index in a sequence or a default value if the index is out of range. + * @param source An IEnumerable to return an element from. + * @param index The zero-based index of the element to retrieve. + * @returns + * default(TSource) if the index is outside the bounds of the source sequence; + * otherwise, the element at the specified position in the source sequence. + */ +exports.elementAtOrDefault = async (source, index) => { + let i = 0; + for await (const item of source) { + if (index === i++) { + return item; + } + } + return null; +}; + + +/***/ }), + +/***/ 56061: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.except = void 0; +const shared_1 = __nccwpck_require__(25897); +const BasicAsyncEnumerable_1 = __nccwpck_require__(87563); +/** + * Produces the set difference of two sequences by using the comparer provided + * or EqualityComparer to compare values. + * @param first An AsyncIterable whose elements that are not also in second will be returned. + * @param second An AsyncIterable whose elements that also occur in the first sequence + * will cause those elements to be removed from the returned sequence. + * @param comparer An IEqualityComparer to compare values. Optional. + * @returns A sequence that contains the set difference of the elements of two sequences. + */ +exports.except = (first, second, comparer = shared_1.StrictEqualityComparer) => { + async function* iterator() { + // TODO: async eq of [...second] ? + const secondArray = []; + for await (const x of second) { + secondArray.push(x); + } + for await (const firstItem of first) { + let exists = false; + for (let j = 0; j < secondArray.length; j++) { + const secondItem = secondArray[j]; + if (comparer(firstItem, secondItem) === true) { + exists = true; + break; + } + } + if (exists === false) { + yield firstItem; + } + } + } + return new BasicAsyncEnumerable_1.BasicAsyncEnumerable(iterator); +}; + + +/***/ }), + +/***/ 56349: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.exceptAsync = void 0; +const BasicAsyncEnumerable_1 = __nccwpck_require__(87563); +/** + * Produces the set difference of two sequences by using the comparer provided to compare values. + * @param first An AsyncIterable whose elements that are not also in second will be returned. + * @param second An AsyncIterable whose elements that also occur in the first sequence + * will cause those elements to be removed from the returned sequence. + * @param comparer An IAsyncEqualityComparer to compare values. + * @returns A sequence that contains the set difference of the elements of two sequences. + */ +function exceptAsync(first, second, comparer) { + async function* iterator() { + // TODO: async eq of [...second] ? + const secondArray = []; + for await (const x of second) { + secondArray.push(x); + } + for await (const firstItem of first) { + let exists = false; + for (let j = 0; j < secondArray.length; j++) { + const secondItem = secondArray[j]; + if (await comparer(firstItem, secondItem) === true) { + exists = true; + break; + } + } + if (exists === false) { + yield firstItem; + } + } + } + return new BasicAsyncEnumerable_1.BasicAsyncEnumerable(iterator); +} +exports.exceptAsync = exceptAsync; + + +/***/ }), + +/***/ 18281: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.first = void 0; +const shared_1 = __nccwpck_require__(25897); +/** + * Returns the first element of a sequence. + * If predicate is specified, returns the first element in a sequence that satisfies a specified condition. + * @param source The AsyncIterable to return the first element of. + * @param predicate A function to test each element for a condition. Optional. + * @throws {InvalidOperationException} The source sequence is empty. + * @returns The first element in the specified sequence. + * If predicate is specified, + * the first element in the sequence that passes the test in the specified predicate function. + */ +exports.first = (source, predicate) => { + if (predicate) { + return first2(source, predicate); + } + else { + return first1(source); + } +}; +const first1 = async (source) => { + const firstElement = await source[Symbol.asyncIterator]().next(); + if (firstElement.done === true) { + throw new shared_1.InvalidOperationException(shared_1.ErrorString.NoElements); + } + return firstElement.value; +}; +const first2 = async (source, predicate) => { + for await (const value of source) { + if (predicate(value) === true) { + return value; + } + } + throw new shared_1.InvalidOperationException(shared_1.ErrorString.NoMatch); +}; + + +/***/ }), + +/***/ 96322: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.firstAsync = void 0; +const shared_1 = __nccwpck_require__(25897); +/** + * Returns the first element in a sequence that satisfies a specified condition. + * @param source An AsyncIterable to return an element from. + * @param predicate An async function to test each element for a condition. + * @throws {InvalidOperationException} No elements in Iteration matching predicate + * @returns The first element in the sequence that passes the test in the specified predicate function. + */ +async function firstAsync(source, predicate) { + for await (const value of source) { + if (await predicate(value) === true) { + return value; + } + } + throw new shared_1.InvalidOperationException(shared_1.ErrorString.NoMatch); +} +exports.firstAsync = firstAsync; + + +/***/ }), + +/***/ 40886: +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.firstOrDefault = void 0; +/** + * Returns first element in sequence that satisfies predicate otherwise + * returns the first element in the sequence. Returns null if no value found. + * @param source An AsyncIterable to return an element from. + * @param predicate A function to test each element for a condition. Optional. + * @returns The first element in the sequence + * or the first element that passes the test in the specified predicate function. + * Returns null if no value found. + */ +function firstOrDefault(source, predicate) { + if (predicate) { + return firstOrDefault2(source, predicate); + } + else { + // eslint-disable-next-line @typescript-eslint/no-unsafe-return + return firstOrDefault1(source); + } +} +exports.firstOrDefault = firstOrDefault; +const firstOrDefault1 = async (source) => { + const first = await source[Symbol.asyncIterator]().next(); + // eslint-disable-next-line @typescript-eslint/no-unsafe-return + return first.value || null; +}; +const firstOrDefault2 = async (source, predicate) => { + for await (const value of source) { + if (predicate(value) === true) { + return value; + } + } + return null; +}; + + +/***/ }), + +/***/ 92619: +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.firstOrDefaultAsync = void 0; +/** + * Returns first element in sequence that satisfies. Returns null if no value found. + * @param source An AsyncIterable to return an element from. + * @param predicate An async function to test each element for a condition. + * @returns The first element that passes the test in the specified predicate function. + * Returns null if no value found. + */ +async function firstOrDefaultAsync(source, predicate) { + for await (const value of source) { + if (await predicate(value) === true) { + return value; + } + } + return null; +} +exports.firstOrDefaultAsync = firstOrDefaultAsync; + + +/***/ }), + +/***/ 76617: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.groupBy = void 0; +const Grouping_1 = __nccwpck_require__(20891); +const BasicAsyncEnumerable_1 = __nccwpck_require__(87563); +function groupBy(source, keySelector, comparer) { + if (comparer) { + return groupBy_0(source, keySelector, comparer); + } + else { + // eslint-disable-next-line @typescript-eslint/no-unsafe-return + return groupBy_0_Simple(source, keySelector); + } +} +exports.groupBy = groupBy; +function groupBy_0(source, keySelector, comparer) { + async function* generate() { + const keyMap = new Array(); + for await (const value of source) { + const key = keySelector(value); + let found = false; + for (let i = 0; i < keyMap.length; i++) { + const group = keyMap[i]; + if (comparer(group.key, key)) { + group.push(value); + found = true; + break; + } + } + if (found === false) { + keyMap.push(new Grouping_1.Grouping(key, value)); // TODO + } + } + for (const g of keyMap) { + yield g; + } + } + return new BasicAsyncEnumerable_1.BasicAsyncEnumerable(generate); +} +function groupBy_0_Simple(source, keySelector) { + async function* iterator() { + const keyMap = {}; + for await (const value of source) { + const key = keySelector(value); + const grouping = keyMap[key]; + if (grouping) { + grouping.push(value); + } + else { + keyMap[key] = new Grouping_1.Grouping(key, value); + } + } + // eslint-disable-next-line guard-for-in + for (const value in keyMap) { + yield keyMap[value]; + } + } + return new BasicAsyncEnumerable_1.BasicAsyncEnumerable(iterator); +} + + +/***/ }), + +/***/ 34376: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.groupByAsync = void 0; +const Grouping_1 = __nccwpck_require__(20891); +const BasicAsyncEnumerable_1 = __nccwpck_require__(87563); +function groupByAsync(source, keySelector, comparer) { + if (comparer) { + return groupByAsync_0(source, keySelector, comparer); + } + else { + // eslint-disable-next-line @typescript-eslint/no-unsafe-return + return groupByAsync_0_Simple(source, keySelector); + } +} +exports.groupByAsync = groupByAsync; +function groupByAsync_0_Simple(source, keySelector) { + async function* iterator() { + const keyMap = {}; // TODO + for await (const value of source) { + const key = await keySelector(value); + const grouping = keyMap[key]; + if (grouping) { + grouping.push(value); + } + else { + keyMap[key] = new Grouping_1.Grouping(key, value); + } + } + // eslint-disable-next-line guard-for-in + for (const value in keyMap) { + yield keyMap[value]; + } + } + return new BasicAsyncEnumerable_1.BasicAsyncEnumerable(iterator); +} +function groupByAsync_0(source, keySelector, comparer) { + async function* generate() { + const keyMap = new Array(); + for await (const value of source) { + const key = await keySelector(value); + let found = false; + for (let i = 0; i < keyMap.length; i++) { + const group = keyMap[i]; + if (await comparer(group.key, key) === true) { + group.push(value); + found = true; + break; + } + } + if (found === false) { + keyMap.push(new Grouping_1.Grouping(key, value)); + } + } + for (const keyValue of keyMap) { + yield keyValue; + } + } + return new BasicAsyncEnumerable_1.BasicAsyncEnumerable(generate); +} + + +/***/ }), + +/***/ 88207: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.groupByWithSel = void 0; +const Grouping_1 = __nccwpck_require__(20891); +const BasicAsyncEnumerable_1 = __nccwpck_require__(87563); +function groupByWithSel(source, keySelector, elementSelector, comparer) { + if (comparer) { + return groupBy1(source, keySelector, elementSelector, comparer); + } + else { + return groupBy1Simple(source, keySelector, elementSelector); + } +} +exports.groupByWithSel = groupByWithSel; +const groupBy1Simple = (source, keySelector, elementSelector) => { + async function* generate() { + const keyMap = {}; + for await (const value of source) { + const key = keySelector(value); + const grouping = keyMap[key]; + const element = elementSelector(value); + if (grouping) { + grouping.push(element); + } + else { + keyMap[key] = new Grouping_1.Grouping(key, element); + } + } + // eslint-disable-next-line guard-for-in + for (const value in keyMap) { + yield keyMap[value]; + } + } + return new BasicAsyncEnumerable_1.BasicAsyncEnumerable(generate); +}; +const groupBy1 = (source, keySelector, elementSelector, comparer) => { + async function* generate() { + const keyMap = new Array(); + for await (const value of source) { + const key = keySelector(value); + let found = false; + for (let i = 0; i < keyMap.length; i++) { + const group = keyMap[i]; + if (comparer(group.key, key)) { + group.push(elementSelector(value)); + found = true; + break; + } + } + if (found === false) { + const element = elementSelector(value); + keyMap.push(new Grouping_1.Grouping(key, element)); // TODO + } + } + for (const value of keyMap) { + yield value; + } + } + return new BasicAsyncEnumerable_1.BasicAsyncEnumerable(generate); +}; + + +/***/ }), + +/***/ 67728: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.intersect = void 0; +const shared_1 = __nccwpck_require__(25897); +const BasicAsyncEnumerable_1 = __nccwpck_require__(87563); +/** + * Produces the set intersection of two sequences by using the specified IEqualityComparer to compare values. + * If not comparer is specified, uses the @see {StrictEqualityComparer} + * @param first An IAsyncEnumerable whose distinct elements that also appear in second will be returned. + * @param second An IAsyncEnumerable whose distinct elements that also appear in the first sequence will be returned. + * @param comparer An IAsyncEqualityComparer to compare values. Optional. + * @returns A sequence that contains the elements that form the set intersection of two sequences. + */ +function intersect(first, second, comparer = shared_1.StrictEqualityComparer) { + async function* iterator() { + const firstResults = await first.distinct(comparer).toArray(); + if (firstResults.length === 0) { + return; + } + const secondResults = await second.toArray(); + for (let i = 0; i < firstResults.length; i++) { + const firstValue = firstResults[i]; + for (let j = 0; j < secondResults.length; j++) { + const secondValue = secondResults[j]; + if (comparer(firstValue, secondValue) === true) { + yield firstValue; + break; + } + } + } + } + return new BasicAsyncEnumerable_1.BasicAsyncEnumerable(iterator); +} +exports.intersect = intersect; + + +/***/ }), + +/***/ 41736: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.intersectAsync = void 0; +const BasicAsyncEnumerable_1 = __nccwpck_require__(87563); +/** + * Produces the set intersection of two sequences by using the specified IAsyncEqualityComparer to compare values. + * @param first An IAsyncEnumerable whose distinct elements that also appear in second will be returned. + * @param second An IAsyncEnumerable whose distinct elements that also appear in the first sequence will be returned. + * @param comparer An IAsyncEqualityComparer to compare values. + * @returns A sequence that contains the elements that form the set intersection of two sequences. + */ +function intersectAsync(first, second, comparer) { + async function* iterator() { + const firstResults = await first.distinctAsync(comparer).toArray(); + if (firstResults.length === 0) { + return; + } + const secondResults = await second.toArray(); + for (let i = 0; i < firstResults.length; i++) { + const firstValue = firstResults[i]; + for (let j = 0; j < secondResults.length; j++) { + const secondValue = secondResults[j]; + if (await comparer(firstValue, secondValue) === true) { + yield firstValue; + break; + } + } + } + } + return new BasicAsyncEnumerable_1.BasicAsyncEnumerable(iterator); +} +exports.intersectAsync = intersectAsync; + + +/***/ }), + +/***/ 10165: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.join = void 0; +const shared_1 = __nccwpck_require__(25897); +const BasicAsyncEnumerable_1 = __nccwpck_require__(87563); +/** + * Correlates the elements of two sequences based on matching keys. + * A specified IEqualityComparer is used to compare keys or the strict equality comparer. + * @param outer The first sequence to join. + * @param inner The sequence to join to the first sequence. + * @param outerKeySelector A function to extract the join key from each element of the first sequence. + * @param innerKeySelector A function to extract the join key from each element of the second sequence. + * @param resultSelector A function to create a result element from two matching elements. + * @param comparer An IEqualityComparer to hash and compare keys. Optional. + * @returns An IAsyncEnumerable that has elements of type TResult that + * are obtained by performing an inner join on two sequences. + */ +function join(outer, inner, outerKeySelector, innerKeySelector, resultSelector, comparer = shared_1.StrictEqualityComparer) { + async function* iterator() { + const innerArray = []; + for await (const i of inner) { + innerArray.push(i); + } + for await (const o of outer) { + const outerKey = outerKeySelector(o); + for (const i of innerArray) { + const innerKey = innerKeySelector(i); + if (comparer(outerKey, innerKey) === true) { + yield resultSelector(o, i); + } + } + } + } + return new BasicAsyncEnumerable_1.BasicAsyncEnumerable(iterator); +} +exports.join = join; + + +/***/ }), + +/***/ 33700: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.last = void 0; +const shared_1 = __nccwpck_require__(25897); +/** + * Returns the last element of a sequence. + * If predicate is specified, the last element of a sequence that satisfies a specified condition. + * @param source An AsyncIterable to return the last element of. + * @param predicate A function to test each element for a condition. Optional. + * @throws {InvalidOperationException} The source sequence is empty. + * @returns The value at the last position in the source sequence + * or the last element in the sequence that passes the test in the specified predicate function. + */ +async function last(source, predicate) { + if (predicate) { + return last2(source, predicate); + } + else { + return last1(source); + } +} +exports.last = last; +const last1 = async (source) => { + let lastItem = null; + for await (const value of source) { + lastItem = value; + } + if (!lastItem) { + throw new shared_1.InvalidOperationException(shared_1.ErrorString.NoElements); + } + return lastItem; +}; +const last2 = async (source, predicate) => { + let lastItem = null; + for await (const value of source) { + if (predicate(value) === true) { + lastItem = value; + } + } + if (!lastItem) { + throw new shared_1.InvalidOperationException(shared_1.ErrorString.NoMatch); + } + return lastItem; +}; + + +/***/ }), + +/***/ 47543: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.lastAsync = void 0; +const shared_1 = __nccwpck_require__(25897); +/** + * Returns the last element of a sequence that satisfies a specified condition. + * @param source An AsyncIterable to return the last element of. + * @param predicate A function to test each element for a condition. + * @throws {InvalidOperationException} The source sequence is empty. + * @returns The last element in the sequence that passes the test in the specified predicate function. + */ +async function lastAsync(source, predicate) { + let last = null; + for await (const value of source) { + if (await predicate(value) === true) { + last = value; + } + } + if (!last) { + throw new shared_1.InvalidOperationException(shared_1.ErrorString.NoMatch); + } + return last; +} +exports.lastAsync = lastAsync; + + +/***/ }), + +/***/ 22424: +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.lastOrDefault = void 0; +/** + * Returns the last element of a sequence. + * If predicate is specified, the last element of a sequence that satisfies a specified condition. + * @param source An AsyncIterable to return the last element of. + * @param predicate A function to test each element for a condition. Optional. + * @returns The value at the last position in the source sequence + * or the last element in the sequence that passes the test in the specified predicate function. + */ +async function lastOrDefault(source, predicate) { + if (predicate) { + return lastOrDefault2(source, predicate); + } + else { + return lastOrDefault1(source); + } +} +exports.lastOrDefault = lastOrDefault; +const lastOrDefault1 = async (source) => { + let last = null; + for await (const value of source) { + last = value; + } + return last; +}; +const lastOrDefault2 = async (source, predicate) => { + let last = null; + for await (const value of source) { + if (predicate(value) === true) { + last = value; + } + } + return last; +}; + + +/***/ }), + +/***/ 12667: +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.lastOrDefaultAsync = void 0; +/** + * Returns the last element of a sequence that satisfies a specified condition. + * @param source An AsyncIterable to return the last element of. + * @param predicate A function to test each element for a condition. + * @returns The last element in the sequence that passes the test in the specified predicate function. + * Null if no elements. + */ +async function lastOrDefaultAsync(source, predicate) { + let last = null; + for await (const value of source) { + if (await predicate(value) === true) { + last = value; + } + } + return last; +} +exports.lastOrDefaultAsync = lastOrDefaultAsync; + + +/***/ }), + +/***/ 85338: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.max = void 0; +const shared_1 = __nccwpck_require__(25897); +function max(source, selector) { + if (selector) { + return max2(source, selector); + } + else { + return max1(source); + } +} +exports.max = max; +const max1 = async (source) => { + let maxItem = null; + for await (const item of source) { + maxItem = Math.max(maxItem || Number.NEGATIVE_INFINITY, item); + } + if (maxItem === null) { + throw new shared_1.InvalidOperationException(shared_1.ErrorString.NoElements); + } + else { + return maxItem; + } +}; +const max2 = async (source, selector) => { + let maxItem = null; + for await (const item of source) { + maxItem = Math.max(maxItem || Number.NEGATIVE_INFINITY, selector(item)); + } + if (maxItem === null) { + throw new shared_1.InvalidOperationException(shared_1.ErrorString.NoElements); + } + else { + return maxItem; + } +}; + + +/***/ }), + +/***/ 71705: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.maxAsync = void 0; +const shared_1 = __nccwpck_require__(25897); +/** + * Invokes an async transform function on each element of a sequence and returns the maximum value. + * @param source A sequence of values to determine the maximum value of. + * @param selector A transform function to apply to each element. + * @throws {InvalidOperationException} source contains no elements. + * @returns The maximum value in the sequence. + */ +async function maxAsync(source, selector) { + let max = null; + for await (const item of source) { + max = Math.max(max || Number.NEGATIVE_INFINITY, await selector(item)); + } + if (max === null) { + throw new shared_1.InvalidOperationException(shared_1.ErrorString.NoElements); + } + else { + return max; + } +} +exports.maxAsync = maxAsync; + + +/***/ }), + +/***/ 32380: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.min = void 0; +const shared_1 = __nccwpck_require__(25897); +function min(source, selector) { + if (selector) { + return min2(source, selector); + } + else { + return min1(source); + } +} +exports.min = min; +const min1 = async (source) => { + let minValue = null; + for await (const item of source) { + minValue = Math.min(minValue || Number.POSITIVE_INFINITY, item); + } + if (minValue === null) { + throw new shared_1.InvalidOperationException(shared_1.ErrorString.NoElements); + } + else { + return minValue; + } +}; +const min2 = async (source, selector) => { + let minValue = null; + for await (const item of source) { + minValue = Math.min(minValue || Number.POSITIVE_INFINITY, selector(item)); + } + if (minValue === null) { + throw new shared_1.InvalidOperationException(shared_1.ErrorString.NoElements); + } + else { + return minValue; + } +}; + + +/***/ }), + +/***/ 24916: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.minAsync = void 0; +const shared_1 = __nccwpck_require__(25897); +/** + * Invokes a transform function on each element of a sequence and returns the minimum value. + * @param source A sequence of values to determine the minimum value of. + * @param selector A transform function to apply to each element. + * @throws {InvalidOperationException} source contains no elements. + * @returns The minimum value in the sequence. + */ +async function minAsync(source, selector) { + let min = null; + for await (const item of source) { + min = Math.min(min || Number.POSITIVE_INFINITY, await selector(item)); + } + if (min === null) { + throw new shared_1.InvalidOperationException(shared_1.ErrorString.NoElements); + } + else { + return min; + } +} +exports.minAsync = minAsync; + + +/***/ }), + +/***/ 66592: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.ofType = void 0; +const BasicAsyncEnumerable_1 = __nccwpck_require__(87563); +/** + * Applies a type filter to a source iteration + * @param source Async Iteration to Filtery by Type + * @param type Either value for typeof or a consturctor function + * @returns Values that match the type string or are instance of type + */ +function ofType(source, type) { + const typeCheck = typeof type === "string" ? + ((x) => typeof x === type) : + ((x) => x instanceof type); + async function* iterator() { + for await (const item of source) { + if (typeCheck(item)) { + yield item; + } + } + } + return new BasicAsyncEnumerable_1.BasicAsyncEnumerable(iterator); +} +exports.ofType = ofType; + + +/***/ }), + +/***/ 11526: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.orderBy = void 0; +const OrderedAsyncEnumerable_1 = __nccwpck_require__(42485); +/** + * Sorts the elements of a sequence in ascending order by using a specified or default comparer. + * @param source A sequence of values to order. + * @param keySelector A function to extract a key from an element. + * @param comparer An IComparer to compare keys. Optional. + * @returns An IOrderedAsyncEnumerable whose elements are sorted according to a key. + */ +function orderBy(source, keySelector, comparer) { + return OrderedAsyncEnumerable_1.OrderedAsyncEnumerable.generate(source, keySelector, true, comparer); +} +exports.orderBy = orderBy; + + +/***/ }), + +/***/ 74392: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.orderByAsync = void 0; +const OrderedAsyncEnumerable_1 = __nccwpck_require__(42485); +/** + * Sorts the elements of a sequence in ascending order by using a specified comparer. + * @param source A sequence of values to order. + * @param keySelector An async function to extract a key from an element. + * @param comparer An IComparer to compare keys. + * @returns An IOrderedAsyncEnumerable whose elements are sorted according to a key. + */ +function orderByAsync(source, keySelector, comparer) { + return OrderedAsyncEnumerable_1.OrderedAsyncEnumerable.generateAsync(source, keySelector, true, comparer); +} +exports.orderByAsync = orderByAsync; + + +/***/ }), + +/***/ 98610: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.orderByDescending = void 0; +const OrderedAsyncEnumerable_1 = __nccwpck_require__(42485); +/** + * Sorts the elements of a sequence in descending order by using a specified or default comparer. + * @param source A sequence of values to order. + * @param keySelector A function to extract a key from an element. + * @param comparer An IComparer to compare keys. Optional. + * @returns An IOrderedAsyncEnumerable whose elements are sorted in descending order according to a key. + */ +function orderByDescending(source, keySelector, comparer) { + return OrderedAsyncEnumerable_1.OrderedAsyncEnumerable.generate(source, keySelector, false, comparer); +} +exports.orderByDescending = orderByDescending; + + +/***/ }), + +/***/ 84310: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.orderByDescendingAsync = void 0; +const OrderedAsyncEnumerable_1 = __nccwpck_require__(42485); +/** + * Sorts the elements of an async sequence in descending order by using a specified comparer. + * @param source A sequence of values to order. + * @param keySelector An async function to extract a key from an element. + * @param comparer An IComparer to compare keys. + * @returns An IOrderedAsyncEnumerable whose elements are sorted in descending order according to a key. + */ +function orderByDescendingAsync(source, keySelector, comparer) { + return OrderedAsyncEnumerable_1.OrderedAsyncEnumerable.generateAsync(source, keySelector, false, comparer); +} +exports.orderByDescendingAsync = orderByDescendingAsync; + + +/***/ }), + +/***/ 79158: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.reverse = void 0; +const BasicAsyncEnumerable_1 = __nccwpck_require__(87563); +/** + * Inverts the order of the elements in a sequence. + * @param source A sequence of values to reverse. + * @returns A sequence whose elements correspond to those of the input sequence in reverse order. + */ +function reverse(source) { + async function* iterator() { + const values = []; + for await (const value of source) { + values.push(value); + } + for (let i = values.length - 1; i >= 0; i--) { + yield values[i]; + } + } + return new BasicAsyncEnumerable_1.BasicAsyncEnumerable(iterator); +} +exports.reverse = reverse; + + +/***/ }), + +/***/ 24187: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.select = void 0; +const BasicAsyncEnumerable_1 = __nccwpck_require__(87563); +function select(source, selector) { + if (typeof selector === "function") { + if (selector.length === 1) { + return select1(source, selector); + } + else { + return select2(source, selector); + } + } + else { + return select3(source, selector); + } +} +exports.select = select; +const select1 = (source, selector) => { + async function* iterator() { + for await (const value of source) { + yield selector(value); + } + } + return new BasicAsyncEnumerable_1.BasicAsyncEnumerable(iterator); +}; +const select2 = (source, selector) => { + async function* iterator() { + let index = 0; + for await (const value of source) { + yield selector(value, index); + index++; + } + } + return new BasicAsyncEnumerable_1.BasicAsyncEnumerable(iterator); +}; +const select3 = (source, key) => { + async function* iterator() { + for await (const value of source) { + yield value[key]; + } + } + return new BasicAsyncEnumerable_1.BasicAsyncEnumerable(iterator); +}; + + +/***/ }), + +/***/ 68786: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.selectAsync = void 0; +const BasicAsyncEnumerable_1 = __nccwpck_require__(87563); +function selectAsync(source, selector) { + if (typeof selector === "string") { + // eslint-disable-next-line @typescript-eslint/no-unsafe-return + return selectAsync2(source, selector); + } + else { + return selectAsync1(source, selector); + } +} +exports.selectAsync = selectAsync; +const selectAsync1 = (source, selector) => { + async function* iterator() { + for await (const value of source) { + yield selector(value); + } + } + return new BasicAsyncEnumerable_1.BasicAsyncEnumerable(iterator); +}; +const selectAsync2 = (source, key) => { + async function* iterator() { + for await (const value of source) { + yield value[key]; + } + } + return new BasicAsyncEnumerable_1.BasicAsyncEnumerable(iterator); +}; + + +/***/ }), + +/***/ 70165: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.selectMany = void 0; +const BasicAsyncEnumerable_1 = __nccwpck_require__(87563); +function selectMany(source, selector) { + if (typeof selector === "function") { + // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access + if (selector.length === 1) { + return selectMany1(source, selector); + } + else { + return selectMany2(source, selector); + } + } + else { + return selectMany3(source, selector); + } +} +exports.selectMany = selectMany; +const selectMany1 = (source, selector) => { + async function* iterator() { + for await (const value of source) { + for (const selectorValue of selector(value)) { + yield selectorValue; + } + } + } + return new BasicAsyncEnumerable_1.BasicAsyncEnumerable(iterator); +}; +const selectMany2 = (source, selector) => { + async function* iterator() { + let index = 0; + for await (const value of source) { + for (const selectorValue of selector(value, index)) { + yield selectorValue; + } + index++; + } + } + return new BasicAsyncEnumerable_1.BasicAsyncEnumerable(iterator); +}; +const selectMany3 = (source, selector) => { + async function* iterator() { + for await (const value of source) { + for (const selectorValue of value[selector]) { + yield selectorValue; + } + } + } + return new BasicAsyncEnumerable_1.BasicAsyncEnumerable(iterator); +}; + + +/***/ }), + +/***/ 52627: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.selectManyAsync = void 0; +const BasicAsyncEnumerable_1 = __nccwpck_require__(87563); +/** + * Projects each element of a sequence to an IAsyncEnumerable and flattens the resulting sequences into one sequence. + * @param source A sequence of values to project. + * @param selector A transform function to apply to each element. + * @returns An IAsyncEnumerable whose elements are the result of invoking the + * one-to-many transform function on each element of the input sequence. + */ +function selectManyAsync(source, selector) { + if (selector.length === 1) { + const iterator = async function* () { + for await (const value of source) { + const many = await selector(value); + for (const innerValue of many) { + yield innerValue; + } + } + }; + return new BasicAsyncEnumerable_1.BasicAsyncEnumerable(iterator); + } + else { + const iterator = async function* () { + let index = 0; + for await (const value of source) { + const many = await selector(value, index); + for (const innerValue of many) { + yield innerValue; + } + index++; + } + }; + return new BasicAsyncEnumerable_1.BasicAsyncEnumerable(iterator); + } +} +exports.selectManyAsync = selectManyAsync; + + +/***/ }), + +/***/ 87058: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.sequenceEquals = void 0; +const shared_1 = __nccwpck_require__(25897); +/** + * Compares two async iterations to see if they are equal using a comparer function. + * @param first First Sequence + * @param second Second Sequence + * @param comparer Comparer + * @returns Whether or not the two iterations are equal + */ +async function sequenceEquals(first, second, comparer = shared_1.StrictEqualityComparer) { + const firstIterator = first[Symbol.asyncIterator](); + const secondIterator = second[Symbol.asyncIterator](); + let results = await Promise.all([firstIterator.next(), secondIterator.next()]); + let firstResult = results[0]; + let secondResult = results[1]; + while (!firstResult.done && !secondResult.done) { + if (!comparer(firstResult.value, secondResult.value)) { + return false; + } + results = await Promise.all([firstIterator.next(), secondIterator.next()]); + firstResult = results[0]; + secondResult = results[1]; + } + return firstResult.done === true && secondResult.done === true; +} +exports.sequenceEquals = sequenceEquals; + + +/***/ }), + +/***/ 38488: +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.sequenceEqualsAsync = void 0; +/** + * Compares two async iterables to see if they are equal using a async comparer function. + * @param first First Sequence + * @param second Second Sequence + * @param comparer Async Comparer + * @returns Whether or not the two iterations are equal + */ +async function sequenceEqualsAsync(first, second, comparer) { + const firstIterator = first[Symbol.asyncIterator](); + const secondIterator = second[Symbol.asyncIterator](); + let results = await Promise.all([firstIterator.next(), secondIterator.next()]); + let firstResult = results[0]; + let secondResult = results[1]; + while (!firstResult.done && !secondResult.done) { + if (await comparer(firstResult.value, secondResult.value) === false) { + return false; + } + results = await Promise.all([firstIterator.next(), secondIterator.next()]); + firstResult = results[0]; + secondResult = results[1]; + } + return firstResult.done === true && secondResult.done === true; +} +exports.sequenceEqualsAsync = sequenceEqualsAsync; + + +/***/ }), + +/***/ 21430: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.single = void 0; +const shared_1 = __nccwpck_require__(25897); +/** + * Returns the only element of a sequence that satisfies a specified condition (if specified), + * and throws an exception if more than one such element exists. + * @param source An AsyncIterable to return a single element from. + * @param predicate A function to test an element for a condition. (Optional) + * @throws {InvalidOperationException} No element satisfies the condition in predicate. OR + * More than one element satisfies the condition in predicate. OR + * The source sequence is empty. + * @returns The single element of the input sequence that satisfies a condition. + */ +function single(source, predicate) { + if (predicate) { + return single2(source, predicate); + } + else { + return single1(source); + } +} +exports.single = single; +const single1 = async (source) => { + let hasValue = false; + let singleValue = null; + for await (const value of source) { + if (hasValue === true) { + throw new shared_1.InvalidOperationException(shared_1.ErrorString.MoreThanOneElement); + } + else { + hasValue = true; + singleValue = value; + } + } + if (hasValue === false) { + throw new shared_1.InvalidOperationException(shared_1.ErrorString.NoElements); + } + return singleValue; +}; +const single2 = async (source, predicate) => { + let hasValue = false; + let singleValue = null; + for await (const value of source) { + if (predicate(value)) { + if (hasValue === true) { + throw new shared_1.InvalidOperationException(shared_1.ErrorString.MoreThanOneMatchingElement); + } + else { + hasValue = true; + singleValue = value; + } + } + } + if (hasValue === false) { + throw new shared_1.InvalidOperationException(shared_1.ErrorString.NoMatch); + } + return singleValue; +}; + + +/***/ }), + +/***/ 94572: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.singleAsync = void 0; +const shared_1 = __nccwpck_require__(25897); +/** + * Returns the only element of a sequence that satisfies a specified condition, + * and throws an exception if more than one such element exists. + * @param source An AsyncIterable to return a single element from. + * @param predicate A function to test an element for a condition. + * @throws {InvalidOperationException} + * No element satisfies the condition in predicate. OR + * More than one element satisfies the condition in predicate. OR + * The source sequence is empty. + * @returns The single element of the input sequence that satisfies a condition. + */ +async function singleAsync(source, predicate) { + let hasValue = false; + let singleValue = null; + for await (const value of source) { + if (await predicate(value)) { + if (hasValue === true) { + throw new shared_1.InvalidOperationException(shared_1.ErrorString.MoreThanOneMatchingElement); + } + else { + hasValue = true; + singleValue = value; + } + } + } + if (hasValue === false) { + throw new shared_1.InvalidOperationException(shared_1.ErrorString.NoMatch); + } + return singleValue; +} +exports.singleAsync = singleAsync; + + +/***/ }), + +/***/ 45053: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.singleOrDefault = void 0; +const shared_1 = __nccwpck_require__(25897); +/** + * If predicate is specified returns the only element of a sequence that satisfies a specified condition, + * ootherwise returns the only element of a sequence. Returns a default value if no such element exists. + * @param source An AsyncIterable to return a single element from. + * @param predicate A function to test an element for a condition. Optional. + * @throws {InvalidOperationException} + * If predicate is specified more than one element satisfies the condition in predicate, + * otherwise the input sequence contains more than one element. + * @returns The single element of the input sequence that satisfies the condition, + * or null if no such element is found. + */ +function singleOrDefault(source, predicate) { + if (predicate) { + return singleOrDefault2(source, predicate); + } + else { + return singleOrDefault1(source); + } +} +exports.singleOrDefault = singleOrDefault; +const singleOrDefault1 = async (source) => { + let hasValue = false; + let singleValue = null; + for await (const value of source) { + if (hasValue === true) { + throw new shared_1.InvalidOperationException(shared_1.ErrorString.MoreThanOneElement); + } + else { + hasValue = true; + singleValue = value; + } + } + return singleValue; +}; +const singleOrDefault2 = async (source, predicate) => { + let hasValue = false; + let singleValue = null; + for await (const value of source) { + if (predicate(value)) { + if (hasValue === true) { + throw new shared_1.InvalidOperationException(shared_1.ErrorString.MoreThanOneMatchingElement); + } + else { + hasValue = true; + singleValue = value; + } + } + } + return singleValue; +}; + + +/***/ }), + +/***/ 36031: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.singleOrDefaultAsync = void 0; +const shared_1 = __nccwpck_require__(25897); +/** + * Returns the only element of a sequence that satisfies a specified condition. + * Returns a default value if no such element exists. + * @param source An AsyncIterable to return a single element from. + * @param predicate A function to test an element for a condition. Optional. + * @throws {InvalidOperationException} + * If predicate is specified more than one element satisfies the condition in predicate, + * otherwise the input sequence contains more than one element. + * @returns The single element of the input sequence that satisfies the condition, + * or null if no such element is found. + */ +async function singleOrDefaultAsync(source, predicate) { + let hasValue = false; + let singleValue = null; + for await (const value of source) { + if (await predicate(value)) { + if (hasValue === true) { + throw new shared_1.InvalidOperationException(shared_1.ErrorString.MoreThanOneMatchingElement); + } + else { + hasValue = true; + singleValue = value; + } + } + } + return singleValue; +} +exports.singleOrDefaultAsync = singleOrDefaultAsync; + + +/***/ }), + +/***/ 94114: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.skip = void 0; +const BasicAsyncEnumerable_1 = __nccwpck_require__(87563); +/** + * Bypasses a specified number of elements in a sequence and then returns the remaining elements. + * @param source An AsyncIterable to return elements from. + * @param count The number of elements to skip before returning the remaining elements. + * @returns + * An IAsyncEnumerable that contains the elements that occur after the specified index in the input sequence. + */ +function skip(source, count) { + async function* iterator() { + let i = 0; + for await (const item of source) { + if (i++ >= count) { + yield item; + } + } + } + return new BasicAsyncEnumerable_1.BasicAsyncEnumerable(iterator); +} +exports.skip = skip; + + +/***/ }), + +/***/ 45477: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.skipWhile = void 0; +const BasicAsyncEnumerable_1 = __nccwpck_require__(87563); +/** + * Bypasses elements in a sequence as long as a specified condition is true and then returns the remaining elements. + * The element's index is used in the logic of the predicate function. + * @param source An AsyncIterable to return elements from. + * @param predicate A function to test each source element for a condition; + * the second parameter of the function represents the index of the source element. + * @returns An IAsyncEnumerable that contains the elements from the input sequence starting at the first element + * in the linear series that does not pass the test specified by predicate. + */ +function skipWhile(source, predicate) { + if (predicate.length === 1) { + return skipWhile1(source, predicate); + } + else { + return skipWhile2(source, predicate); + } +} +exports.skipWhile = skipWhile; +const skipWhile1 = (source, predicate) => { + async function* iterator() { + let skip = true; + for await (const item of source) { + if (skip === false) { + yield item; + } + else if (predicate(item) === false) { + skip = false; + yield item; + } + } + } + return new BasicAsyncEnumerable_1.BasicAsyncEnumerable(iterator); +}; +const skipWhile2 = (source, predicate) => { + async function* iterator() { + let index = 0; + let skip = true; + for await (const item of source) { + if (skip === false) { + yield item; + } + else if (predicate(item, index) === false) { + skip = false; + yield item; + } + index++; + } + } + return new BasicAsyncEnumerable_1.BasicAsyncEnumerable(iterator); +}; + + +/***/ }), + +/***/ 5706: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.skipWhileAsync = void 0; +const BasicAsyncEnumerable_1 = __nccwpck_require__(87563); +/** + * Bypasses elements in a sequence as long as a specified condition is true and then returns the remaining elements. + * The element's index is used in the logic of the predicate function. + * @param source An AsyncIterable to return elements from. + * @param predicate A function to test each source element for a condition; + * the second parameter of the function represents the index of the source element. + * @returns An IAsyncEnumerable that contains the elements from the input sequence starting + * at the first element in the linear series that does not pass the test specified by predicate. + */ +function skipWhileAsync(source, predicate) { + if (predicate.length === 1) { + return skipWhileAsync1(source, predicate); + } + else { + return skipWhileAsync2(source, predicate); + } +} +exports.skipWhileAsync = skipWhileAsync; +const skipWhileAsync1 = (source, predicate) => { + async function* iterator() { + let skip = true; + for await (const item of source) { + if (skip === false) { + yield item; + } + else if (await predicate(item) === false) { + skip = false; + yield item; + } + } + } + return new BasicAsyncEnumerable_1.BasicAsyncEnumerable(iterator); +}; +const skipWhileAsync2 = (source, predicate) => { + async function* iterator() { + let index = 0; + let skip = true; + for await (const item of source) { + if (skip === false) { + yield item; + } + else if (await predicate(item, index) === false) { + skip = false; + yield item; + } + index++; + } + } + return new BasicAsyncEnumerable_1.BasicAsyncEnumerable(iterator); +}; + + +/***/ }), + +/***/ 79890: +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.sum = void 0; +function sum(source, selector) { + if (selector) { + return sum2(source, selector); + } + else { + return sum1(source); + } +} +exports.sum = sum; +const sum1 = async (source) => { + let total = 0; + for await (const value of source) { + total += value; + } + return total; +}; +const sum2 = async (source, selector) => { + let total = 0; + for await (const value of source) { + total += selector(value); + } + return total; +}; + + +/***/ }), + +/***/ 37237: +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.sumAsync = void 0; +/** + * Computes the sum of the sequence of numeric values that are obtained by invoking a transform function + * on each element of the input async sequence. + * @param source A sequence of values that are used to calculate a sum. + * @param selector A transform function to apply to each element. + * @returns The sum of values (from the selector) of the async sequence + */ +exports.sumAsync = async (source, selector) => { + let sum = 0; + for await (const value of source) { + sum += await selector(value); + } + return sum; +}; + + +/***/ }), + +/***/ 58143: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.take = void 0; +const BasicAsyncEnumerable_1 = __nccwpck_require__(87563); +/** + * Returns a specified number of contiguous elements from the start of a sequence. + * @param source The sequence to return elements from. + * @param amount The number of elements to return. + * @returns An IAsyncEnumerable that contains the specified number of elements from the start of the input sequence. + */ +function take(source, amount) { + async function* iterator() { + // negative amounts should yield empty + let amountLeft = amount > 0 ? amount : 0; + for await (const item of source) { + if (amountLeft-- === 0) { + break; + } + else { + yield item; + } + } + } + return new BasicAsyncEnumerable_1.BasicAsyncEnumerable(iterator); +} +exports.take = take; + + +/***/ }), + +/***/ 79458: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.takeWhile = void 0; +const BasicAsyncEnumerable_1 = __nccwpck_require__(87563); +/** + * Returns elements from a sequence as long as a specified condition is true. + * The element's index is used in the logic of the predicate function. + * @param source The sequence to return elements from. + * @param predicate A function to test each source element for a condition; + * the second parameter of the function represents the index of the source element. + * @returns An IAsyncEnumerable that contains elements from the input sequence + * that occur before the element at which the test no longer passes. + */ +exports.takeWhile = (source, predicate) => { + if (predicate.length === 1) { + return takeWhile1(source, predicate); + } + else { + return takeWhile2(source, predicate); + } +}; +const takeWhile1 = (source, predicate) => { + async function* iterator() { + for await (const item of source) { + if (predicate(item)) { + yield item; + } + else { + break; + } + } + } + return new BasicAsyncEnumerable_1.BasicAsyncEnumerable(iterator); +}; +const takeWhile2 = (source, predicate) => { + async function* iterator() { + let index = 0; + for await (const item of source) { + if (predicate(item, index++)) { + yield item; + } + else { + break; + } + } + } + return new BasicAsyncEnumerable_1.BasicAsyncEnumerable(iterator); +}; + + +/***/ }), + +/***/ 19247: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.takeWhileAsync = void 0; +const BasicAsyncEnumerable_1 = __nccwpck_require__(87563); +/** + * Returns elements from a sequence as long as a specified condition is true. + * The element's index is used in the logic of the predicate function. + * @param source The sequence to return elements from. + * @param predicate A async function to test each source element for a condition; + * the second parameter of the function represents the index of the source element. + * @returns An IAsyncEnumerable that contains elements from the input sequence + * that occur before the element at which the test no longer passes. + */ +function takeWhileAsync(source, predicate) { + if (predicate.length === 1) { + return takeWhileAsync1(source, predicate); + } + else { + return takeWhileAsync2(source, predicate); + } +} +exports.takeWhileAsync = takeWhileAsync; +const takeWhileAsync1 = (source, predicate) => { + async function* iterator() { + for await (const item of source) { + if (await predicate(item)) { + yield item; + } + else { + break; + } + } + } + return new BasicAsyncEnumerable_1.BasicAsyncEnumerable(iterator); +}; +const takeWhileAsync2 = (source, predicate) => { + async function* iterator() { + let index = 0; + for await (const item of source) { + if (await predicate(item, index++)) { + yield item; + } + else { + break; + } + } + } + return new BasicAsyncEnumerable_1.BasicAsyncEnumerable(iterator); +}; + + +/***/ }), + +/***/ 65029: +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.toArray = void 0; +/** + * Creates an array from a AsyncIterable. + * @param source An AsyncIterable to create an array from. + * @returns An array of elements + */ +async function toArray(source) { + const array = []; + for await (const item of source) { + array.push(item); + } + return array; +} +exports.toArray = toArray; + + +/***/ }), + +/***/ 47060: +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.toMap = void 0; +/** + * Converts an AsyncIterable to a Map. + * @param source An Iterable to convert. + * @param selector A function to serve as a key selector. + * @returns A promise for Map + */ +async function toMap(source, selector) { + const map = new Map(); + for await (const value of source) { + const key = selector(value); + const array = map.get(key); + if (array === undefined) { + map.set(key, [value]); + } + else { + array.push(value); + } + } + return map; +} +exports.toMap = toMap; + + +/***/ }), + +/***/ 38649: +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.toMapAsync = void 0; +/** + * Converts an AsyncIterable to a Map. + * @param source An Iterable to convert. + * @param selector An async function to serve as a key selector. + * @returns A promise for Map + */ +async function toMapAsync(source, selector) { + const map = new Map(); + for await (const value of source) { + const key = await selector(value); + const array = map.get(key); + if (array === undefined) { + map.set(key, [value]); + } + else { + array.push(value); + } + } + return map; +} +exports.toMapAsync = toMapAsync; + + +/***/ }), + +/***/ 24145: +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.toSet = void 0; +/** + * Converts the Async Itertion to a Set + * @param source Iteration + * @returns Set containing the iteration values + */ +async function toSet(source) { + const set = new Set(); + for await (const item of source) { + set.add(item); + } + return set; +} +exports.toSet = toSet; + + +/***/ }), + +/***/ 33410: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.union = void 0; +const BasicAsyncEnumerable_1 = __nccwpck_require__(87563); +/** + * Produces the set union of two sequences by using scrict equality comparison or a specified IEqualityComparer. + * @param first An AsyncIterable whose distinct elements form the first set for the union. + * @param second An AsyncIterable whose distinct elements form the second set for the union. + * @param comparer The IEqualityComparer to compare values. Optional. + * @returns An IAsyncEnumerable that contains the elements from both input sequences, excluding duplicates. + */ +function union(first, second, comparer) { + if (comparer) { + return union2(first, second, comparer); + } + else { + return union1(first, second); + } +} +exports.union = union; +const union1 = (first, second) => { + async function* iterator() { + const set = new Set(); + for await (const item of first) { + if (set.has(item) === false) { + yield item; + set.add(item); + } + } + for await (const item of second) { + if (set.has(item) === false) { + yield item; + set.add(item); + } + } + } + return new BasicAsyncEnumerable_1.BasicAsyncEnumerable(iterator); +}; +const union2 = (first, second, comparer) => { + async function* iterator() { + const result = []; + for (const source of [first, second]) { + for await (const value of source) { + let exists = false; + for (const resultValue of result) { + if (comparer(value, resultValue) === true) { + exists = true; + break; + } + } + if (exists === false) { + yield value; + result.push(value); + } + } + } + } + return new BasicAsyncEnumerable_1.BasicAsyncEnumerable(iterator); +}; + + +/***/ }), + +/***/ 99953: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.unionAsync = void 0; +const BasicAsyncEnumerable_1 = __nccwpck_require__(87563); +/** + * Produces the set union of two sequences by using a specified IAsyncEqualityComparer. + * @param first An AsyncIterable whose distinct elements form the first set for the union. + * @param second An AsyncIterable whose distinct elements form the second set for the union. + * @param comparer The IAsyncEqualityComparer to compare values. + * @returns An IAsyncEnumerable that contains the elements from both input sequences, excluding duplicates. + */ +function unionAsync(first, second, comparer) { + async function* iterator() { + const result = []; + for (const source of [first, second]) { + for await (const value of source) { + let exists = false; + for (const resultValue of result) { + if (await comparer(value, resultValue) === true) { + exists = true; + break; + } + } + if (exists === false) { + yield value; + result.push(value); + } + } + } + } + return new BasicAsyncEnumerable_1.BasicAsyncEnumerable(iterator); +} +exports.unionAsync = unionAsync; + + +/***/ }), + +/***/ 59156: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.where = void 0; +const BasicAsyncEnumerable_1 = __nccwpck_require__(87563); +/** + * Filters a sequence of values based on a predicate. + * Each element's index is used in the logic of the predicate function. + * @param source An AsyncIterable to filter. + * @param predicate A function to test each source element for a condition; + * the second parameter of the function represents the index of the source element. + * @returns An IAsyncEnumerable that contains elements from the input sequence that satisfy the condition. + */ +function where(source, predicate) { + if (predicate.length === 1) { + return where1(source, predicate); + } + else { + return where2(source, predicate); + } +} +exports.where = where; +const where1 = (source, predicate) => { + async function* iterator() { + for await (const item of source) { + if (predicate(item) === true) { + yield item; + } + } + } + return new BasicAsyncEnumerable_1.BasicAsyncEnumerable(iterator); +}; +const where2 = (source, predicate) => { + async function* iterator() { + let i = 0; + for await (const item of source) { + if (predicate(item, i++) === true) { + yield item; + } + } + } + return new BasicAsyncEnumerable_1.BasicAsyncEnumerable(iterator); +}; + + +/***/ }), + +/***/ 377: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.whereAsync = void 0; +const BasicAsyncEnumerable_1 = __nccwpck_require__(87563); +/** + * Filters a sequence of values based on a predicate. + * Each element's index is used in the logic of the predicate function. + * @param source An AsyncIterable to filter. + * @param predicate A async function to test each source element for a condition; + * the second parameter of the function represents the index of the source element. + * @returns An IAsyncEnumerable that contains elements from the input sequence that satisfy the condition. + */ +function whereAsync(source, predicate) { + if (predicate.length === 1) { + return whereAsync1(source, predicate); + } + else { + return whereAsync2(source, predicate); + } +} +exports.whereAsync = whereAsync; +const whereAsync1 = (source, predicate) => { + async function* iterator() { + for await (const item of source) { + if (await predicate(item) === true) { + yield item; + } + } + } + return new BasicAsyncEnumerable_1.BasicAsyncEnumerable(iterator); +}; +const whereAsync2 = (source, predicate) => { + async function* iterator() { + let i = 0; + for await (const item of source) { + if (await predicate(item, i++) === true) { + yield item; + } + } + } + return new BasicAsyncEnumerable_1.BasicAsyncEnumerable(iterator); +}; + + +/***/ }), + +/***/ 44440: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.zip = void 0; +const BasicAsyncEnumerable_1 = __nccwpck_require__(87563); +function zip(first, second, resultSelector) { + if (resultSelector) { + return zip2(first, second, resultSelector); + } + else { + return zip1(first, second); + } +} +exports.zip = zip; +const zip1 = (source, second) => { + async function* iterator() { + const firstIterator = source[Symbol.asyncIterator](); + const secondIterator = second[Symbol.asyncIterator](); + while (true) { + const result = await Promise.all([firstIterator.next(), secondIterator.next()]); + const a = result[0]; + const b = result[1]; + if (a.done && b.done) { + break; + } + else { + yield [a.value, b.value]; + } + } + } + return new BasicAsyncEnumerable_1.BasicAsyncEnumerable(iterator); +}; +const zip2 = (source, second, resultSelector) => { + async function* iterator() { + const firstIterator = source[Symbol.asyncIterator](); + const secondIterator = second[Symbol.asyncIterator](); + while (true) { + const result = await Promise.all([firstIterator.next(), secondIterator.next()]); + const a = result[0]; + const b = result[1]; + if (a.done && b.done) { + break; + } + else { + yield resultSelector(a.value, b.value); + } + } + } + return new BasicAsyncEnumerable_1.BasicAsyncEnumerable(iterator); +}; + + +/***/ }), + +/***/ 49774: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.zipAsync = void 0; +const BasicAsyncEnumerable_1 = __nccwpck_require__(87563); +/** + * Applies a specified async function to the corresponding elements of two sequences, + * producing a sequence of the results. + * @param first The first sequence to merge. + * @param second The second sequence to merge. + * @param resultSelector An async function that specifies how to merge the elements from the two sequences. + * @returns An IAsyncEnumerable that contains merged elements of two input sequences. + */ +function zipAsync(first, second, resultSelector) { + async function* generator() { + const firstIterator = first[Symbol.asyncIterator](); + const secondIterator = second[Symbol.asyncIterator](); + while (true) { + const results = await Promise.all([firstIterator.next(), secondIterator.next()]); + const firstNext = results[0]; + const secondNext = results[1]; + if (firstNext.done || secondNext.done) { + break; + } + else { + yield resultSelector(firstNext.value, secondNext.value); + } + } + } + return new BasicAsyncEnumerable_1.BasicAsyncEnumerable(generator); +} +exports.zipAsync = zipAsync; + + +/***/ }), + +/***/ 67718: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.isAsyncEnumerable = void 0; +const BasicAsyncEnumerable_1 = __nccwpck_require__(87563); +/* eslint-disable @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-member-access */ +/** + * Determine if a type is IAsyncEnumerable + * @param source Any Value + * @returns Whether or not source is an Async Enumerable + */ +function isAsyncEnumerable(source) { + if (!source) { + return false; + } + if (source instanceof BasicAsyncEnumerable_1.BasicAsyncEnumerable) { + return true; + } + if (typeof source[Symbol.asyncIterator] !== "function") { + return false; + } + const propertyNames = Object.getOwnPropertyNames(BasicAsyncEnumerable_1.BasicAsyncEnumerable.prototype) + .filter((v) => v !== "constructor"); + const methods = source.prototype || source; + for (const prop of propertyNames) { + if (typeof methods[prop] !== "function") { + return false; + } + } + return true; +} +exports.isAsyncEnumerable = isAsyncEnumerable; + + +/***/ }), + +/***/ 12544: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.emptyAsync = void 0; +const BasicAsyncEnumerable_1 = __nccwpck_require__(87563); +/** + * Returns an empty IAsyncEnumerable that has the specified type argument. + * @returns An empty IAsyncEnumerable whose type argument is TResult. + */ +exports.emptyAsync = () => { + async function* iterable() { + for await (const _ of []) { + yield _; + } + } + return new BasicAsyncEnumerable_1.BasicAsyncEnumerable(iterable); +}; + + +/***/ }), + +/***/ 52753: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.enumerateObjectAsync = void 0; +const BasicAsyncEnumerable_1 = __nccwpck_require__(87563); +/** + * Iterates through the object + * @param source Source Object + * @returns IAsyncEnumerabe<[TKey, TValue]> of Key Value pairs + */ +exports.enumerateObjectAsync = (source) => { + async function* iterable() { + /* eslint-disable */ + for (const key in source) { + yield [key, source[key]]; + } + /* eslint-enable */ + } + return new BasicAsyncEnumerable_1.BasicAsyncEnumerable(iterable); +}; + + +/***/ }), + +/***/ 31712: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.flattenAsync = void 0; +const BasicAsyncEnumerable_1 = __nccwpck_require__(87563); +function flattenAsync(source, shallow) { + async function* iterator(sourceInner) { + for await (const item of sourceInner) { + // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access + if (item[Symbol.asyncIterator] !== undefined) { + // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment + const items = shallow ? item : iterator(item); + for await (const inner of items) { + yield inner; + } + } + else { + yield item; + } + } + } + return new BasicAsyncEnumerable_1.BasicAsyncEnumerable(() => iterator(source)); +} +exports.flattenAsync = flattenAsync; + + +/***/ }), + +/***/ 55641: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.fromAsync = void 0; +const shared_1 = __nccwpck_require__(25897); +const BasicAsyncEnumerable_1 = __nccwpck_require__(87563); +function fromAsync(promisesOrIterable) { + if (Array.isArray(promisesOrIterable)) { + if (promisesOrIterable.length === 0) { + throw new shared_1.InvalidOperationException(shared_1.ErrorString.NoElements); + } + return new BasicAsyncEnumerable_1.BasicAsyncEnumerable(async function* () { + for await (const value of promisesOrIterable) { + yield value; + } + }); + } + else { + return new BasicAsyncEnumerable_1.BasicAsyncEnumerable(promisesOrIterable); + } +} +exports.fromAsync = fromAsync; + + +/***/ }), + +/***/ 28272: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +var emptyAsync_1 = __nccwpck_require__(12544); +Object.defineProperty(exports, "emptyAsync", ({ enumerable: true, get: function () { return emptyAsync_1.emptyAsync; } })); +var enumerateObjectAsync_1 = __nccwpck_require__(52753); +Object.defineProperty(exports, "enumerateObjectAsync", ({ enumerable: true, get: function () { return enumerateObjectAsync_1.enumerateObjectAsync; } })); +var flattenAsync_1 = __nccwpck_require__(31712); +Object.defineProperty(exports, "flattenAsync", ({ enumerable: true, get: function () { return flattenAsync_1.flattenAsync; } })); +var fromAsync_1 = __nccwpck_require__(55641); +Object.defineProperty(exports, "fromAsync", ({ enumerable: true, get: function () { return fromAsync_1.fromAsync; } })); +var partitionAsync_1 = __nccwpck_require__(73482); +Object.defineProperty(exports, "partitionAsync", ({ enumerable: true, get: function () { return partitionAsync_1.partitionAsync; } })); +var rangeAsync_1 = __nccwpck_require__(85948); +Object.defineProperty(exports, "rangeAsync", ({ enumerable: true, get: function () { return rangeAsync_1.rangeAsync; } })); +var repeatAsync_1 = __nccwpck_require__(37393); +Object.defineProperty(exports, "repeatAsync", ({ enumerable: true, get: function () { return repeatAsync_1.repeatAsync; } })); + + +/***/ }), + +/***/ 73482: +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.partitionAsync = void 0; +/** + * Paritions the Iterable into a tuple of failing and passing arrays + * based on the predicate. + * @param source Elements to Partition + * @param predicate Pass / Fail condition + * @returns [pass, fail] + */ +exports.partitionAsync = async (source, predicate) => { + const fail = []; + const pass = []; + for await (const value of source) { + if (predicate(value) === true) { + pass.push(value); + } + else { + fail.push(value); + } + } + return [pass, fail]; +}; + + +/***/ }), + +/***/ 85948: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.rangeAsync = void 0; +const shared_1 = __nccwpck_require__(25897); +const BasicAsyncEnumerable_1 = __nccwpck_require__(87563); +/** + * Generates a sequence of integral numbers within a specified range. + * @param start The value of the first integer in the sequence. + * @param count The number of sequential integers to generate. + * @throws {ArgumentOutOfRangeException} Start is Less than 0 + * OR start + count -1 is larger than MAX_SAFE_INTEGER. + * @returns An IAsyncEnumerable that contains a range of sequential integral numbers. + */ +function rangeAsync(start, count) { + if (start < 0 || (start + count - 1) > Number.MAX_SAFE_INTEGER) { + throw new shared_1.ArgumentOutOfRangeException(`start`); + } + async function* iterator() { + const max = start + count; + for (let i = start; i < max; i++) { + yield i; + } + } + return new BasicAsyncEnumerable_1.BasicAsyncEnumerable(iterator); +} +exports.rangeAsync = rangeAsync; + + +/***/ }), + +/***/ 37393: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.repeatAsync = void 0; +const shared_1 = __nccwpck_require__(25897); +const BasicAsyncEnumerable_1 = __nccwpck_require__(87563); +/** + * Generates a sequence that contains one repeated value. + * @param element The value to be repeated. + * @param count The number of times to repeat the value in the generated sequence. + * @param delay How long to delay the repeat (ms) + * @returns An IAsyncEnumerable that contains a repeated value. + */ +function repeatAsync(element, count, delay) { + if (count < 0) { + throw new shared_1.ArgumentOutOfRangeException(`count`); + } + if (delay) { + return repeat2(element, count, delay); + } + else { + return repeat1(element, count); + } +} +exports.repeatAsync = repeatAsync; +/** + * @private + */ +const repeat1 = (element, count) => { + async function* iterator() { + for (let i = 0; i < count; i++) { + yield element; + } + } + return new BasicAsyncEnumerable_1.BasicAsyncEnumerable(iterator); +}; +/** + * @private + */ +const repeat2 = (element, count, delay) => { + async function* iterator() { + for (let i = 0; i < count; i++) { + yield await new Promise((resolve) => setTimeout(() => resolve(element), delay)); + } + } + return new BasicAsyncEnumerable_1.BasicAsyncEnumerable(iterator); +}; + + +/***/ }), + +/***/ 39657: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +// LINQ to TypeScript +// Copyright (c) Alexandre Rogozine +// MIT License +// https://github.com/arogozine/LinqToTypeScript/blob/master/LICENSE +Object.defineProperty(exports, "__esModule", ({ value: true })); +const tslib_1 = __nccwpck_require__(4351); +// API design adapted from, +// LINQ: .NET Language-Integrated Query +// API is part of .NET Core foundational libraries (CoreFX) +// MIT License +// https://github.com/dotnet/corefx/blob/master/LICENSE.TXT +// API Documentation adapted from, +// LINQ API Documentation +// Create Commons Attribution 4.0 International +// https://github.com/dotnet/docs/blob/master/LICENSE +// Shared Interfacess +tslib_1.__exportStar(__nccwpck_require__(29581), exports); +// Types and Stuff +tslib_1.__exportStar(__nccwpck_require__(25897), exports); +var ArrayEnumerable_1 = __nccwpck_require__(18640); +Object.defineProperty(exports, "ArrayEnumerable", ({ enumerable: true, get: function () { return ArrayEnumerable_1.ArrayEnumerable; } })); +// Main Initializer +tslib_1.__exportStar(__nccwpck_require__(28593), exports); +// Static Methods +tslib_1.__exportStar(__nccwpck_require__(2374), exports); +tslib_1.__exportStar(__nccwpck_require__(28272), exports); +tslib_1.__exportStar(__nccwpck_require__(78485), exports); +// Type Check +var isEnumerable_1 = __nccwpck_require__(98120); +Object.defineProperty(exports, "isEnumerable", ({ enumerable: true, get: function () { return isEnumerable_1.isEnumerable; } })); +var isParallelEnumerable_1 = __nccwpck_require__(19475); +Object.defineProperty(exports, "isParallelEnumerable", ({ enumerable: true, get: function () { return isParallelEnumerable_1.isParallelEnumerable; } })); +var isAsyncEnumerable_1 = __nccwpck_require__(67718); +Object.defineProperty(exports, "isAsyncEnumerable", ({ enumerable: true, get: function () { return isAsyncEnumerable_1.isAsyncEnumerable; } })); + + +/***/ }), + +/***/ 10973: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.bindArray = void 0; +const ArrayEnumerable_1 = __nccwpck_require__(18640); +/** + * Binds LINQ method to a built in array type + * @param jsArray Built In JS Array Type + */ +exports.bindArray = (jsArray) => { + const propertyNames = Object.getOwnPropertyNames(ArrayEnumerable_1.ArrayEnumerable.prototype) + // eslint-disable-next-line @typescript-eslint/array-type + .filter((v) => v !== "constructor"); + for (const prop of propertyNames) { + // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-member-access + jsArray.prototype[prop] = jsArray.prototype[prop] || ArrayEnumerable_1.ArrayEnumerable.prototype[prop]; + } +}; + + +/***/ }), + +/***/ 73091: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.bindArrayEnumerable = void 0; +const shared_1 = __nccwpck_require__(25897); +const ArrayEnumerable_1 = __nccwpck_require__(18640); +const BasicEnumerable_1 = __nccwpck_require__(93706); +/** + * @private + */ +exports.bindArrayEnumerable = () => { + const { prototype } = ArrayEnumerable_1.ArrayEnumerable; + const propertyNames = Object.getOwnPropertyNames(BasicEnumerable_1.BasicEnumerable.prototype) + // eslint-disable-next-line @typescript-eslint/array-type + .filter((v) => v !== "constructor"); + for (const prop of propertyNames) { + // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment + prototype[prop] = prototype[prop] || BasicEnumerable_1.BasicEnumerable.prototype[prop]; + } + prototype.all = function (predicate) { + return this.every(predicate); + }; + prototype.any = function (predicate) { + if (predicate) { + return this.some(predicate); + } + else { + return this.length !== 0; + } + }; + prototype.count = function (predicate) { + if (predicate) { + // eslint-disable-next-line no-shadow + let count = 0; + for (let i = 0; i < this.length; i++) { + if (predicate(this[i]) === true) { + count++; + } + } + return count; + } + else { + return this.length; + } + }; + prototype.elementAt = function (index) { + if (index < 0 || index >= this.length) { + throw new shared_1.ArgumentOutOfRangeException("index"); + } + return this[index]; + }; + prototype.elementAtOrDefault = function (index) { + return this[index] || null; + }; + prototype.first = function (predicate) { + if (predicate) { + const value = this.find(predicate); + if (value === undefined) { + throw new shared_1.InvalidOperationException(shared_1.ErrorString.NoMatch); + } + else { + return value; + } + } + else { + if (this.length === 0) { + throw new shared_1.InvalidOperationException(shared_1.ErrorString.NoElements); + } + return this[0]; + } + }; + prototype.firstOrDefault = function (predicate) { + if (predicate) { + const value = this.find(predicate); + if (value === undefined) { + return null; + } + else { + return value; + } + } + else { + return this.length === 0 ? null : this[0]; + } + }; + prototype.last = function (predicate) { + if (predicate) { + for (let i = this.length - 1; i >= 0; i--) { + const value = this[i]; + if (predicate(value) === true) { + return value; + } + } + throw new shared_1.InvalidOperationException(shared_1.ErrorString.NoMatch); + } + else { + if (this.length === 0) { + throw new shared_1.InvalidOperationException(shared_1.ErrorString.NoElements); + } + return this[this.length - 1]; + } + }; + prototype.lastOrDefault = function (predicate) { + if (predicate) { + for (let i = this.length - 1; i >= 0; i--) { + const value = this[i]; + if (predicate(value) === true) { + return value; + } + } + return null; + } + else { + return this.length === 0 ? null : this[this.length - 1]; + } + }; + prototype.max = function (selector) { + if (this.length === 0) { + throw new shared_1.InvalidOperationException(shared_1.ErrorString.NoElements); + } + if (selector) { + // eslint-disable-next-line no-shadow + let max = Number.NEGATIVE_INFINITY; + for (let i = 0; i < this.length; i++) { + max = Math.max(selector(this[i]), max); + } + return max; + } + else { + return Math.max.apply(null, this); + } + }; + prototype.min = function (selector) { + if (this.length === 0) { + throw new shared_1.InvalidOperationException(shared_1.ErrorString.NoElements); + } + if (selector) { + // eslint-disable-next-line no-shadow + let min = Number.POSITIVE_INFINITY; + for (let i = 0; i < this.length; i++) { + min = Math.min(selector(this[i]), min); + } + return min; + } + else { + return Math.min.apply(null, this); + } + }; + prototype.reverse = function () { + Array.prototype.reverse.apply(this); + return this; + }; +}; + + +/***/ }), + +/***/ 86802: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.bindLinq = void 0; +const aggregate_1 = __nccwpck_require__(33880); +const all_1 = __nccwpck_require__(86504); +const allAsync_1 = __nccwpck_require__(57664); +const any_1 = __nccwpck_require__(26666); +const anyAsync_1 = __nccwpck_require__(47462); +const asAsync_1 = __nccwpck_require__(7662); +const asParallel_1 = __nccwpck_require__(92035); +const average_1 = __nccwpck_require__(80758); +const averageAsync_1 = __nccwpck_require__(99013); +const concatenate_1 = __nccwpck_require__(10323); +const contains_1 = __nccwpck_require__(6805); +const containsAsync_1 = __nccwpck_require__(38261); +const count_1 = __nccwpck_require__(46333); +const countAsync_1 = __nccwpck_require__(87872); +const distinct_1 = __nccwpck_require__(65605); +const distinctAsync_1 = __nccwpck_require__(54770); +const each_1 = __nccwpck_require__(70679); +const eachAsync_1 = __nccwpck_require__(46256); +const elementAt_1 = __nccwpck_require__(93281); +const elementAtOrDefault_1 = __nccwpck_require__(86643); +const except_1 = __nccwpck_require__(3281); +const exceptAsync_1 = __nccwpck_require__(30202); +const first_1 = __nccwpck_require__(13633); +const firstAsync_1 = __nccwpck_require__(86717); +const firstOrDefault_1 = __nccwpck_require__(51250); +const firstOrDefaultAsync_1 = __nccwpck_require__(75559); +const groupBy_1 = __nccwpck_require__(17267); +const groupByAsync_1 = __nccwpck_require__(72697); +const groupByWithSel_1 = __nccwpck_require__(31647); +const intersect_1 = __nccwpck_require__(71400); +const intersectAsync_1 = __nccwpck_require__(96380); +const join_1 = __nccwpck_require__(25095); +const last_1 = __nccwpck_require__(97768); +const lastAsync_1 = __nccwpck_require__(37040); +const lastOrDefault_1 = __nccwpck_require__(89490); +const lastOrDefaultAsync_1 = __nccwpck_require__(84899); +const max_1 = __nccwpck_require__(16526); +const maxAsync_1 = __nccwpck_require__(50485); +const min_1 = __nccwpck_require__(80031); +const minAsync_1 = __nccwpck_require__(35475); +const ofType_1 = __nccwpck_require__(41334); +const orderBy_1 = __nccwpck_require__(123); +const orderByAsync_1 = __nccwpck_require__(95293); +const orderByDescending_1 = __nccwpck_require__(41098); +const orderByDescendingAsync_1 = __nccwpck_require__(89594); +const reverse_1 = __nccwpck_require__(85631); +const select_1 = __nccwpck_require__(92998); +const selectAsync_1 = __nccwpck_require__(89362); +const selectMany_1 = __nccwpck_require__(49430); +const selectManyAsync_1 = __nccwpck_require__(3796); +const sequenceEquals_1 = __nccwpck_require__(41748); +const sequenceEqualsAsync_1 = __nccwpck_require__(66249); +const single_1 = __nccwpck_require__(44579); +const singleAsync_1 = __nccwpck_require__(91488); +const singleOrDefault_1 = __nccwpck_require__(44811); +const singleOrDefaultAsync_1 = __nccwpck_require__(56250); +const skip_1 = __nccwpck_require__(71504); +const skipWhile_1 = __nccwpck_require__(39517); +const skipWhileAsync_1 = __nccwpck_require__(27112); +const sum_1 = __nccwpck_require__(4747); +const sumAsync_1 = __nccwpck_require__(85914); +const take_1 = __nccwpck_require__(37429); +const takeWhile_1 = __nccwpck_require__(33875); +const takeWhileAsync_1 = __nccwpck_require__(74277); +const toArray_1 = __nccwpck_require__(37708); +const toMap_1 = __nccwpck_require__(35036); +const toMapAsync_1 = __nccwpck_require__(42124); +const toSet_1 = __nccwpck_require__(4469); +const union_1 = __nccwpck_require__(93396); +const unionAsync_1 = __nccwpck_require__(45489); +const where_1 = __nccwpck_require__(92745); +const whereAsync_1 = __nccwpck_require__(52971); +const zip_1 = __nccwpck_require__(44172); +const zipAsync_1 = __nccwpck_require__(23202); +/* eslint-disable @typescript-eslint/no-unsafe-return, @typescript-eslint/no-unsafe-assignment */ +/** + * Binds LINQ methods to an iterable type + * @param object Iterable Type + */ +exports.bindLinq = (object) => { + const prototype = object.prototype; + // The static methods take an IEnumerable as first argument + // when wrapping the first argument becomes `this` + const bind = (func, key) => { + const wrapped = function (...params) { + return func(this, ...params); + }; + Object.defineProperty(wrapped, "length", { value: func.length - 1 }); + prototype[key] = wrapped; + }; + bind(aggregate_1.aggregate, "aggregate"); + bind(all_1.all, "all"); + bind(allAsync_1.allAsync, "allAsync"); + bind(any_1.any, "any"); + bind(anyAsync_1.anyAsync, "anyAsync"); + bind(asAsync_1.asAsync, "asAsync"); + bind(asParallel_1.asParallel, "asParallel"); + bind(average_1.average, "average"); + bind(averageAsync_1.averageAsync, "averageAsync"); + bind(concatenate_1.concatenate, "concatenate"); + bind(contains_1.contains, "contains"); + bind(containsAsync_1.containsAsync, "containsAsync"); + bind(count_1.count, "count"); + bind(countAsync_1.countAsync, "countAsync"); + bind(distinct_1.distinct, "distinct"); + bind(distinctAsync_1.distinctAsync, "distinctAsync"); + bind(each_1.each, "each"); + bind(eachAsync_1.eachAsync, "eachAsync"); + bind(elementAt_1.elementAt, "elementAt"); + bind(elementAtOrDefault_1.elementAtOrDefault, "elementAtOrDefault"); + bind(except_1.except, "except"); + bind(exceptAsync_1.exceptAsync, "exceptAsync"); + bind(first_1.first, "first"); + bind(firstAsync_1.firstAsync, "firstAsync"); + bind(firstOrDefault_1.firstOrDefault, "firstOrDefault"); + bind(firstOrDefaultAsync_1.firstOrDefaultAsync, "firstOrDefaultAsync"); + bind(groupBy_1.groupBy, "groupBy"); + bind(groupByAsync_1.groupByAsync, "groupByAsync"); + bind(groupByWithSel_1.groupByWithSel, "groupByWithSel"); + bind(intersect_1.intersect, "intersect"); + bind(intersectAsync_1.intersectAsync, "intersectAsync"); + bind(join_1.join, "joinByKey"); + bind(last_1.last, "last"); + bind(lastAsync_1.lastAsync, "lastAsync"); + bind(lastOrDefault_1.lastOrDefault, "lastOrDefault"); + bind(lastOrDefaultAsync_1.lastOrDefaultAsync, "lastOrDefaultAsync"); + bind(max_1.max, "max"); + bind(maxAsync_1.maxAsync, "maxAsync"); + bind(min_1.min, "min"); + bind(minAsync_1.minAsync, "minAsync"); + bind(ofType_1.ofType, "ofType"); + bind(orderBy_1.orderBy, "orderBy"); + bind(orderByAsync_1.orderByAsync, "orderByAsync"); + bind(orderByDescending_1.orderByDescending, "orderByDescending"); + bind(orderByDescendingAsync_1.orderByDescendingAsync, "orderByDescendingAsync"); + bind(reverse_1.reverse, "reverse"); + bind(select_1.select, "select"); + bind(selectAsync_1.selectAsync, "selectAsync"); + bind(selectMany_1.selectMany, "selectMany"); + bind(selectManyAsync_1.selectManyAsync, "selectManyAsync"); + bind(sequenceEquals_1.sequenceEquals, "sequenceEquals"); + bind(sequenceEqualsAsync_1.sequenceEqualsAsync, "sequenceEqualsAsync"); + bind(single_1.single, "single"); + bind(singleAsync_1.singleAsync, "singleAsync"); + bind(singleOrDefault_1.singleOrDefault, "singleOrDefault"); + bind(singleOrDefaultAsync_1.singleOrDefaultAsync, "singleOrDefaultAsync"); + bind(skip_1.skip, "skip"); + bind(skipWhile_1.skipWhile, "skipWhile"); + bind(skipWhileAsync_1.skipWhileAsync, "skipWhileAsync"); + bind(sum_1.sum, "sum"); + bind(sumAsync_1.sumAsync, "sumAsync"); + bind(take_1.take, "take"); + bind(takeWhile_1.takeWhile, "takeWhile"); + bind(takeWhileAsync_1.takeWhileAsync, "takeWhileAsync"); + bind(toArray_1.toArray, "toArray"); + bind(toMap_1.toMap, "toMap"); + bind(toMapAsync_1.toMapAsync, "toMapAsync"); + bind(toSet_1.toSet, "toSet"); + bind(union_1.union, "union"); + bind(unionAsync_1.unionAsync, "unionAsync"); + bind(where_1.where, "where"); + bind(whereAsync_1.whereAsync, "whereAsync"); + bind(zip_1.zip, "zip"); + bind(zipAsync_1.zipAsync, "zipAsync"); +}; + + +/***/ }), + +/***/ 33083: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.bindLinqAsync = void 0; +const aggregate_1 = __nccwpck_require__(83822); +const all_1 = __nccwpck_require__(81383); +const allAsync_1 = __nccwpck_require__(34380); +const any_1 = __nccwpck_require__(57112); +const anyAsync_1 = __nccwpck_require__(76897); +const asParallel_1 = __nccwpck_require__(10441); +const average_1 = __nccwpck_require__(8261); +const averageAsync_1 = __nccwpck_require__(71525); +const concatenate_1 = __nccwpck_require__(42548); +const contains_1 = __nccwpck_require__(69498); +const containsAsync_1 = __nccwpck_require__(16486); +const count_1 = __nccwpck_require__(71283); +const countAsync_1 = __nccwpck_require__(44686); +const distinct_1 = __nccwpck_require__(81289); +const distinctAsync_1 = __nccwpck_require__(29106); +const each_1 = __nccwpck_require__(92763); +const eachAsync_1 = __nccwpck_require__(2610); +const elementAt_1 = __nccwpck_require__(5484); +const elementAtOrDefault_1 = __nccwpck_require__(407); +const except_1 = __nccwpck_require__(56061); +const exceptAsync_1 = __nccwpck_require__(56349); +const first_1 = __nccwpck_require__(18281); +const firstAsync_1 = __nccwpck_require__(96322); +const firstOrDefault_1 = __nccwpck_require__(40886); +const firstOrDefaultAsync_1 = __nccwpck_require__(92619); +const groupBy_1 = __nccwpck_require__(76617); +const groupByAsync_1 = __nccwpck_require__(34376); +const groupByWithSel_1 = __nccwpck_require__(88207); +const intersect_1 = __nccwpck_require__(67728); +const intersectAsync_1 = __nccwpck_require__(41736); +const join_1 = __nccwpck_require__(10165); +const last_1 = __nccwpck_require__(33700); +const lastAsync_1 = __nccwpck_require__(47543); +const lastOrDefault_1 = __nccwpck_require__(22424); +const lastOrDefaultAsync_1 = __nccwpck_require__(12667); +const max_1 = __nccwpck_require__(85338); +const maxAsync_1 = __nccwpck_require__(71705); +const min_1 = __nccwpck_require__(32380); +const minAsync_1 = __nccwpck_require__(24916); +const ofType_1 = __nccwpck_require__(66592); +const orderBy_1 = __nccwpck_require__(11526); +const orderByAsync_1 = __nccwpck_require__(74392); +const orderByDescending_1 = __nccwpck_require__(98610); +const orderByDescendingAsync_1 = __nccwpck_require__(84310); +const reverse_1 = __nccwpck_require__(79158); +const select_1 = __nccwpck_require__(24187); +const selectAsync_1 = __nccwpck_require__(68786); +const selectMany_1 = __nccwpck_require__(70165); +const selectManyAsync_1 = __nccwpck_require__(52627); +const sequenceEquals_1 = __nccwpck_require__(87058); +const sequenceEqualsAsync_1 = __nccwpck_require__(38488); +const single_1 = __nccwpck_require__(21430); +const singleAsync_1 = __nccwpck_require__(94572); +const singleOrDefault_1 = __nccwpck_require__(45053); +const singleOrDefaultAsync_1 = __nccwpck_require__(36031); +const skip_1 = __nccwpck_require__(94114); +const skipWhile_1 = __nccwpck_require__(45477); +const skipWhileAsync_1 = __nccwpck_require__(5706); +const sum_1 = __nccwpck_require__(79890); +const sumAsync_1 = __nccwpck_require__(37237); +const take_1 = __nccwpck_require__(58143); +const takeWhile_1 = __nccwpck_require__(79458); +const takeWhileAsync_1 = __nccwpck_require__(19247); +const toArray_1 = __nccwpck_require__(65029); +const toMap_1 = __nccwpck_require__(47060); +const toMapAsync_1 = __nccwpck_require__(38649); +const toSet_1 = __nccwpck_require__(24145); +const union_1 = __nccwpck_require__(33410); +const unionAsync_1 = __nccwpck_require__(99953); +const where_1 = __nccwpck_require__(59156); +const whereAsync_1 = __nccwpck_require__(377); +const zip_1 = __nccwpck_require__(44440); +const zipAsync_1 = __nccwpck_require__(49774); +/* eslint-disable @typescript-eslint/no-unsafe-return, @typescript-eslint/no-unsafe-assignment */ +/** + * Binds LINQ methods to an iterable type + * @param object Iterable Type + */ +exports.bindLinqAsync = (object) => { + const prototype = object.prototype; + const bind = (func, key) => { + switch (func.length) { + case 1: + prototype[key] = function () { + return func(this); + }; + return; + case 2: + prototype[key] = function (a) { + return func(this, a); + }; + return; + case 3: + prototype[key] = function (a, b) { + return func(this, a, b); + }; + return; + case 4: + prototype[key] = function (a, b, c) { + return func(this, a, b, c); + }; + return; + case 5: + prototype[key] = function (a, b, c, d) { + return func(this, a, b, c, d); + }; + return; + default: + throw new Error("Invalid Function"); + } + }; + bind(aggregate_1.aggregate, "aggregate"); + bind(all_1.all, "all"); + bind(allAsync_1.allAsync, "allAsync"); + bind(any_1.any, "any"); + bind(anyAsync_1.anyAsync, "anyAsync"); + // bind(asAsync, "asAsync") + bind(asParallel_1.asParallel, "asParallel"); + bind(average_1.average, "average"); + bind(averageAsync_1.averageAsync, "averageAsync"); + bind(concatenate_1.concatenate, "concatenate"); + prototype.contains = function (value, comparer) { + return contains_1.contains(this, value, comparer); + }; + bind(containsAsync_1.containsAsync, "containsAsync"); + bind(count_1.count, "count"); + bind(countAsync_1.countAsync, "countAsync"); + prototype.distinct = function (comparer) { + return distinct_1.distinct(this, comparer); + }; + bind(distinctAsync_1.distinctAsync, "distinctAsync"); + bind(each_1.each, "each"); + bind(eachAsync_1.eachAsync, "eachAsync"); + bind(elementAt_1.elementAt, "elementAt"); + bind(elementAtOrDefault_1.elementAtOrDefault, "elementAtOrDefault"); + bind(except_1.except, "except"); + bind(exceptAsync_1.exceptAsync, "exceptAsync"); + bind(first_1.first, "first"); + bind(firstAsync_1.firstAsync, "firstAsync"); + bind(firstOrDefault_1.firstOrDefault, "firstOrDefault"); + bind(firstOrDefaultAsync_1.firstOrDefaultAsync, "firstOrDefaultAsync"); + bind(groupBy_1.groupBy, "groupBy"); + bind(groupByAsync_1.groupByAsync, "groupByAsync"); + bind(groupByWithSel_1.groupByWithSel, "groupByWithSel"); + prototype.intersect = function (second, comparer) { + return intersect_1.intersect(this, second, comparer); + }; + bind(intersectAsync_1.intersectAsync, "intersectAsync"); + prototype.joinByKey = function (inner, outerKeySelector, innerKeySelector, resultSelector, comparer) { + return join_1.join(this, inner, outerKeySelector, innerKeySelector, resultSelector, comparer); + }; + bind(last_1.last, "last"); + bind(lastAsync_1.lastAsync, "lastAsync"); + bind(lastOrDefault_1.lastOrDefault, "lastOrDefault"); + bind(lastOrDefaultAsync_1.lastOrDefaultAsync, "lastOrDefaultAsync"); + bind(max_1.max, "max"); + bind(maxAsync_1.maxAsync, "maxAsync"); + bind(min_1.min, "min"); + bind(minAsync_1.minAsync, "minAsync"); + bind(ofType_1.ofType, "ofType"); + bind(orderBy_1.orderBy, "orderBy"); + bind(orderByAsync_1.orderByAsync, "orderByAsync"); + bind(orderByDescending_1.orderByDescending, "orderByDescending"); + bind(orderByDescendingAsync_1.orderByDescendingAsync, "orderByDescendingAsync"); + bind(reverse_1.reverse, "reverse"); + bind(select_1.select, "select"); + bind(selectAsync_1.selectAsync, "selectAsync"); + bind(selectMany_1.selectMany, "selectMany"); + bind(selectManyAsync_1.selectManyAsync, "selectManyAsync"); + prototype.sequenceEquals = function (second, comparer) { + return sequenceEquals_1.sequenceEquals(this, second, comparer); + }; + bind(sequenceEqualsAsync_1.sequenceEqualsAsync, "sequenceEqualsAsync"); + bind(single_1.single, "single"); + bind(singleAsync_1.singleAsync, "singleAsync"); + bind(singleOrDefault_1.singleOrDefault, "singleOrDefault"); + bind(singleOrDefaultAsync_1.singleOrDefaultAsync, "singleOrDefaultAsync"); + bind(skip_1.skip, "skip"); + bind(skipWhile_1.skipWhile, "skipWhile"); + bind(skipWhileAsync_1.skipWhileAsync, "skipWhileAsync"); + bind(sum_1.sum, "sum"); + bind(sumAsync_1.sumAsync, "sumAsync"); + bind(take_1.take, "take"); + bind(takeWhile_1.takeWhile, "takeWhile"); + bind(takeWhileAsync_1.takeWhileAsync, "takeWhileAsync"); + bind(toArray_1.toArray, "toArray"); + bind(toMap_1.toMap, "toMap"); + bind(toMapAsync_1.toMapAsync, "toMapAsync"); + bind(toSet_1.toSet, "toSet"); + bind(union_1.union, "union"); + bind(unionAsync_1.unionAsync, "unionAsync"); + bind(where_1.where, "where"); + bind(whereAsync_1.whereAsync, "whereAsync"); + bind(zip_1.zip, "zip"); + bind(zipAsync_1.zipAsync, "zipAsync"); +}; + + +/***/ }), + +/***/ 49354: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.bindLinqParallel = void 0; +const aggregate_1 = __nccwpck_require__(3912); +const all_1 = __nccwpck_require__(48475); +const allAsync_1 = __nccwpck_require__(91256); +const any_1 = __nccwpck_require__(6979); +const anyAsync_1 = __nccwpck_require__(37637); +const asAsync_1 = __nccwpck_require__(31944); +const average_1 = __nccwpck_require__(54012); +const averageAsync_1 = __nccwpck_require__(73927); +const concatenate_1 = __nccwpck_require__(86034); +const contains_1 = __nccwpck_require__(12270); +const containsAsync_1 = __nccwpck_require__(94327); +const count_1 = __nccwpck_require__(24363); +const countAsync_1 = __nccwpck_require__(33435); +const distinct_1 = __nccwpck_require__(85186); +const distinctAsync_1 = __nccwpck_require__(81106); +const each_1 = __nccwpck_require__(50969); +const eachAsync_1 = __nccwpck_require__(86055); +const elementAt_1 = __nccwpck_require__(70959); +const elementAtOrDefault_1 = __nccwpck_require__(9571); +const except_1 = __nccwpck_require__(15606); +const exceptAsync_1 = __nccwpck_require__(45674); +const first_1 = __nccwpck_require__(48517); +const firstAsync_1 = __nccwpck_require__(36270); +const firstOrDefault_1 = __nccwpck_require__(33153); +const firstOrDefaultAsync_1 = __nccwpck_require__(21327); +const groupBy_1 = __nccwpck_require__(43589); +const groupByAsync_1 = __nccwpck_require__(92477); +const groupByWithSel_1 = __nccwpck_require__(96630); +const intersect_1 = __nccwpck_require__(2166); +const intersectAsync_1 = __nccwpck_require__(93650); +const join_1 = __nccwpck_require__(57048); +const last_1 = __nccwpck_require__(30815); +const lastAsync_1 = __nccwpck_require__(2145); +const lastOrDefault_1 = __nccwpck_require__(47621); +const lastOrDefaultAsync_1 = __nccwpck_require__(1370); +const max_1 = __nccwpck_require__(53661); +const maxAsync_1 = __nccwpck_require__(91121); +const min_1 = __nccwpck_require__(62299); +const minAsync_1 = __nccwpck_require__(49111); +const ofType_1 = __nccwpck_require__(32534); +const orderBy_1 = __nccwpck_require__(10211); +const orderByAsync_1 = __nccwpck_require__(8744); +const orderByDescending_1 = __nccwpck_require__(41268); +const orderByDescendingAsync_1 = __nccwpck_require__(58011); +const reverse_1 = __nccwpck_require__(69476); +const select_1 = __nccwpck_require__(41611); +const selectAsync_1 = __nccwpck_require__(31803); +const selectMany_1 = __nccwpck_require__(62637); +const selectManyAsync_1 = __nccwpck_require__(55961); +const sequenceEquals_1 = __nccwpck_require__(62790); +const sequenceEqualsAsync_1 = __nccwpck_require__(83839); +const single_1 = __nccwpck_require__(9360); +const singleAsync_1 = __nccwpck_require__(60389); +const singleOrDefault_1 = __nccwpck_require__(6648); +const singleOrDefaultAsync_1 = __nccwpck_require__(73096); +const skip_1 = __nccwpck_require__(8392); +const skipWhile_1 = __nccwpck_require__(19226); +const skipWhileAsync_1 = __nccwpck_require__(44057); +const sum_1 = __nccwpck_require__(20429); +const sumAsync_1 = __nccwpck_require__(50021); +const take_1 = __nccwpck_require__(27609); +const takeWhile_1 = __nccwpck_require__(95009); +const takeWhileAsync_1 = __nccwpck_require__(78842); +const toArray_1 = __nccwpck_require__(72537); +const toMap_1 = __nccwpck_require__(2031); +const toMapAsync_1 = __nccwpck_require__(33037); +const toSet_1 = __nccwpck_require__(59632); +const union_1 = __nccwpck_require__(33615); +const unionAsync_1 = __nccwpck_require__(65945); +const where_1 = __nccwpck_require__(50719); +const whereAsync_1 = __nccwpck_require__(76742); +const zip_1 = __nccwpck_require__(48763); +const zipAsync_1 = __nccwpck_require__(80669); +/* eslint-disable @typescript-eslint/no-unsafe-return, @typescript-eslint/no-unsafe-assignment */ +/** + * Binds LINQ methods to an iterable type + * @param object Iterable Type + */ +exports.bindLinqParallel = (object) => { + const wPrototype = object.prototype; + const prototype = wPrototype; + const bind = (func, key) => { + switch (func.length) { + case 1: + wPrototype[key] = function () { + return func(this); + }; + return; + case 2: + wPrototype[key] = function (a) { + return func(this, a); + }; + return; + case 3: + wPrototype[key] = function (a, b) { + return func(this, a, b); + }; + return; + case 4: + wPrototype[key] = function (a, b, c) { + return func(this, a, b, c); + }; + return; + case 5: + wPrototype[key] = function (a, b, c, d) { + return func(this, a, b, c, d); + }; + return; + default: + throw new Error("Invalid Function"); + } + }; + bind(aggregate_1.aggregate, "aggregate"); + bind(all_1.all, "all"); + bind(allAsync_1.allAsync, "allAsync"); + bind(any_1.any, "any"); + bind(anyAsync_1.anyAsync, "anyAsync"); + bind(asAsync_1.asAsync, "asAsync"); + // bind(asParallel) + bind(average_1.average, "average"); + bind(averageAsync_1.averageAsync, "averageAsync"); + bind(concatenate_1.concatenate, "concatenate"); + prototype.contains = function (value, comparer) { + return contains_1.contains(this, value, comparer); + }; + bind(containsAsync_1.containsAsync, "containsAsync"); + bind(count_1.count, "count"); + bind(countAsync_1.countAsync, "countAsync"); + prototype.distinct = function (comparer) { + return distinct_1.distinct(this, comparer); + }; + bind(distinctAsync_1.distinctAsync, "distinctAsync"); + bind(each_1.each, "each"); + bind(eachAsync_1.eachAsync, "eachAsync"); + bind(elementAt_1.elementAt, "elementAt"); + bind(elementAtOrDefault_1.elementAtOrDefault, "elementAtOrDefault"); + bind(except_1.except, "except"); + bind(exceptAsync_1.exceptAsync, "exceptAsync"); + bind(first_1.first, "first"); + bind(firstAsync_1.firstAsync, "firstAsync"); + bind(firstOrDefault_1.firstOrDefault, "firstOrDefault"); + bind(firstOrDefaultAsync_1.firstOrDefaultAsync, "firstOrDefaultAsync"); + bind(groupBy_1.groupBy, "groupBy"); + bind(groupByAsync_1.groupByAsync, "groupByAsync"); + bind(groupByWithSel_1.groupByWithSel, "groupByWithSel"); + prototype.intersect = function (second, comparer) { + return intersect_1.intersect(this, second, comparer); + }; + bind(intersectAsync_1.intersectAsync, "intersectAsync"); + prototype.joinByKey = function (inner, outerKeySelector, innerKeySelector, resultSelector, comparer) { + return join_1.join(this, inner, outerKeySelector, innerKeySelector, resultSelector, comparer); + }; + bind(last_1.last, "last"); + bind(lastAsync_1.lastAsync, "lastAsync"); + bind(lastOrDefault_1.lastOrDefault, "lastOrDefault"); + bind(lastOrDefaultAsync_1.lastOrDefaultAsync, "lastOrDefaultAsync"); + bind(max_1.max, "max"); + bind(maxAsync_1.maxAsync, "maxAsync"); + bind(min_1.min, "min"); + bind(minAsync_1.minAsync, "minAsync"); + bind(ofType_1.ofType, "ofType"); + bind(orderBy_1.orderBy, "orderBy"); + bind(orderByAsync_1.orderByAsync, "orderByAsync"); + bind(orderByDescending_1.orderByDescending, "orderByDescending"); + bind(orderByDescendingAsync_1.orderByDescendingAsync, "orderByDescendingAsync"); + bind(reverse_1.reverse, "reverse"); + bind(select_1.select, "select"); + bind(selectAsync_1.selectAsync, "selectAsync"); + bind(selectMany_1.selectMany, "selectMany"); + bind(selectManyAsync_1.selectManyAsync, "selectManyAsync"); + prototype.sequenceEquals = function (second, comparer) { + return sequenceEquals_1.sequenceEquals(this, second, comparer); + }; + bind(sequenceEqualsAsync_1.sequenceEqualsAsync, "sequenceEqualsAsync"); + bind(single_1.single, "single"); + bind(singleAsync_1.singleAsync, "singleAsync"); + bind(singleOrDefault_1.singleOrDefault, "singleOrDefault"); + bind(singleOrDefaultAsync_1.singleOrDefaultAsync, "singleOrDefaultAsync"); + bind(skip_1.skip, "skip"); + bind(skipWhile_1.skipWhile, "skipWhile"); + bind(skipWhileAsync_1.skipWhileAsync, "skipWhileAsync"); + bind(sum_1.sum, "sum"); + bind(sumAsync_1.sumAsync, "sumAsync"); + bind(take_1.take, "take"); + bind(takeWhile_1.takeWhile, "takeWhile"); + bind(takeWhileAsync_1.takeWhileAsync, "takeWhileAsync"); + bind(toArray_1.toArray, "toArray"); + bind(toMap_1.toMap, "toMap"); + bind(toMapAsync_1.toMapAsync, "toMapAsync"); + bind(toSet_1.toSet, "toSet"); + bind(union_1.union, "union"); + bind(unionAsync_1.unionAsync, "unionAsync"); + bind(where_1.where, "where"); + bind(whereAsync_1.whereAsync, "whereAsync"); + bind(zip_1.zip, "zip"); + bind(zipAsync_1.zipAsync, "zipAsync"); +}; + + +/***/ }), + +/***/ 92195: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.bindString = void 0; +const shared_1 = __nccwpck_require__(25897); +const BasicEnumerable_1 = __nccwpck_require__(93706); +/** + * Adds LINQ methods to String prototype + */ +exports.bindString = () => { + const prototype = String.prototype; + const propertyNames = Object.getOwnPropertyNames(BasicEnumerable_1.BasicEnumerable.prototype) + // eslint-disable-next-line @typescript-eslint/array-type + .filter((v) => v !== "constructor"); + for (const prop of propertyNames) { + // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment + prototype[prop] = prototype[prop] || BasicEnumerable_1.BasicEnumerable.prototype[prop]; + } + prototype.first = function (predicate) { + if (predicate) { + for (let i = 0; i < this.length; i++) { + const value = this[i]; + if (predicate(value) === true) { + return value; + } + } + throw new shared_1.InvalidOperationException(shared_1.ErrorString.NoMatch); + } + if (this.length === 0) { + throw new shared_1.InvalidOperationException(shared_1.ErrorString.NoElements); + } + return this[0]; + }; + prototype.firstOrDefault = function (predicate) { + if (predicate) { + for (let i = 0; i < this.length; i++) { + const value = this[i]; + if (predicate(value) === true) { + return value; + } + } + return null; + } + return this.length === 0 ? null : this[0]; + }; + prototype.count = function (predicate) { + if (predicate) { + // eslint-disable-next-line no-shadow + let count = 0; + for (let i = 0; i < this.length; i++) { + if (predicate(this[i]) === true) { + count++; + } + } + return count; + } + else { + return this.length; + } + }; + prototype.elementAt = function (index) { + if (index < 0 || index >= this.length) { + throw new shared_1.ArgumentOutOfRangeException("index"); + } + return this[index]; + }; + prototype.elementAtOrDefault = function (index) { + return this[index] || null; + }; + prototype.last = function (predicate) { + if (predicate) { + for (let i = this.length - 1; i >= 0; i--) { + const value = this[i]; + if (predicate(value) === true) { + return value; + } + } + throw new shared_1.InvalidOperationException(shared_1.ErrorString.NoMatch); + } + else { + if (this.length === 0) { + throw new shared_1.InvalidOperationException(shared_1.ErrorString.NoElements); + } + return this[this.length - 1]; + } + }; + prototype.lastOrDefault = function (predicate) { + if (predicate) { + for (let i = this.length - 1; i >= 0; i--) { + const value = this[i]; + if (predicate(value) === true) { + return value; + } + } + return null; + } + else { + return this.length === 0 ? null : this[this.length - 1]; + } + }; + prototype.reverse = function () { + // eslint-disable-next-line @typescript-eslint/no-this-alias + const outer = this; + function* generator() { + for (let i = outer.length - 1; i >= 0; i--) { + yield outer[i]; + } + } + return new BasicEnumerable_1.BasicEnumerable(generator); + }; +}; + + +/***/ }), + +/***/ 27998: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.initializeLinq = void 0; +const bindArray_1 = __nccwpck_require__(10973); +const bindString_1 = __nccwpck_require__(92195); +const bindLinq_1 = __nccwpck_require__(86802); +/** + * Binds LINQ methods to Array Types, Map, Set, and String + */ +exports.initializeLinq = () => { + bindLinq_1.bindLinq(Map); + bindLinq_1.bindLinq(Set); + bindString_1.bindString(); + bindArray_1.bindArray(Array); + bindArray_1.bindArray(Int8Array); + bindArray_1.bindArray(Int16Array); + bindArray_1.bindArray(Int32Array); + bindArray_1.bindArray(Uint8Array); + bindArray_1.bindArray(Uint8ClampedArray); + bindArray_1.bindArray(Uint16Array); + bindArray_1.bindArray(Uint32Array); + bindArray_1.bindArray(Float32Array); + bindArray_1.bindArray(Float64Array); +}; + + +/***/ }), + +/***/ 28593: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.bindString = exports.bindArray = exports.bindLinqAsync = exports.bindLinq = void 0; +const BasicAsyncEnumerable_1 = __nccwpck_require__(87563); +const BasicParallelEnumerable_1 = __nccwpck_require__(76716); +const BasicEnumerable_1 = __nccwpck_require__(93706); +const bindArray_1 = __nccwpck_require__(10973); +Object.defineProperty(exports, "bindArray", ({ enumerable: true, get: function () { return bindArray_1.bindArray; } })); +const bindArrayEnumerable_1 = __nccwpck_require__(73091); +const bindLinq_1 = __nccwpck_require__(86802); +Object.defineProperty(exports, "bindLinq", ({ enumerable: true, get: function () { return bindLinq_1.bindLinq; } })); +const bindLinqAsync_1 = __nccwpck_require__(33083); +Object.defineProperty(exports, "bindLinqAsync", ({ enumerable: true, get: function () { return bindLinqAsync_1.bindLinqAsync; } })); +const bindLinqParallel_1 = __nccwpck_require__(49354); +const bindString_1 = __nccwpck_require__(92195); +Object.defineProperty(exports, "bindString", ({ enumerable: true, get: function () { return bindString_1.bindString; } })); +// To avoid circular dependencies, we bind LINQ methods to classes here +bindLinq_1.bindLinq(BasicEnumerable_1.BasicEnumerable); +bindLinqAsync_1.bindLinqAsync(BasicAsyncEnumerable_1.BasicAsyncEnumerable); +bindLinqParallel_1.bindLinqParallel(BasicParallelEnumerable_1.BasicParallelEnumerable); +// Array Enumerable extends Array and has some custom optimizations +bindArrayEnumerable_1.bindArrayEnumerable(); +var initializeLinq_1 = __nccwpck_require__(27998); +Object.defineProperty(exports, "initializeLinq", ({ enumerable: true, get: function () { return initializeLinq_1.initializeLinq; } })); + + +/***/ }), + +/***/ 76716: +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.BasicParallelEnumerable = void 0; +/* eslint-disable @typescript-eslint/naming-convention, @typescript-eslint/no-empty-interface */ +/** + * Base implementation of IParallelEnumerable + * @private + */ +class BasicParallelEnumerable { + constructor(dataFunc) { + this.dataFunc = dataFunc; + } + [Symbol.asyncIterator]() { + const { dataFunc } = this; + async function* iterator() { + switch (dataFunc.type) { + case 1 /* ArrayOfPromises */: + for (const value of dataFunc.generator()) { + yield value; + } + break; + case 2 /* PromiseOfPromises */: + for (const value of await dataFunc.generator()) { + yield value; + } + break; + case 0 /* PromiseToArray */: + default: + for (const value of await dataFunc.generator()) { + yield value; + } + break; + } + } + return iterator(); + } +} +exports.BasicParallelEnumerable = BasicParallelEnumerable; + + +/***/ }), + +/***/ 42166: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.OrderedParallelEnumerable = void 0; +const asAsyncSortedKeyValues_1 = __nccwpck_require__(33779); +const asAsyncSortedKeyValuesSync_1 = __nccwpck_require__(22978); +const asSortedKeyValues_1 = __nccwpck_require__(13858); +const asSortedKeyValuesSync_1 = __nccwpck_require__(10875); +const BasicParallelEnumerable_1 = __nccwpck_require__(76716); +/** + * Ordered Parallel Enumerable + * @private + */ +class OrderedParallelEnumerable extends BasicParallelEnumerable_1.BasicParallelEnumerable { + constructor(orderedPairs) { + super({ + generator: async () => { + const asyncVals = orderedPairs(); + const array = []; + for await (const val of asyncVals) { + array.push(...val); + } + return array; + }, + type: 0 /* PromiseToArray */, + }); + this.orderedPairs = orderedPairs; + } + static generateAsync(source, keySelector, ascending, comparer) { + let orderedPairs; + if (source instanceof OrderedParallelEnumerable) { + orderedPairs = async function* () { + for await (const pair of source.orderedPairs()) { + yield* asAsyncSortedKeyValuesSync_1.asAsyncSortedKeyValuesSync(pair, keySelector, ascending, comparer); + } + }; + } + else { + orderedPairs = () => asAsyncSortedKeyValues_1.asAsyncSortedKeyValues(source, keySelector, ascending, comparer); + } + return new OrderedParallelEnumerable(orderedPairs); + } + static generate(source, keySelector, ascending, comparer) { + let orderedPairs; + if (source instanceof OrderedParallelEnumerable) { + orderedPairs = async function* () { + for await (const pair of source.orderedPairs()) { + yield* asSortedKeyValuesSync_1.asSortedKeyValuesSync(pair, keySelector, ascending, comparer); + } + }; + } + else { + orderedPairs = () => asSortedKeyValues_1.asSortedKeyValues(source, keySelector, ascending, comparer); + } + return new OrderedParallelEnumerable(orderedPairs); + } + thenBy(keySelector, comparer) { + return OrderedParallelEnumerable.generate(this, keySelector, true, comparer); + } + thenByAsync(keySelector, comparer) { + return OrderedParallelEnumerable.generateAsync(this, keySelector, true, comparer); + } + thenByDescending(keySelector, comparer) { + return OrderedParallelEnumerable.generate(this, keySelector, false, comparer); + } + thenByDescendingAsync(keySelector, comparer) { + return OrderedParallelEnumerable.generateAsync(this, keySelector, false, comparer); + } +} +exports.OrderedParallelEnumerable = OrderedParallelEnumerable; + + +/***/ }), + +/***/ 23987: +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.asAsyncKeyMap = void 0; +/** + * Converts values to a key values map. + * @param source Async Iterable + * @param keySelector Async Key Selector for Map + * @returns Promise for a Map for Key to Values + */ +exports.asAsyncKeyMap = async (source, keySelector) => { + const map = new Map(); + for await (const item of source) { + const key = await keySelector(item); + const currentMapping = map.get(key); + if (currentMapping) { + currentMapping.push(item); + } + else { + map.set(key, [item]); + } + } + return map; +}; + + +/***/ }), + +/***/ 22176: +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.asAsyncKeyMapSync = void 0; +/** + * Converts values to a key values map. + * @param source Iterable + * @param keySelector Async Key Selector for Map + * @returns Promise for a Map for Key to Values + */ +exports.asAsyncKeyMapSync = async (source, keySelector) => { + const map = new Map(); + for (const item of source) { + const key = await keySelector(item); + const currentMapping = map.get(key); + if (currentMapping) { + currentMapping.push(item); + } + else { + map.set(key, [item]); + } + } + return map; +}; + + +/***/ }), + +/***/ 33779: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.asAsyncSortedKeyValues = void 0; +const asAsyncKeyMap_1 = __nccwpck_require__(23987); +/** + * Sorts values in an Async Iterable based on key and a key comparer. + * @param source Async Iterable + * @param keySelector Async Key Selector + * @param ascending Ascending or Descending Sort + * @param comparer Key Comparer for Sorting. Optional. + * @returns Async Iterable Iterator of arrays + */ +async function* asAsyncSortedKeyValues(source, keySelector, ascending, comparer) { + const map = await asAsyncKeyMap_1.asAsyncKeyMap(source, keySelector); + const sortedKeys = [...map.keys()].sort(comparer ? comparer : undefined); + if (ascending) { + for (let i = 0; i < sortedKeys.length; i++) { + yield map.get(sortedKeys[i]); + } + } + else { + for (let i = sortedKeys.length - 1; i >= 0; i--) { + yield map.get(sortedKeys[i]); + } + } +} +exports.asAsyncSortedKeyValues = asAsyncSortedKeyValues; + + +/***/ }), + +/***/ 22978: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.asAsyncSortedKeyValuesSync = void 0; +const asAsyncKeyMapSync_1 = __nccwpck_require__(22176); +/** + * Sorts values in an Async Iterable based on key and a key comparer. + * @param source Iterable + * @param keySelector Async Key Selector + * @param ascending Ascending or Descending Sort + * @param comparer Key Comparer for Sorting. Optional. + * @returns Async Iterable Iterator of arrays + */ +async function* asAsyncSortedKeyValuesSync(source, keySelector, ascending, comparer) { + const map = await asAsyncKeyMapSync_1.asAsyncKeyMapSync(source, keySelector); + const sortedKeys = [...map.keys()].sort(comparer ? comparer : undefined); + if (ascending) { + for (let i = 0; i < sortedKeys.length; i++) { + yield map.get(sortedKeys[i]); + } + } + else { + for (let i = sortedKeys.length - 1; i >= 0; i--) { + yield map.get(sortedKeys[i]); + } + } +} +exports.asAsyncSortedKeyValuesSync = asAsyncSortedKeyValuesSync; + + +/***/ }), + +/***/ 21127: +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.asKeyMap = void 0; +/** + * Converts values to a key values map. + * @param source Async Iterable + * @param keySelector Key Selector for Map + * @returns Promise for a Map for Key to Values + */ +exports.asKeyMap = async (source, keySelector) => { + const map = new Map(); + for await (const item of source) { + const key = keySelector(item); + const currentMapping = map.get(key); + if (currentMapping) { + currentMapping.push(item); + } + else { + map.set(key, [item]); + } + } + return map; +}; + + +/***/ }), + +/***/ 42952: +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.asKeyMapSync = void 0; +/** + * Converts values to a key values map. + * @param source Iterable + * @param keySelector Key Selector for Map + * @returns Map for Key to Values + */ +exports.asKeyMapSync = (source, keySelector) => { + const map = new Map(); + for (const item of source) { + const key = keySelector(item); + const currentMapping = map.get(key); + if (currentMapping) { + currentMapping.push(item); + } + else { + map.set(key, [item]); + } + } + return map; +}; + + +/***/ }), + +/***/ 13858: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.asSortedKeyValues = void 0; +const asKeyMap_1 = __nccwpck_require__(21127); +/** + * Sorts values in an Iterable based on key and a key comparer. + * @param source Async Iterable + * @param keySelector Key Selector + * @param ascending Ascending or Descending Sort + * @param comparer Key Comparer for Sorting. Optional. + * @returns Async Iterable Iterator + */ +async function* asSortedKeyValues(source, keySelector, ascending, comparer) { + const map = await asKeyMap_1.asKeyMap(source, keySelector); + const sortedKeys = [...map.keys()].sort(comparer ? comparer : undefined); + if (ascending) { + for (let i = 0; i < sortedKeys.length; i++) { + yield map.get(sortedKeys[i]); + } + } + else { + for (let i = sortedKeys.length - 1; i >= 0; i--) { + yield map.get(sortedKeys[i]); + } + } +} +exports.asSortedKeyValues = asSortedKeyValues; + + +/***/ }), + +/***/ 10875: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.asSortedKeyValuesSync = void 0; +const asKeyMapSync_1 = __nccwpck_require__(42952); +/** + * Sorts values in an Iterable based on key and a key comparer. + * @param source Iterable + * @param keySelector Key Selector + * @param ascending Ascending or Descending Sort + * @param comparer Key Comparer for Sorting. Optional. + * @returns Async Iterable Iterator + */ +async function* asSortedKeyValuesSync(source, keySelector, ascending, comparer) { + const map = asKeyMapSync_1.asKeyMapSync(source, keySelector); + const sortedKeys = [...map.keys()].sort(comparer ? comparer : undefined); + if (ascending) { + for (let i = 0; i < sortedKeys.length; i++) { + yield map.get(sortedKeys[i]); + } + } + else { + for (let i = sortedKeys.length - 1; i >= 0; i--) { + yield map.get(sortedKeys[i]); + } + } +} +exports.asSortedKeyValuesSync = asSortedKeyValuesSync; + + +/***/ }), + +/***/ 49931: +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.nextIteration = void 0; +/* eslint-disable */ +/** + * @private Don't use directly. + */ +exports.nextIteration = (source, onfulfilled) => { + const dataFunc = source.dataFunc; + switch (dataFunc.type) { + case 0 /* PromiseToArray */: { + const generator = () => dataFunc.generator().then((x) => { + const convValues = new Array(x.length); + for (let i = 0; i < x.length; i++) { + convValues[i] = onfulfilled(x[i]); + } + return convValues; + }); + return { + generator, + type: 0 /* PromiseToArray */, + }; + } + case 1 /* ArrayOfPromises */: { + const generator = () => { + const previousData = dataFunc.generator(); + const newPromises = new Array(previousData.length); + for (let i = 0; i < previousData.length; i++) { + newPromises[i] = previousData[i].then(onfulfilled); + } + return newPromises; + }; + return { + generator, + type: 1 /* ArrayOfPromises */, + }; + } + case 2 /* PromiseOfPromises */: { + const generator = async () => { + const previousData = await dataFunc.generator(); + const newPromises = new Array(previousData.length); + for (let i = 0; i < previousData.length; i++) { + newPromises[i] = previousData[i].then(onfulfilled); + } + return newPromises; + }; + return { + generator, + type: 2 /* PromiseOfPromises */, + }; + } + } +}; + + +/***/ }), + +/***/ 1892: +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.nextIterationAsync = void 0; +/* eslint-disable */ +/** + * @private Next Iteration for Parallel Enumerable + */ +exports.nextIterationAsync = (source, onfulfilled) => { + const dataFunc = source.dataFunc; + switch (dataFunc.type) { + case 0 /* PromiseToArray */: { + const generator = async () => { + const results = await dataFunc.generator(); + const newPromises = new Array(results.length); + for (let i = 0; i < results.length; i++) { + newPromises[i] = onfulfilled(results[i]); + } + return newPromises; + }; + return { + generator, + type: 2 /* PromiseOfPromises */, + }; + } + case 1 /* ArrayOfPromises */: { + const generator = () => dataFunc + .generator() + .map((promise) => promise.then(onfulfilled)); + return { + generator, + type: 1 /* ArrayOfPromises */, + }; + } + case 2 /* PromiseOfPromises */: { + const generator = async () => { + const promises = await dataFunc.generator(); + return promises.map((promise) => promise.then(onfulfilled)); + }; + return { + generator, + type: 2 /* PromiseOfPromises */, + }; + } + } +}; + + +/***/ }), + +/***/ 41734: +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.nextIterationWithIndex = void 0; +/* eslint-disable */ +exports.nextIterationWithIndex = (source, onfulfilled) => { + const dataFunc = source.dataFunc; + switch (dataFunc.type) { + case 0 /* PromiseToArray */: { + const generator = () => dataFunc.generator().then((x) => { + const convValues = new Array(x.length); + for (let i = 0; i < x.length; i++) { + convValues[i] = onfulfilled(x[i], i); + } + return convValues; + }); + return { + generator, + type: 0 /* PromiseToArray */, + }; + } + case 1 /* ArrayOfPromises */: { + const generator = () => { + const previousData = dataFunc.generator(); + const newPromises = new Array(previousData.length); + for (let i = 0; i < previousData.length; i++) { + newPromises[i] = previousData[i].then((value) => { + return onfulfilled(value, i); + }); + } + return newPromises; + }; + return { + generator, + type: 1 /* ArrayOfPromises */, + }; + } + case 2 /* PromiseOfPromises */: { + const generator = async () => { + const previousData = await dataFunc.generator(); + const newPromises = new Array(previousData.length); + for (let i = 0; i < previousData.length; i++) { + newPromises[i] = previousData[i].then((value) => onfulfilled(value, i)); + } + return newPromises; + }; + return { + generator, + type: 2 /* PromiseOfPromises */, + }; + } + } +}; + + +/***/ }), + +/***/ 61983: +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.nextIterationWithIndexAsync = void 0; +/* eslint-disable */ +exports.nextIterationWithIndexAsync = (source, onfulfilled) => { + const dataFunc = source.dataFunc; + switch (dataFunc.type) { + case 0 /* PromiseToArray */: { + const generator = async () => { + const results = await dataFunc.generator(); + const newPromises = new Array(results.length); + for (let i = 0; i < results.length; i++) { + newPromises[i] = onfulfilled(results[i], i); + } + return newPromises; + }; + return { + generator, + type: 2 /* PromiseOfPromises */, + }; + } + case 1 /* ArrayOfPromises */: { + const generator = () => dataFunc + .generator() + .map((promise, index) => promise.then((x) => onfulfilled(x, index))); + return { + generator, + type: 1 /* ArrayOfPromises */, + }; + } + case 2 /* PromiseOfPromises */: { + const generator = async () => { + const promises = await dataFunc.generator(); + return promises.map((promise, index) => promise.then((x) => onfulfilled(x, index))); + }; + return { + generator, + type: 2 /* PromiseOfPromises */, + }; + } + } +}; + + +/***/ }), + +/***/ 3912: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.aggregate = void 0; +const shared_1 = __nccwpck_require__(25897); +function aggregate(source, seedOrFunc, func, resultSelector) { + if (resultSelector) { + if (!func) { + throw new ReferenceError(`TAccumulate function is undefined`); + } + return aggregate3(source, seedOrFunc, func, resultSelector); + } + else if (func) { + return aggregate2(source, seedOrFunc, func); + } + else { + return aggregate1(source, seedOrFunc); + } +} +exports.aggregate = aggregate; +const aggregate1 = async (source, func) => { + let aggregateValue; + for await (const value of source) { + if (aggregateValue) { + aggregateValue = func(aggregateValue, value); + } + else { + aggregateValue = value; + } + } + if (aggregateValue === undefined) { + throw new shared_1.InvalidOperationException(shared_1.ErrorString.NoElements); + } + return aggregateValue; +}; +const aggregate2 = async (source, seed, func) => { + let aggregateValue = seed; + for await (const value of source) { + aggregateValue = func(aggregateValue, value); + } + return aggregateValue; +}; +const aggregate3 = async (source, seed, func, resultSelector) => { + let aggregateValue = seed; + for await (const value of source) { + aggregateValue = func(aggregateValue, value); + } + return resultSelector(aggregateValue); +}; + + +/***/ }), + +/***/ 48475: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.all = void 0; +const _nextIteration_1 = __nccwpck_require__(49931); +/** + * Determines whether all elements of a sequence satisfy a condition. + * @param source An IParallelEnumerable that contains the elements to apply the predicate to. + * @param predicate A function to test each element for a condition. + * @returns ``true`` if every element of the source sequence passes the test in the specified predicate, + * or if the sequence is empty; otherwise, ``false``. + */ +exports.all = (source, predicate) => { + const nextIter = _nextIteration_1.nextIteration(source, (x) => { + if (!predicate(x)) { + throw new Error(String(false)); + } + return true; + }); + switch (nextIter.type) { + case 0 /* PromiseToArray */: + return nextIter.generator() + .then(() => true, () => false); + case 1 /* ArrayOfPromises */: + return Promise.all(nextIter.generator()) + .then(() => true, () => false); + case 2 /* PromiseOfPromises */: + return nextIter.generator() + .then(Promise.all.bind(Promise)) + .then(() => true, () => false); + } +}; + + +/***/ }), + +/***/ 91256: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.allAsync = void 0; +const _nextIterationAsync_1 = __nccwpck_require__(1892); +/** + * Determines whether all elements of a sequence satisfy a condition. + * @param source An IParallelEnumerable that contains the elements to apply the predicate to. + * @param predicate A function to test each element for a condition. + * @returns ``true`` if every element of the source sequence passes the test in the specified predicate, + * or if the sequence is empty; otherwise, ``false``. + */ +exports.allAsync = (source, predicate) => { + const nextIter = _nextIterationAsync_1.nextIterationAsync(source, async (x) => { + if (await predicate(x) === false) { + throw new Error(String(false)); + } + return true; + }); + switch (nextIter.type) { + case 0 /* PromiseToArray */: + return nextIter + .generator() + .then(() => true, () => false); + case 1 /* ArrayOfPromises */: + return Promise.all(nextIter.generator()) + .then(() => true, () => false); + case 2 /* PromiseOfPromises */: + return nextIter.generator() + .then(Promise.all.bind(Promise)) + .then(() => true, () => false); + } +}; + + +/***/ }), + +/***/ 6979: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.any = void 0; +const _nextIteration_1 = __nccwpck_require__(49931); +/** + * Determines whether a sequence contains any elements. + * If predicate is specified, determines whether any element of a sequence satisfies a condition. + * @param source The IEnumerable to check for emptiness or apply the predicate to. + * @param predicate A function to test each element for a condition. + * @returns Whether or not the sequence contains any elements or contains any elements matching the predicate + */ +exports.any = (source, predicate) => { + if (predicate) { + return any2(source, predicate); + } + else { + return any1(source); + } +}; +const any1 = async (source) => { + const dataFunc = source.dataFunc; + let values; + switch (dataFunc.type) { + case 0 /* PromiseToArray */: + values = await dataFunc.generator(); + return values.length !== 0; + case 1 /* ArrayOfPromises */: + values = dataFunc.generator(); + return values.length !== 0; + case 2 /* PromiseOfPromises */: + values = await dataFunc.generator(); + return values.length !== 0; + } +}; +const any2 = async (source, predicate) => { + const dataFunc = _nextIteration_1.nextIteration(source, predicate); + let values; + switch (dataFunc.type) { + case 0 /* PromiseToArray */: + values = await dataFunc.generator(); + return values.includes(true); + case 1 /* ArrayOfPromises */: + values = await Promise.all(dataFunc.generator()); + return values.includes(true); + case 2 /* PromiseOfPromises */: + values = await Promise.all(await dataFunc.generator()); + return values.includes(true); + } +}; + + +/***/ }), + +/***/ 37637: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.anyAsync = void 0; +const _nextIterationAsync_1 = __nccwpck_require__(1892); +/** + * Determines whether any element of a sequence satisfies a condition. + * @param source An IParallelEnumerable whose elements to apply the predicate to. + * @param predicate A function to test each element for a condition. + * @returns Whether or not the parallel sequence contains any value (from the predicate) + */ +function anyAsync(source, predicate) { + const nextIter = _nextIterationAsync_1.nextIterationAsync(source, predicate); + switch (nextIter.type) { + case 0 /* PromiseToArray */: + return nextIter.generator().then((values) => { + return values.some((x) => x); + }); + case 1 /* ArrayOfPromises */: + return Promise.all(nextIter.generator()).then((values) => { + return values.some((x) => x); + }); + case 2 /* PromiseOfPromises */: + return nextIter.generator().then((values) => Promise.all(values)).then((values) => { + return values.some((x) => x); + }); + } +} +exports.anyAsync = anyAsync; + + +/***/ }), + +/***/ 31944: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.asAsync = void 0; +const fromAsync_1 = __nccwpck_require__(55641); +/** + * Converts a IEnumerable enumerable to an async one. + * @param source A parallel IEnumerable + * @returns IAsyncEnumerable + */ +exports.asAsync = (source) => { + async function* generator() { + for await (const value of source) { + yield value; + } + } + return fromAsync_1.fromAsync(generator); +}; + + +/***/ }), + +/***/ 54012: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.average = void 0; +const shared_1 = __nccwpck_require__(25897); +function average(source, selector) { + if (selector) { + return average2(source, selector); + } + else { + return average1(source); + } +} +exports.average = average; +const average1 = async (source) => { + let value; + let itemCount; + for (const item of await source.toArray()) { + value = (value || 0) + item; + itemCount = (itemCount || 0) + 1; + } + if (value === undefined) { + throw new shared_1.InvalidOperationException(shared_1.ErrorString.NoElements); + } + return value / itemCount; +}; +const average2 = async (source, func) => { + let value; + // eslint-disable-next-line no-shadow + let count; + for (const item of await source.toArray()) { + value = (value || 0) + func(item); + count = (count || 0) + 1; + } + if (value === undefined) { + throw new shared_1.InvalidOperationException(shared_1.ErrorString.NoElements); + } + return value / count; +}; + + +/***/ }), + +/***/ 73927: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.averageAsync = void 0; +const shared_1 = __nccwpck_require__(25897); +const _nextIterationAsync_1 = __nccwpck_require__(1892); +/** + * Computes the average of a sequence of values + * that are obtained by invoking a transform function on each element of the input sequence. + * @param source A sequence of values to calculate the average of. + * @param selector A transform function to apply to each element. + * @throws {InvalidOperationException} source contains no elements. + * @returns Average value (from the selector) of this parallel sequence + */ +async function averageAsync(source, selector) { + const nextIter = _nextIterationAsync_1.nextIterationAsync(source, selector); + // eslint-disable-next-line @typescript-eslint/array-type + let values; + switch (nextIter.type) { + case 1 /* ArrayOfPromises */: + values = nextIter.generator(); + break; + case 2 /* PromiseOfPromises */: + values = await nextIter.generator(); + break; + case 0 /* PromiseToArray */: + default: + values = await nextIter.generator(); + break; + } + if (values.length === 0) { + throw new shared_1.InvalidOperationException(shared_1.ErrorString.NoElements); + } + let value = 0; + for (const selectedValue of values) { + value += await selectedValue; + } + return value / values.length; +} +exports.averageAsync = averageAsync; + + +/***/ }), + +/***/ 86034: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.concatenate = void 0; +const BasicParallelEnumerable_1 = __nccwpck_require__(76716); +/** + * Concatenates two sequences. + * @param first The first sequence to concatenate. + * @param second The sequence to concatenate to the first sequence. + * @returns An IParallelEnumerable that contains the concatenated elements of the two input sequences. + */ +function concatenate( +// eslint-disable-next-line no-shadow +first, second) { + const generator = async () => { + // Wait for both enumerables + const promiseResults = await Promise.all([first.toArray(), second.toArray()]); + // Concat + const firstData = promiseResults[0]; + const secondData = promiseResults[1]; + const data = new Array(firstData.length + secondData.length); + let i = 0; + for (; i < firstData.length; i++) { + data[i] = firstData[i]; + } + for (let j = 0; j < secondData.length; j++, i++) { + data[i] = secondData[j]; + } + return data; + }; + return new BasicParallelEnumerable_1.BasicParallelEnumerable({ + generator, + type: 0 /* PromiseToArray */, + }); +} +exports.concatenate = concatenate; + + +/***/ }), + +/***/ 12270: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.contains = void 0; +const shared_1 = __nccwpck_require__(25897); +const _nextIteration_1 = __nccwpck_require__(49931); +/** + * Determines whether a sequence contains a specified element by using the specified or default IEqualityComparer. + * @param source A sequence in which to locate a value. + * @param value The value to locate in the sequence. + * @param comparer An equality comparer to compare values. Optional. + * @returns Whether or not source contains the specified value + */ +async function contains(source, value, comparer = shared_1.StrictEqualityComparer) { + let values; + if (comparer) { + values = _nextIteration_1.nextIteration(source, (x) => comparer(value, x)); + } + else { + values = _nextIteration_1.nextIteration(source, (x) => x === value); + } + switch (values.type) { + case 0 /* PromiseToArray */: { + const data = await values.generator(); + return data.some((x) => x); + } + case 1 /* ArrayOfPromises */: { + const data = await Promise.all(values.generator()); + return data.some((x) => x); + } + case 2 /* PromiseOfPromises */: { + const data = await Promise.all(await values.generator()); + return data.some((x) => x); + } + } +} +exports.contains = contains; + + +/***/ }), + +/***/ 94327: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.containsAsync = void 0; +const _nextIterationAsync_1 = __nccwpck_require__(1892); +/** + * Determines whether a sequence contains a specified element by using the specified or default IEqualityComparer. + * @param source A sequence in which to locate a value. + * @param value The value to locate in the sequence. + * @param comparer An equality comparer to compare values. Optional. + * @returns Whether or not the specified parallel sequence contains a value + */ +async function containsAsync(source, value, comparer) { + const values = _nextIterationAsync_1.nextIterationAsync(source, (x) => comparer(value, x)); + switch (values.type) { + case 0 /* PromiseToArray */: { + const data = await values.generator(); + return data.some((x) => x); + } + case 1 /* ArrayOfPromises */: { + const data = await Promise.all(values.generator()); + return data.some((x) => x); + } + case 2 /* PromiseOfPromises */: { + const data = await Promise.all(await values.generator()); + return data.some((x) => x); + } + } +} +exports.containsAsync = containsAsync; + + +/***/ }), + +/***/ 24363: +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.count = void 0; +/** + * Returns the number of elements in a sequence + * or represents how many elements in the specified sequence satisfy a condition + * if the predicate is specified. + * @param source A sequence that contains elements to be counted. + * @param predicate A function to test each element for a condition. Optional. + * @returns The number of elements in the input sequence. + */ +exports.count = (source, predicate) => { + if (predicate) { + return count2(source, predicate); + } + else { + return count1(source); + } +}; +const count1 = async (source) => { + const dataFunc = source.dataFunc; + switch (dataFunc.type) { + case 0 /* PromiseToArray */: + case 2 /* PromiseOfPromises */: + const arrayData = await source.toArray(); + return arrayData.length; + case 1 /* ArrayOfPromises */: + const promises = dataFunc.generator(); + return promises.length; + } +}; +const count2 = async (source, predicate) => { + const values = await source.toArray(); + let totalCount = 0; + for (let i = 0; i < values.length; i++) { + if (predicate(values[i]) === true) { + totalCount++; + } + } + return totalCount; +}; + + +/***/ }), + +/***/ 33435: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.countAsync = void 0; +const _nextIterationAsync_1 = __nccwpck_require__(1892); +/** + * Returns how many elements in the specified sequence satisfy a condition + * @param source A sequence that contains elements to be counted. + * @param predicate A function to test each element for a condition. + * @returns How many elements in the specified sequence satisfy the provided predicate. + */ +exports.countAsync = async (source, predicate) => { + const data = _nextIterationAsync_1.nextIterationAsync(source, predicate); + let countPromise; + switch (data.type) { + case 1 /* ArrayOfPromises */: + countPromise = Promise.all(data.generator()); + break; + case 2 /* PromiseOfPromises */: + countPromise = Promise.all(await data.generator()); + break; + case 0 /* PromiseToArray */: + default: + countPromise = data.generator(); + break; + } + let totalCount = 0; + for (const value of await countPromise) { + if (value) { + totalCount++; + } + } + return totalCount; +}; + + +/***/ }), + +/***/ 85186: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.distinct = void 0; +const shared_1 = __nccwpck_require__(25897); +const BasicParallelEnumerable_1 = __nccwpck_require__(76716); +/** + * Returns distinct elements from a sequence by using the default or specified equality comparer to compare values. + * @param source The sequence to remove duplicate elements from. + * @param comparer An IEqualityComparer to compare values. Optional. Defaults to Strict Equality Comparison. + * @returns An IParallelEnumerable that contains distinct elements from the source sequence. + */ +function distinct(source, comparer = shared_1.StrictEqualityComparer) { + const generator = async () => { + const distinctElements = []; + for (const item of await source.toArray()) { + const foundItem = distinctElements.find((x) => comparer(x, item)); + if (!foundItem) { + distinctElements.push(item); + } + } + return distinctElements; + }; + return new BasicParallelEnumerable_1.BasicParallelEnumerable({ + generator, + type: 0 /* PromiseToArray */, + }); +} +exports.distinct = distinct; + + +/***/ }), + +/***/ 81106: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.distinctAsync = void 0; +const BasicParallelEnumerable_1 = __nccwpck_require__(76716); +/** + * Returns distinct elements from a sequence by using the specified equality comparer to compare values. + * @param source The sequence to remove duplicate elements from. + * @param comparer An IAsyncEqualityComparer to compare values. + * @returns An IParallelEnumerable that contains distinct elements from the source sequence. + */ +function distinctAsync(source, comparer) { + const generator = async () => { + const distinctElements = []; + outerLoop: for (const item of await source.toArray()) { + for (const distinctElement of distinctElements) { + const found = await comparer(distinctElement, item); + if (found) { + continue outerLoop; + } + } + distinctElements.push(item); + } + return distinctElements; + }; + return new BasicParallelEnumerable_1.BasicParallelEnumerable({ + generator, + type: 0 /* PromiseToArray */, + }); +} +exports.distinctAsync = distinctAsync; + + +/***/ }), + +/***/ 50969: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.each = void 0; +const BasicParallelEnumerable_1 = __nccwpck_require__(76716); +const _nextIteration_1 = __nccwpck_require__(49931); +/** + * Performs a specified action on each element of the IParallelEnumerable + * @param source The source to iterate + * @param action The action to take an each element + * @returns A new IParallelEnumerable that executes the action lazily as you iterate. + */ +function each(source, action) { + return new BasicParallelEnumerable_1.BasicParallelEnumerable(_nextIteration_1.nextIteration(source, (x) => { + action(x); + return x; + })); +} +exports.each = each; + + +/***/ }), + +/***/ 86055: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.eachAsync = void 0; +const BasicParallelEnumerable_1 = __nccwpck_require__(76716); +const _nextIterationAsync_1 = __nccwpck_require__(1892); +/** + * Performs a specified action on each element of the IParallelEnumerable + * @param source The source to iterate + * @param action The action to take an each element + * @returns A new IParallelEnumerable that executes the action lazily as you iterate. + */ +function eachAsync(source, action) { + return new BasicParallelEnumerable_1.BasicParallelEnumerable(_nextIterationAsync_1.nextIterationAsync(source, async (x) => { + await action(x); + return x; + })); +} +exports.eachAsync = eachAsync; + + +/***/ }), + +/***/ 70959: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.elementAt = void 0; +const shared_1 = __nccwpck_require__(25897); +/** + * Returns the element at a specified index in a sequence. + * @param source An IEnumerable to return an element from. + * @param index The zero-based index of the element to retrieve. + * @throws {ArgumentOutOfRangeException} + * index is less than 0 or greater than or equal to the number of elements in source. + * @returns The element at the specified index in the sequence. + */ +async function elementAt(source, index) { + if (index < 0) { + throw new shared_1.ArgumentOutOfRangeException("index"); + } + const dataFunc = source.dataFunc; + switch (dataFunc.type) { + case 0 /* PromiseToArray */: + return dataFunc.generator().then((values) => { + if (index >= values.length) { + throw new shared_1.ArgumentOutOfRangeException("index"); + } + else { + return values[index]; + } + }); + case 1 /* ArrayOfPromises */: + return Promise.all(dataFunc.generator()).then((values) => { + if (index >= values.length) { + throw new shared_1.ArgumentOutOfRangeException("index"); + } + else { + return values[index]; + } + }); + case 2 /* PromiseOfPromises */: + return dataFunc.generator().then(async (values) => { + if (index >= values.length) { + throw new shared_1.ArgumentOutOfRangeException("index"); + } + else { + return await values[index]; + } + }); + } +} +exports.elementAt = elementAt; + + +/***/ }), + +/***/ 9571: +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.elementAtOrDefault = void 0; +/** + * Returns the element at a specified index in a sequence or a default value if the index is out of range. + * @param source An IEnumerable to return an element from. + * @param index The zero-based index of the element to retrieve. + * @returns + * default(TSource) if the index is outside the bounds of the source sequence; + * otherwise, the element at the specified position in the source sequence. + */ +function elementAtOrDefault(source, index) { + const dataFunc = source.dataFunc; + switch (dataFunc.type) { + case 0 /* PromiseToArray */: + return dataFunc.generator().then((values) => { + if (index >= values.length) { + return null; + } + else { + return values[index]; + } + }); + case 1 /* ArrayOfPromises */: + return Promise.all(dataFunc.generator()).then((values) => { + if (index >= values.length) { + return null; + } + else { + return values[index]; + } + }); + case 2 /* PromiseOfPromises */: + return dataFunc.generator().then(async (values) => { + if (index >= values.length) { + return null; + } + else { + return await values[index]; + } + }); + } +} +exports.elementAtOrDefault = elementAtOrDefault; + + +/***/ }), + +/***/ 15606: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.except = void 0; +const shared_1 = __nccwpck_require__(25897); +const BasicParallelEnumerable_1 = __nccwpck_require__(76716); +/** + * Produces the set difference of two sequences by using the comparer provided + * or EqualityComparer to compare values. + * @param first An IAsyncParallel whose elements that are not also in second will be returned. + * @param second An IAsyncParallel whose elements that also occur in the first sequence + * will cause those elements to be removed from the returned sequence. + * @param comparer An IEqualityComparer to compare values. Optional. + * @returns A sequence that contains the set difference of the elements of two sequences. + */ +function except( +// eslint-disable-next-line no-shadow +first, second, comparer = shared_1.StrictEqualityComparer) { + const generator = async () => { + const values = await Promise.all([first.toArray(), second.toArray()]); + const firstValues = values[0]; + const secondValues = values[1]; + const resultValues = []; + for (const firstItem of firstValues) { + let exists = false; + for (let j = 0; j < secondValues.length; j++) { + const secondItem = secondValues[j]; + if (comparer(firstItem, secondItem) === true) { + exists = true; + break; + } + } + if (exists === false) { + resultValues.push(firstItem); + } + } + return resultValues; + }; + return new BasicParallelEnumerable_1.BasicParallelEnumerable({ + generator, + type: 0 /* PromiseToArray */, + }); +} +exports.except = except; + + +/***/ }), + +/***/ 45674: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.exceptAsync = void 0; +const BasicParallelEnumerable_1 = __nccwpck_require__(76716); +/** + * Produces the set difference of two sequences by using the comparer provided to compare values. + * @param first An IAsyncParallel whose elements that are not also in second will be returned. + * @param second An IAsyncParallel whose elements that also occur in the first sequence + * will cause those elements to be removed from the returned sequence. + * @param comparer An IAsyncEqualityComparer to compare values. + * @returns A sequence that contains the set difference of the elements of two sequences. + */ +function exceptAsync( +// eslint-disable-next-line no-shadow +first, second, comparer) { + const generator = async () => { + const values = await Promise.all([first.toArray(), second.toArray()]); + const firstValues = values[0]; + const secondValues = values[1]; + const resultValues = []; + for (const firstItem of firstValues) { + let exists = false; + for (let j = 0; j < secondValues.length; j++) { + const secondItem = secondValues[j]; + if (await comparer(firstItem, secondItem) === true) { + exists = true; + break; + } + } + if (exists === false) { + resultValues.push(firstItem); + } + } + return resultValues; + }; + return new BasicParallelEnumerable_1.BasicParallelEnumerable({ + generator, + type: 0 /* PromiseToArray */, + }); +} +exports.exceptAsync = exceptAsync; + + +/***/ }), + +/***/ 48517: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.first = void 0; +const shared_1 = __nccwpck_require__(25897); +const toArray_1 = __nccwpck_require__(72537); +/** + * Returns the first element of a sequence. + * If predicate is specified, returns the first element in a sequence that satisfies a specified condition. + * @param source The IParallelEnumerable to return the first element of. + * @param predicate A function to test each element for a condition. Optional. + * @throws {InvalidOperationException} The source sequence is empty. + * @returns The first element in the specified sequence. + * If predicate is specified, + * the first element in the sequence that passes the test in the specified predicate function. + */ +function first(source, predicate) { + if (predicate) { + return first2(source, predicate); + } + else { + return first1(source); + } +} +exports.first = first; +const first1 = async (source) => { + const dataFunc = source.dataFunc; + switch (dataFunc.type) { + case 0 /* PromiseToArray */: { + const values = await dataFunc.generator(); + if (values.length === 0) { + throw new shared_1.InvalidOperationException(shared_1.ErrorString.NoElements); + } + else { + return values[0]; + } + } + case 1 /* ArrayOfPromises */: { + const promises = dataFunc.generator(); + if (promises.length === 0) { + throw new shared_1.InvalidOperationException(shared_1.ErrorString.NoElements); + } + else { + return await promises[0]; + } + } + case 2 /* PromiseOfPromises */: { + const promises = await dataFunc.generator(); + if (promises.length === 0) { + throw new shared_1.InvalidOperationException(shared_1.ErrorString.NoElements); + } + else { + return await promises[0]; + } + } + } +}; +const first2 = async (source, predicate) => { + const data = await toArray_1.toArray(source); + for (const value of data) { + if (predicate(value) === true) { + return value; + } + } + throw new shared_1.InvalidOperationException(shared_1.ErrorString.NoMatch); +}; + + +/***/ }), + +/***/ 36270: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.firstAsync = void 0; +const shared_1 = __nccwpck_require__(25897); +const toArray_1 = __nccwpck_require__(72537); +/** + * Returns the first element in a sequence that satisfies a specified condition. + * @param source An IParallelEnumerable to return an element from. + * @param predicate An async function to test each element for a condition. + * @throws {InvalidOperationException} No elements in Iteration matching predicate + * @returns The first element in the sequence that passes the test in the specified predicate function. + */ +async function firstAsync(source, predicate) { + const data = await toArray_1.toArray(source); + for (const value of data) { + if (await predicate(value) === true) { + return value; + } + } + throw new shared_1.InvalidOperationException(shared_1.ErrorString.NoMatch); +} +exports.firstAsync = firstAsync; + + +/***/ }), + +/***/ 33153: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.firstOrDefault = void 0; +const toArray_1 = __nccwpck_require__(72537); +/** + * Returns first element in sequence that satisfies predicate otherwise + * returns the first element in the sequence. Returns null if no value found. + * @param source An IParallelEnumerable to return an element from. + * @param predicate A function to test each element for a condition. Optional. + * @returns The first element in the sequence + * or the first element that passes the test in the specified predicate function. + * Returns null if no value found. + */ +function firstOrDefault(source, predicate) { + if (predicate) { + return firstOrDefault2(source, predicate); + } + else { + return firstOrDefault1(source); + } +} +exports.firstOrDefault = firstOrDefault; +const firstOrDefault1 = async (source) => { + const dataFunc = source.dataFunc; + switch (dataFunc.type) { + case 0 /* PromiseToArray */: { + const values = await dataFunc.generator(); + if (values.length === 0) { + return null; + } + else { + return values[0]; + } + } + case 1 /* ArrayOfPromises */: { + const promises = dataFunc.generator(); + if (promises.length === 0) { + return null; + } + else { + return await promises[0]; + } + } + case 2 /* PromiseOfPromises */: { + const promises = await dataFunc.generator(); + if (promises.length === 0) { + return null; + } + else { + return await promises[0]; + } + } + } +}; +const firstOrDefault2 = async (source, predicate) => { + const data = await toArray_1.toArray(source); + for (const value of data) { + if (predicate(value) === true) { + return value; + } + } + return null; +}; + + +/***/ }), + +/***/ 21327: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.firstOrDefaultAsync = void 0; +const toArray_1 = __nccwpck_require__(72537); +/** + * Returns first element in sequence that satisfies. Returns null if no value found. + * @param source An IParallelEnumerable to return an element from. + * @param predicate An async function to test each element for a condition. + * @returns The first element that passes the test in the specified predicate function. + * Returns null if no value found. + */ +async function firstOrDefaultAsync(source, predicate) { + const data = await toArray_1.toArray(source); + for (const value of data) { + if (await predicate(value) === true) { + return value; + } + } + return null; +} +exports.firstOrDefaultAsync = firstOrDefaultAsync; + + +/***/ }), + +/***/ 43589: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.groupBy = void 0; +const Grouping_1 = __nccwpck_require__(20891); +const BasicParallelEnumerable_1 = __nccwpck_require__(76716); +function groupBy(source, keySelector, comparer) { + if (comparer) { + return groupBy_0(source, keySelector, comparer); + } + else { + // eslint-disable-next-line @typescript-eslint/no-unsafe-return + return groupBy_0_Simple(source, keySelector); + } +} +exports.groupBy = groupBy; +function groupBy_0_Simple(source, keySelector) { + const generator = async () => { + const keyMap = {}; + for (const value of await source.toArray()) { + const key = keySelector(value); + const grouping = keyMap[key]; // TODO + if (grouping) { + grouping.push(value); + } + else { + keyMap[key] = new Grouping_1.Grouping(key, value); + } + } + const results = new Array(); + /* eslint-disable guard-for-in */ + for (const value in keyMap) { + results.push(keyMap[value]); + } + /* eslint-enable guard-for-in */ + return results; + }; + return new BasicParallelEnumerable_1.BasicParallelEnumerable({ + generator, + type: 0 /* PromiseToArray */, + }); +} +function groupBy_0(source, keySelector, comparer) { + const generator = async () => { + const keyMap = new Array(); + for (const value of await source.toArray()) { + const key = keySelector(value); + let found = false; + for (let i = 0; i < keyMap.length; i++) { + const group = keyMap[i]; + if (comparer(group.key, key)) { + group.push(value); + found = true; + break; + } + } + if (found === false) { + keyMap.push(new Grouping_1.Grouping(key, value)); + } + } + const results = new Array(); + for (const g of keyMap) { + results.push(g); + } + return results; + }; + return new BasicParallelEnumerable_1.BasicParallelEnumerable({ + generator, + type: 0 /* PromiseToArray */, + }); +} + + +/***/ }), + +/***/ 92477: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.groupByAsync = void 0; +const Grouping_1 = __nccwpck_require__(20891); +const BasicParallelEnumerable_1 = __nccwpck_require__(76716); +function groupByAsync(source, keySelector, comparer) { + if (comparer) { + return groupByAsync_0(source, keySelector, comparer); + } + else { + // eslint-disable-next-line @typescript-eslint/no-unsafe-return + return groupByAsync_0_Simple(source, keySelector); + } +} +exports.groupByAsync = groupByAsync; +function groupByAsync_0(source, keySelector, comparer) { + const generator = async () => { + const keyMap = new Array(); + for await (const value of source) { + const key = await keySelector(value); + let found = false; + for (let i = 0; i < keyMap.length; i++) { + const group = keyMap[i]; + if (await comparer(group.key, key) === true) { + group.push(value); + found = true; + break; + } + } + if (found === false) { + keyMap.push(new Grouping_1.Grouping(key, value)); + } + } + const results = new Array(); + for (const g of keyMap) { + results.push(g); + } + return results; + }; + return new BasicParallelEnumerable_1.BasicParallelEnumerable({ + generator, + type: 0 /* PromiseToArray */, + }); +} +function groupByAsync_0_Simple(source, keySelector) { + const generator = async () => { + const keyMap = {}; + for (const value of await source.toArray()) { + const key = await keySelector(value); + const grouping = keyMap[key]; + if (grouping) { + grouping.push(value); + } + else { + keyMap[key] = new Grouping_1.Grouping(key, value); + } + } + const results = new Array(); + /* eslint-disable guard-for-in */ + for (const value in keyMap) { + results.push(keyMap[value]); + } + /* eslint-enable guard-for-in */ + return results; + }; + return new BasicParallelEnumerable_1.BasicParallelEnumerable({ + generator, + type: 0 /* PromiseToArray */, + }); +} + + +/***/ }), + +/***/ 96630: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.groupByWithSel = void 0; +const Grouping_1 = __nccwpck_require__(20891); +const BasicParallelEnumerable_1 = __nccwpck_require__(76716); +function groupByWithSel(source, keySelector, elementSelector, comparer) { + if (comparer) { + return groupBy1(source, keySelector, elementSelector, comparer); + } + else { + return groupBy1Simple(source, keySelector, elementSelector); + } +} +exports.groupByWithSel = groupByWithSel; +const groupBy1 = (source, keySelector, elementSelector, comparer) => { + const generator = async () => { + const keyMap = new Array(); + for await (const value of source) { + const key = keySelector(value); + let found = false; + for (let i = 0; i < keyMap.length; i++) { + const group = keyMap[i]; + if (comparer(group.key, key)) { + group.push(elementSelector(value)); + found = true; + break; + } + } + if (found === false) { + const element = elementSelector(value); + keyMap.push(new Grouping_1.Grouping(key, element)); + } + } + const results = new Array(); + for (const value of keyMap) { + results.push(value); + } + return results; + }; + return new BasicParallelEnumerable_1.BasicParallelEnumerable({ + generator, + type: 0 /* PromiseToArray */, + }); +}; +const groupBy1Simple = (source, keySelector, elementSelector) => { + // generate(): AsyncIterableIterator> + const generator = async () => { + const keyMap = {}; + for (const value of await source.toArray()) { + const key = keySelector(value); + const grouping = keyMap[key]; + const element = elementSelector(value); + if (grouping) { + grouping.push(element); + } + else { + keyMap[key] = new Grouping_1.Grouping(key, element); + } + } + /* eslint-disable guard-for-in */ + const results = new Array(); + for (const value in keyMap) { + results.push(keyMap[value]); + } + /* eslint-enable guard-for-in */ + return results; + }; + return new BasicParallelEnumerable_1.BasicParallelEnumerable({ + generator, + type: 0 /* PromiseToArray */, + }); +}; + + +/***/ }), + +/***/ 2166: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.intersect = void 0; +const shared_1 = __nccwpck_require__(25897); +const BasicParallelEnumerable_1 = __nccwpck_require__(76716); +/** + * Produces the set intersection of two sequences by using the specified IEqualityComparer to compare values. + * If not comparer is specified, uses the @see {StrictEqualityComparer} + * @param first An IParallelEnumerable whose distinct elements that also appear in second will be returned. + * @param second An IAsyncParallel whose distinct elements that also appear in the first sequence will be returned. + * @param comparer An IAsyncEqualityComparer to compare values. Optional. + * @returns A sequence that contains the elements that form the set intersection of two sequences. + */ +function intersect( +// eslint-disable-next-line no-shadow +first, second, comparer = shared_1.StrictEqualityComparer) { + const generator = async () => { + const firstResults = await first.distinct(comparer).toArray(); + if (firstResults.length === 0) { + return []; + } + const secondResults = await second.toArray(); + const results = new Array(); + for (let i = 0; i < firstResults.length; i++) { + const firstValue = firstResults[i]; + for (let j = 0; j < secondResults.length; j++) { + const secondValue = secondResults[j]; + if (comparer(firstValue, secondValue) === true) { + results.push(firstValue); + break; + } + } + } + return results; + }; + return new BasicParallelEnumerable_1.BasicParallelEnumerable({ + generator, + type: 0 /* PromiseToArray */, + }); +} +exports.intersect = intersect; + + +/***/ }), + +/***/ 93650: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.intersectAsync = void 0; +const BasicParallelEnumerable_1 = __nccwpck_require__(76716); +/** + * Produces the set intersection of two sequences by using the specified IAsyncEqualityComparer to compare values. + * @param first An IParallelEnumerable whose distinct elements that also appear in second will be returned. + * @param second An IAsyncParallel whose distinct elements that also appear in the first sequence will be returned. + * @param comparer An IAsyncEqualityComparer to compare values. + * @returns A sequence that contains the elements that form the set intersection of two sequences. + */ +function intersectAsync( +// eslint-disable-next-line no-shadow +first, second, comparer) { + const generator = async () => { + const firstResults = await first.distinctAsync(comparer).toArray(); + if (firstResults.length === 0) { + return []; + } + const secondResults = await second.toArray(); + const results = new Array(); + for (let i = 0; i < firstResults.length; i++) { + const firstValue = firstResults[i]; + for (let j = 0; j < secondResults.length; j++) { + const secondValue = secondResults[j]; + if (await comparer(firstValue, secondValue) === true) { + results.push(firstValue); + break; + } + } + } + return results; + }; + return new BasicParallelEnumerable_1.BasicParallelEnumerable({ + generator, + type: 0 /* PromiseToArray */, + }); +} +exports.intersectAsync = intersectAsync; + + +/***/ }), + +/***/ 57048: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.join = void 0; +const shared_1 = __nccwpck_require__(25897); +const BasicParallelEnumerable_1 = __nccwpck_require__(76716); +/** + * Correlates the elements of two sequences based on matching keys. + * A specified IEqualityComparer is used to compare keys or the strict equality comparer. + * @param outer The first sequence to join. + * @param inner The sequence to join to the first sequence. + * @param outerKeySelector A function to extract the join key from each element of the first sequence. + * @param innerKeySelector A function to extract the join key from each element of the second sequence. + * @param resultSelector A function to create a result element from two matching elements. + * @param comparer An IEqualityComparer to hash and compare keys. Optional. + * @returns An IParallelEnumerable that has elements of type TResult that + * are obtained by performing an inner join on two sequences. + */ +function join(outer, inner, outerKeySelector, innerKeySelector, resultSelector, comparer = shared_1.StrictEqualityComparer) { + const generator = async () => { + const innerOuter = await Promise.all([inner.toArray(), outer.toArray()]); + const innerArray = innerOuter[0]; + const outerArray = innerOuter[1]; + const results = new Array(); + for (const o of outerArray) { + const outerKey = outerKeySelector(o); + for (const i of innerArray) { + const innerKey = innerKeySelector(i); + if (comparer(outerKey, innerKey) === true) { + results.push(resultSelector(o, i)); + } + } + } + return results; + }; + return new BasicParallelEnumerable_1.BasicParallelEnumerable({ + generator, + type: 0 /* PromiseToArray */, + }); +} +exports.join = join; + + +/***/ }), + +/***/ 30815: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.last = void 0; +const shared_1 = __nccwpck_require__(25897); +/** + * Returns the last element of a sequence. + * If predicate is specified, the last element of a sequence that satisfies a specified condition. + * @param source An IParallelEnumerable to return the last element of. + * @param predicate A function to test each element for a condition. Optional. + * @throws {InvalidOperationException} The source sequence is empty. + * @returns The value at the last position in the source sequence + * or the last element in the sequence that passes the test in the specified predicate function. + */ +function last(source, predicate) { + if (predicate) { + return last2(source, predicate); + } + else { + return last1(source); + } +} +exports.last = last; +const last1 = async (source) => { + const dataFunc = source.dataFunc; + switch (dataFunc.type) { + case 0 /* PromiseToArray */: { + const values = await dataFunc.generator(); + if (values.length === 0) { + throw new shared_1.InvalidOperationException(shared_1.ErrorString.NoElements); + } + else { + return values[values.length - 1]; + } + } + case 1 /* ArrayOfPromises */: { + const promises = dataFunc.generator(); + if (promises.length === 0) { + throw new shared_1.InvalidOperationException(shared_1.ErrorString.NoElements); + } + else { + return await promises[promises.length - 1]; + } + } + case 2 /* PromiseOfPromises */: { + const promises = await dataFunc.generator(); + if (promises.length === 0) { + throw new shared_1.InvalidOperationException(shared_1.ErrorString.NoElements); + } + else { + return await promises[promises.length - 1]; + } + } + } +}; +const last2 = async (source, predicate) => { + const dataFunc = source.dataFunc; + switch (dataFunc.type) { + case 0 /* PromiseToArray */: { + const values = await dataFunc.generator(); + // Promise Array - Predicate + for (let i = values.length - 1; i >= 0; i--) { + const value = values[i]; + if (predicate(value)) { + return value; + } + } + break; + } + case 1 /* ArrayOfPromises */: { + const promises = dataFunc.generator(); + // Promise Array - Predicate + for (let i = promises.length - 1; i >= 0; i--) { + const value = await promises[i]; + if (predicate(value)) { + return value; + } + } + break; + } + case 2 /* PromiseOfPromises */: { + const promises = await dataFunc.generator(); + // Promise Array - Predicate + for (let i = promises.length - 1; i >= 0; i--) { + const value = await promises[i]; + if (predicate(value)) { + return value; + } + } + break; + } + } + throw new shared_1.InvalidOperationException(shared_1.ErrorString.NoMatch); +}; + + +/***/ }), + +/***/ 2145: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.lastAsync = void 0; +const shared_1 = __nccwpck_require__(25897); +/** + * Returns the last element of a sequence that satisfies a specified condition. + * @param source An IParallelEnumerable to return the last element of. + * @param predicate A function to test each element for a condition. + * @throws {InvalidOperationException} The source sequence is empty. + * @returns The last element in the sequence that passes the test in the specified predicate function. + */ +async function lastAsync(source, predicate) { + const dataFunc = source.dataFunc; + switch (dataFunc.type) { + case 0 /* PromiseToArray */: { + const values = await dataFunc.generator(); + // Promise Array - Predicate + for (let i = values.length - 1; i >= 0; i--) { + const value = values[i]; + if (await predicate(value) === true) { + return value; + } + } + break; + } + case 1 /* ArrayOfPromises */: { + const promises = dataFunc.generator(); + // Promise Array - Predicate + for (let i = promises.length - 1; i >= 0; i--) { + const value = await promises[i]; + if (await predicate(value) === true) { + return value; + } + } + break; + } + case 2 /* PromiseOfPromises */: { + const promises = await dataFunc.generator(); + // Promise Array - Predicate + for (let i = promises.length - 1; i >= 0; i--) { + const value = await promises[i]; + if (await predicate(value) === true) { + return value; + } + } + break; + } + } + throw new shared_1.InvalidOperationException(shared_1.ErrorString.NoMatch); +} +exports.lastAsync = lastAsync; + + +/***/ }), + +/***/ 47621: +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.lastOrDefault = void 0; +/** + * Returns the last element of a sequence. + * If predicate is specified, the last element of a sequence that satisfies a specified condition. + * @param source An IParallelEnumerable to return the last element of. + * @param predicate A function to test each element for a condition. Optional. + * @returns The value at the last position in the source sequence + * or the last element in the sequence that passes the test in the specified predicate function. + */ +function lastOrDefault(source, predicate) { + if (predicate) { + return lastOrDefault2(source, predicate); + } + else { + return lastOrDefault1(source); + } +} +exports.lastOrDefault = lastOrDefault; +const lastOrDefault1 = async (source) => { + const dataFunc = source.dataFunc; + switch (dataFunc.type) { + case 0 /* PromiseToArray */: { + const values = await dataFunc.generator(); + if (values.length === 0) { + return null; + } + else { + return values[values.length - 1]; + } + } + case 1 /* ArrayOfPromises */: { + const promises = dataFunc.generator(); + if (promises.length === 0) { + return null; + } + else { + return await promises[promises.length - 1]; + } + } + case 2 /* PromiseOfPromises */: { + const promises = await dataFunc.generator(); + if (promises.length === 0) { + return null; + } + else { + return await promises[promises.length - 1]; + } + } + } +}; +const lastOrDefault2 = async (source, predicate) => { + const dataFunc = source.dataFunc; + switch (dataFunc.type) { + case 0 /* PromiseToArray */: { + const values = await dataFunc.generator(); + for (let i = values.length - 1; i >= 0; i--) { + const value = values[i]; + if (predicate(value)) { + return value; + } + } + break; + } + case 1 /* ArrayOfPromises */: { + const promises = dataFunc.generator(); + for (let i = promises.length - 1; i >= 0; i--) { + const value = await promises[i]; + if (predicate(value)) { + return value; + } + } + break; + } + case 2 /* PromiseOfPromises */: { + const promises = await dataFunc.generator(); + for (let i = promises.length - 1; i >= 0; i--) { + const value = await promises[i]; + if (predicate(value)) { + return value; + } + } + break; + } + } + return null; +}; + + +/***/ }), + +/***/ 1370: +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.lastOrDefaultAsync = void 0; +/** + * Returns the last element of a sequence that satisfies a specified condition. + * @param source An IParallelEnumerable to return the last element of. + * @param predicate A function to test each element for a condition. + * @returns The last element in the sequence that passes the test in the specified predicate function. + * Null if no elements. + */ +async function lastOrDefaultAsync(source, predicate) { + const dataFunc = source.dataFunc; + switch (dataFunc.type) { + case 0 /* PromiseToArray */: { + const values = await dataFunc.generator(); + for (let i = values.length - 1; i >= 0; i--) { + const value = values[i]; + if (await predicate(value) === true) { + return value; + } + } + break; + } + case 1 /* ArrayOfPromises */: { + const promises = dataFunc.generator(); + for (let i = promises.length - 1; i >= 0; i--) { + const value = await promises[i]; + if (await predicate(value) === true) { + return value; + } + } + break; + } + case 2 /* PromiseOfPromises */: { + const promises = await dataFunc.generator(); + for (let i = promises.length - 1; i >= 0; i--) { + const value = await promises[i]; + if (await predicate(value) === true) { + return value; + } + } + break; + } + } + return null; +} +exports.lastOrDefaultAsync = lastOrDefaultAsync; + + +/***/ }), + +/***/ 53661: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.max = void 0; +const shared_1 = __nccwpck_require__(25897); +const BasicParallelEnumerable_1 = __nccwpck_require__(76716); +const _nextIteration_1 = __nccwpck_require__(49931); +async function max(source, selector) { + let maxInfo; + if (selector) { + const dataFunc = _nextIteration_1.nextIteration(source, selector); + maxInfo = await new BasicParallelEnumerable_1.BasicParallelEnumerable(dataFunc).toArray(); + } + else { + maxInfo = await source.toArray(); + } + if (maxInfo.length === 0) { + throw new shared_1.InvalidOperationException(shared_1.ErrorString.NoElements); + } + return Math.max.apply(null, maxInfo); +} +exports.max = max; + + +/***/ }), + +/***/ 91121: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.maxAsync = void 0; +const shared_1 = __nccwpck_require__(25897); +const BasicParallelEnumerable_1 = __nccwpck_require__(76716); +const _nextIterationAsync_1 = __nccwpck_require__(1892); +/** + * Invokes an async transform function on each element of a sequence and returns the maximum value. + * @param source A sequence of values to determine the maximum value of. + * @param selector A transform function to apply to each element. + * @throws {InvalidOperationException} source contains no elements. + * @returns The maximum value in the sequence. + */ +async function maxAsync(source, selector) { + const dataFunc = _nextIterationAsync_1.nextIterationAsync(source, selector); + const maxInfo = await new BasicParallelEnumerable_1.BasicParallelEnumerable(dataFunc).toArray(); + if (maxInfo.length === 0) { + throw new shared_1.InvalidOperationException(shared_1.ErrorString.NoElements); + } + return Math.max.apply(null, maxInfo); +} +exports.maxAsync = maxAsync; + + +/***/ }), + +/***/ 62299: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.min = void 0; +const shared_1 = __nccwpck_require__(25897); +const BasicParallelEnumerable_1 = __nccwpck_require__(76716); +const _nextIteration_1 = __nccwpck_require__(49931); +async function min(source, selector) { + let minInfo; + if (selector) { + const dataFunc = _nextIteration_1.nextIteration(source, selector); + minInfo = await new BasicParallelEnumerable_1.BasicParallelEnumerable(dataFunc) + .toArray(); + } + else { + minInfo = await source.toArray(); + } + if (minInfo.length === 0) { + throw new shared_1.InvalidOperationException(shared_1.ErrorString.NoElements); + } + return Math.min.apply(null, minInfo); +} +exports.min = min; + + +/***/ }), + +/***/ 49111: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.minAsync = void 0; +const shared_1 = __nccwpck_require__(25897); +const BasicParallelEnumerable_1 = __nccwpck_require__(76716); +const _nextIterationAsync_1 = __nccwpck_require__(1892); +/** + * Invokes a transform function on each element of a sequence and returns the minimum value. + * @param source A sequence of values to determine the minimum value of. + * @param selector A transform function to apply to each element. + * @throws {InvalidOperationException} source contains no elements. + * @returns The minimum value in the sequence. + */ +async function minAsync(source, selector) { + const dataFunc = _nextIterationAsync_1.nextIterationAsync(source, selector); + const maxInfo = await new BasicParallelEnumerable_1.BasicParallelEnumerable(dataFunc).toArray(); + if (maxInfo.length === 0) { + throw new shared_1.InvalidOperationException(shared_1.ErrorString.NoElements); + } + return Math.min.apply(null, maxInfo); +} +exports.minAsync = minAsync; + + +/***/ }), + +/***/ 32534: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.ofType = void 0; +const BasicParallelEnumerable_1 = __nccwpck_require__(76716); +/** + * Applies a type filter to a source iteration + * @param source Async Iteration to Filtery by Type + * @param type Either value for typeof or a consturctor function + * @returns Values that match the type string or are instance of type + */ +function ofType(source, type) { + const typeCheck = typeof type === "string" ? + ((x) => typeof x === type) : + ((x) => x instanceof type); + const data = async () => (await source.toArray()).filter(typeCheck); + return new BasicParallelEnumerable_1.BasicParallelEnumerable({ + generator: data, + type: 0 /* PromiseToArray */, + }); +} +exports.ofType = ofType; + + +/***/ }), + +/***/ 10211: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.orderBy = void 0; +const OrderedParallelEnumerable_1 = __nccwpck_require__(42166); +/** + * Sorts the elements of a sequence in ascending order by using a specified or default comparer. + * @param source A sequence of values to order. + * @param keySelector A function to extract a key from an element. + * @param comparer An IComparer to compare keys. Optional. + * @returns An IOrderedParallelEnumerable whose elements are sorted according to a key. + */ +function orderBy(source, keySelector, comparer) { + return OrderedParallelEnumerable_1.OrderedParallelEnumerable.generate(source, keySelector, true, comparer); +} +exports.orderBy = orderBy; + + +/***/ }), + +/***/ 8744: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.orderByAsync = void 0; +const OrderedParallelEnumerable_1 = __nccwpck_require__(42166); +/** + * Sorts the elements of a sequence in ascending order by using a specified comparer. + * @param source A sequence of values to order. + * @param keySelector An async function to extract a key from an element. + * @param comparer An IComparer to compare keys. + * @returns An IOrderedParallelEnumerable whose elements are sorted according to a key. + */ +function orderByAsync(source, keySelector, comparer) { + return OrderedParallelEnumerable_1.OrderedParallelEnumerable.generateAsync(source, keySelector, true, comparer); +} +exports.orderByAsync = orderByAsync; + + +/***/ }), + +/***/ 41268: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.orderByDescending = void 0; +const OrderedParallelEnumerable_1 = __nccwpck_require__(42166); +/** + * Sorts the elements of a sequence in descending order by using a specified or default comparer. + * @param source A sequence of values to order. + * @param keySelector A function to extract a key from an element. + * @param comparer An IComparer to compare keys. Optional. + * @returns An IOrderedParallelEnumerable whose elements are sorted in descending order according to a key. + */ +function orderByDescending(source, keySelector, comparer) { + return OrderedParallelEnumerable_1.OrderedParallelEnumerable.generate(source, keySelector, false, comparer); +} +exports.orderByDescending = orderByDescending; + + +/***/ }), + +/***/ 58011: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.orderByDescendingAsync = void 0; +const OrderedParallelEnumerable_1 = __nccwpck_require__(42166); +/** + * Sorts the elements of a sequence in descending order by using a specified comparer. + * @param source A sequence of values to order. + * @param keySelector An async function to extract a key from an element. + * @param comparer An IComparer to compare keys. + * @returns An IOrderedParallelEnumerable whose elements are sorted in descending order according to a key. + */ +function orderByDescendingAsync(source, keySelector, comparer) { + return OrderedParallelEnumerable_1.OrderedParallelEnumerable.generateAsync(source, keySelector, false, comparer); +} +exports.orderByDescendingAsync = orderByDescendingAsync; + + +/***/ }), + +/***/ 69476: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.reverse = void 0; +const BasicParallelEnumerable_1 = __nccwpck_require__(76716); +/** + * Inverts the order of the elements in a sequence. + * @param source A sequence of values to reverse. + * @returns A sequence whose elements correspond to those of the input sequence in reverse order. + */ +function reverse(source) { + const dataFunc = source.dataFunc; + switch (dataFunc.type) { + case 1 /* ArrayOfPromises */: { + const generator = () => { + return dataFunc.generator().reverse(); + }; + return new BasicParallelEnumerable_1.BasicParallelEnumerable({ + generator, + type: dataFunc.type, + }); + } + case 2 /* PromiseOfPromises */: { + const generator = async () => { + const array = await dataFunc.generator(); + return array.reverse(); + }; + return new BasicParallelEnumerable_1.BasicParallelEnumerable({ + generator, + type: dataFunc.type, + }); + } + case 0 /* PromiseToArray */: { + const generator = async () => { + const array = await dataFunc.generator(); + return array.reverse(); + }; + return new BasicParallelEnumerable_1.BasicParallelEnumerable({ + generator, + type: dataFunc.type, + }); + } + } +} +exports.reverse = reverse; + + +/***/ }), + +/***/ 41611: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.select = void 0; +const BasicParallelEnumerable_1 = __nccwpck_require__(76716); +const _nextIteration_1 = __nccwpck_require__(49931); +const _nextIterationWithIndex_1 = __nccwpck_require__(41734); +function select(source, key) { + if (typeof key === "function") { + if (key.length === 1) { + return new BasicParallelEnumerable_1.BasicParallelEnumerable(_nextIteration_1.nextIteration(source, key)); + } + else { + return new BasicParallelEnumerable_1.BasicParallelEnumerable(_nextIterationWithIndex_1.nextIterationWithIndex(source, key)); + } + } + else { + // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access + return new BasicParallelEnumerable_1.BasicParallelEnumerable(_nextIteration_1.nextIteration(source, (x) => x[key])); + } +} +exports.select = select; + + +/***/ }), + +/***/ 31803: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.selectAsync = void 0; +const BasicParallelEnumerable_1 = __nccwpck_require__(76716); +const _nextIterationAsync_1 = __nccwpck_require__(1892); +const _nextIterationWithIndexAsync_1 = __nccwpck_require__(61983); +function selectAsync(source, keyOrSelector) { + let generator; + if (typeof keyOrSelector === "function") { + if (keyOrSelector.length === 1) { + generator = _nextIterationAsync_1.nextIterationAsync(source, keyOrSelector); + } + else { + generator = _nextIterationWithIndexAsync_1.nextIterationWithIndexAsync(source, keyOrSelector); + } + } + else { + generator = _nextIterationAsync_1.nextIterationAsync(source, (x) => (x[keyOrSelector])); + } + return new BasicParallelEnumerable_1.BasicParallelEnumerable(generator); +} +exports.selectAsync = selectAsync; + + +/***/ }), + +/***/ 62637: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.selectMany = void 0; +const BasicParallelEnumerable_1 = __nccwpck_require__(76716); +const _nextIteration_1 = __nccwpck_require__(49931); +const _nextIterationWithIndex_1 = __nccwpck_require__(41734); +function selectMany(source, selector) { + const generator = async () => { + let values; + if (typeof selector === "function") { + if (selector.length === 1) { + values = _nextIteration_1.nextIteration(source, selector); + } + else { + values = _nextIterationWithIndex_1.nextIterationWithIndex(source, selector); + } + } + else { + // eslint-disable-next-line @typescript-eslint/no-unsafe-return, @typescript-eslint/no-unsafe-member-access + values = _nextIteration_1.nextIteration(source, (x) => x[selector]); + } + const valuesArray = []; + switch (values.type) { + case 0 /* PromiseToArray */: { + for (const outer of await values.generator()) { + for (const y of outer) { + valuesArray.push(y); + } + } + break; + } + case 1 /* ArrayOfPromises */: { + for (const outer of values.generator()) { + for (const y of await outer) { + valuesArray.push(y); + } + } + break; + } + case 2 /* PromiseOfPromises */: { + for (const outer of await values.generator()) { + for (const y of await outer) { + valuesArray.push(y); + } + } + break; + } + } + return valuesArray; + }; + return new BasicParallelEnumerable_1.BasicParallelEnumerable({ + generator, + type: 0 /* PromiseToArray */, + }); +} +exports.selectMany = selectMany; + + +/***/ }), + +/***/ 55961: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.selectManyAsync = void 0; +const BasicParallelEnumerable_1 = __nccwpck_require__(76716); +const _nextIterationAsync_1 = __nccwpck_require__(1892); +const _nextIterationWithIndexAsync_1 = __nccwpck_require__(61983); +/** + * Projects each element of a sequence to an IParallelEnumerable + * and flattens the resulting sequences into one sequence. + * @param source A sequence of values to project. + * @param selector A transform function to apply to each element. + * @returns An IParallelEnumerable whose elements are the result of invoking the + * one-to-many transform function on each element of the input sequence. + */ +function selectManyAsync(source, selector) { + const generator = async () => { + let values; + if (selector.length === 1) { + values = _nextIterationAsync_1.nextIterationAsync(source, selector); + } + else { + values = _nextIterationWithIndexAsync_1.nextIterationWithIndexAsync(source, selector); + } + const valuesArray = []; + switch (values.type) { + case 0 /* PromiseToArray */: { + for (const outer of await values.generator()) { + for (const y of outer) { + valuesArray.push(y); + } + } + break; + } + case 1 /* ArrayOfPromises */: { + for (const outer of values.generator()) { + for (const y of await outer) { + valuesArray.push(y); + } + } + break; + } + case 2 /* PromiseOfPromises */: { + for (const outer of await values.generator()) { + for (const y of await outer) { + valuesArray.push(y); + } + } + break; + } + } + return valuesArray; + }; + return new BasicParallelEnumerable_1.BasicParallelEnumerable({ + generator, + type: 0 /* PromiseToArray */, + }); +} +exports.selectManyAsync = selectManyAsync; + + +/***/ }), + +/***/ 62790: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.sequenceEquals = void 0; +const shared_1 = __nccwpck_require__(25897); +/** + * Compares two parallel sequences to see if they are equal using a comparer function. + * @param first First Sequence + * @param second Second Sequence + * @param comparer Comparer + * @returns Whether or not the two iterations are equal + */ +async function sequenceEquals( +// eslint-disable-next-line no-shadow +first, second, comparer = shared_1.StrictEqualityComparer) { + const firstArray = await first.toArray(); + const secondArray = await second.toArray(); + if (firstArray.length !== secondArray.length) { + return false; + } + for (let i = 0; i < firstArray.length; i++) { + const firstResult = firstArray[i]; + const secondResult = secondArray[i]; + if (comparer(firstResult, secondResult) === false) { + return false; + } + } + return true; +} +exports.sequenceEquals = sequenceEquals; + + +/***/ }), + +/***/ 83839: +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.sequenceEqualsAsync = void 0; +/** + * Compares two parallel iterables to see if they are equal using a async comparer function. + * @param first First Sequence + * @param second Second Sequence + * @param comparer Async Comparer + * @returns Whether or not the two iterations are equal + */ +async function sequenceEqualsAsync( +// eslint-disable-next-line no-shadow +first, second, comparer) { + const firstArray = await first.toArray(); + const secondArray = await second.toArray(); + if (firstArray.length !== secondArray.length) { + return false; + } + for (let i = 0; i < firstArray.length; i++) { + const firstResult = firstArray[i]; + const secondResult = secondArray[i]; + if (await comparer(firstResult, secondResult) === false) { + return false; + } + } + return true; +} +exports.sequenceEqualsAsync = sequenceEqualsAsync; + + +/***/ }), + +/***/ 9360: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.single = void 0; +const shared_1 = __nccwpck_require__(25897); +const toArray_1 = __nccwpck_require__(72537); +/** + * Returns the only element of a sequence that satisfies a specified condition (if specified), + * and throws an exception if more than one such element exists. + * @param source An IParallelEnumerable to return a single element from. + * @param predicate A function to test an element for a condition. (Optional) + * @throws {InvalidOperationException} No element satisfies the condition in predicate. OR + * More than one element satisfies the condition in predicate. OR + * The source sequence is empty. + * @returns The single element of the input sequence that satisfies a condition. + */ +function single(source, predicate) { + if (predicate) { + return single2(source, predicate); + } + else { + return single1(source); + } +} +exports.single = single; +const single1 = async (source) => { + const dataFunc = source.dataFunc; + switch (dataFunc.type) { + case 0 /* PromiseToArray */: { + const results = await dataFunc.generator(); + if (results.length > 1) { + throw new shared_1.InvalidOperationException(shared_1.ErrorString.MoreThanOneElement); + } + else if (results.length === 0) { + throw new shared_1.InvalidOperationException(shared_1.ErrorString.NoElements); + } + return results[0]; + } + case 1 /* ArrayOfPromises */: { + const results = dataFunc.generator(); + if (results.length > 1) { + throw new shared_1.InvalidOperationException(shared_1.ErrorString.MoreThanOneElement); + } + else if (results.length === 0) { + throw new shared_1.InvalidOperationException(shared_1.ErrorString.NoElements); + } + return results[0]; + } + case 2 /* PromiseOfPromises */: { + const results = await dataFunc.generator(); + if (results.length > 1) { + throw new shared_1.InvalidOperationException(shared_1.ErrorString.MoreThanOneElement); + } + else if (results.length === 0) { + throw new shared_1.InvalidOperationException(shared_1.ErrorString.NoElements); + } + return await results[0]; + } + } +}; +const single2 = async (source, predicate) => { + const results = await toArray_1.toArray(source); + let hasValue = false; + let singleValue = null; + for (const value of results) { + if (predicate(value)) { + if (hasValue === true) { + throw new shared_1.InvalidOperationException(shared_1.ErrorString.MoreThanOneMatchingElement); + } + else { + hasValue = true; + singleValue = value; + } + } + } + if (hasValue === false) { + throw new shared_1.InvalidOperationException(shared_1.ErrorString.NoMatch); + } + return singleValue; +}; + + +/***/ }), + +/***/ 60389: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.singleAsync = void 0; +const shared_1 = __nccwpck_require__(25897); +const toArray_1 = __nccwpck_require__(72537); +/** + * Returns the only element of a sequence that satisfies a specified condition, + * and throws an exception if more than one such element exists. + * @param source An IParallelEnumerable to return a single element from. + * @param predicate A function to test an element for a condition. + * @throws {InvalidOperationException} + * No element satisfies the condition in predicate. OR + * More than one element satisfies the condition in predicate. OR + * The source sequence is empty. + * @returns The single element of the input sequence that satisfies a condition. + */ +async function singleAsync(source, predicate) { + const results = await toArray_1.toArray(source); + let hasValue = false; + let singleValue = null; + for (const value of results) { + if (await predicate(value) === true) { + if (hasValue === true) { + throw new shared_1.InvalidOperationException(shared_1.ErrorString.MoreThanOneMatchingElement); + } + else { + hasValue = true; + singleValue = value; + } + } + } + if (hasValue === false) { + throw new shared_1.InvalidOperationException(shared_1.ErrorString.NoMatch); + } + return singleValue; +} +exports.singleAsync = singleAsync; + + +/***/ }), + +/***/ 6648: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.singleOrDefault = void 0; +const shared_1 = __nccwpck_require__(25897); +const toArray_1 = __nccwpck_require__(72537); +/** + * If predicate is specified returns the only element of a sequence that satisfies a specified condition, + * ootherwise returns the only element of a sequence. Returns a default value if no such element exists. + * @param source An IParallelEnumerable to return a single element from. + * @param predicate A function to test an element for a condition. Optional. + * @throws {InvalidOperationException} + * If predicate is specified more than one element satisfies the condition in predicate, + * otherwise the input sequence contains more than one element. + * @returns The single element of the input sequence that satisfies the condition, + * or null if no such element is found. + */ +exports.singleOrDefault = (source, predicate) => { + if (predicate) { + return singleOrDefault2(source, predicate); + } + else { + return singleOrDefault1(source); + } +}; +const singleOrDefault1 = async (source) => { + const dataFunc = source.dataFunc; + switch (dataFunc.type) { + case 0 /* PromiseToArray */: { + const results = await dataFunc.generator(); + if (results.length > 1) { + throw new shared_1.InvalidOperationException(shared_1.ErrorString.MoreThanOneElement); + } + else if (results.length === 0) { + return null; + } + return results[0]; + } + case 1 /* ArrayOfPromises */: { + const results = dataFunc.generator(); + if (results.length > 1) { + throw new shared_1.InvalidOperationException(shared_1.ErrorString.MoreThanOneElement); + } + else if (results.length === 0) { + return null; + } + return results[0]; + } + case 2 /* PromiseOfPromises */: { + const results = await dataFunc.generator(); + if (results.length > 1) { + throw new shared_1.InvalidOperationException(shared_1.ErrorString.MoreThanOneElement); + } + else if (results.length === 0) { + return null; + } + return await results[0]; + } + } +}; +const singleOrDefault2 = async (source, predicate) => { + const results = await toArray_1.toArray(source); + let hasValue = false; + let singleValue = null; + for (const value of results) { + if (predicate(value)) { + if (hasValue === true) { + throw new shared_1.InvalidOperationException(shared_1.ErrorString.MoreThanOneElement); + } + else { + hasValue = true; + singleValue = value; + } + } + } + return singleValue; +}; + + +/***/ }), + +/***/ 73096: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.singleOrDefaultAsync = void 0; +const shared_1 = __nccwpck_require__(25897); +const toArray_1 = __nccwpck_require__(72537); +/** + * If predicate is specified returns the only element of a sequence that satisfies a specified condition, + * ootherwise returns the only element of a sequence. Returns a default value if no such element exists. + * @param source An IParallelEnumerable to return a single element from. + * @param predicate A function to test an element for a condition. Optional. + * @throws {InvalidOperationException} + * If predicate is specified more than one element satisfies the condition in predicate, + * otherwise the input sequence contains more than one element. + * @returns The single element of the input sequence that satisfies the condition, + * or null if no such element is found. + */ +async function singleOrDefaultAsync(source, predicate) { + const results = await toArray_1.toArray(source); + let hasValue = false; + let singleValue = null; + for (const value of results) { + if (await predicate(value) === true) { + if (hasValue === true) { + throw new shared_1.InvalidOperationException(shared_1.ErrorString.MoreThanOneElement); + } + else { + hasValue = true; + singleValue = value; + } + } + } + return singleValue; +} +exports.singleOrDefaultAsync = singleOrDefaultAsync; + + +/***/ }), + +/***/ 8392: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.skip = void 0; +const BasicParallelEnumerable_1 = __nccwpck_require__(76716); +/** + * Bypasses a specified number of elements in a sequence and then returns the remaining elements. + * @param source An IParallelEnumerable to return elements from. + * @param count The number of elements to skip before returning the remaining elements. + * @returns + * An IParallelEnumerable that contains the elements that occur after the specified index in the input sequence. + */ +function skip(source, count) { + const dataFunc = source.dataFunc; + switch (dataFunc.type) { + case 0 /* PromiseToArray */: { + const generator = async () => (await dataFunc.generator()).slice(count); + return new BasicParallelEnumerable_1.BasicParallelEnumerable({ + generator, + type: 0 /* PromiseToArray */, + }); + } + case 1 /* ArrayOfPromises */: { + const generator = () => dataFunc.generator().slice(count); + return new BasicParallelEnumerable_1.BasicParallelEnumerable({ + generator, + type: 1 /* ArrayOfPromises */, + }); + } + case 2 /* PromiseOfPromises */: { + const generator = async () => { + const dataInner = await dataFunc.generator(); + return dataInner.slice(count); + }; + const dataFuncNew = { + generator, + type: 2 /* PromiseOfPromises */, + }; + return new BasicParallelEnumerable_1.BasicParallelEnumerable(dataFuncNew); + } + } +} +exports.skip = skip; + + +/***/ }), + +/***/ 19226: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.skipWhile = void 0; +const BasicParallelEnumerable_1 = __nccwpck_require__(76716); +/** + * Bypasses elements in a sequence as long as a specified condition is true and then returns the remaining elements. + * The element's index is used in the logic of the predicate function. + * @param source An IAsyncParallel to return elements from. + * @param predicate A function to test each source element for a condition; + * the second parameter of the function represents the index of the source element. + * @returns An IParallelEnumerable that contains the elements from the input sequence starting at the first element + * in the linear series that does not pass the test specified by predicate. + */ +function skipWhile(source, predicate) { + const generator = async () => { + const values = await source.toArray(); + let i = 0; + for (; i < values.length; i++) { + const value = values[i]; + if (predicate(value, i) === false) { + break; + } + } + const returnedValues = []; + for (; i < values.length; i++) { + returnedValues.push(values[i]); + } + return returnedValues; + }; + return new BasicParallelEnumerable_1.BasicParallelEnumerable({ + generator, + type: 0 /* PromiseToArray */, + }); +} +exports.skipWhile = skipWhile; + + +/***/ }), + +/***/ 44057: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.skipWhileAsync = void 0; +const BasicParallelEnumerable_1 = __nccwpck_require__(76716); +/** + * Bypasses elements in a sequence as long as a specified condition is true and then returns the remaining elements. + * The element's index is used in the logic of the predicate function. + * @param source An IAsyncParallel to return elements from. + * @param predicate A function to test each source element for a condition; + * the second parameter of the function represents the index of the source element. + * @returns An IParallelEnumerable that contains the elements from the input sequence starting + * at the first element in the linear series that does not pass the test specified by predicate. + */ +function skipWhileAsync(source, predicate) { + const generator = async () => { + const values = await source.toArray(); + let i = 0; + for (; i < values.length; i++) { + const value = values[i]; + if (await predicate(value, i) === false) { + break; + } + } + const returnedValues = []; + for (; i < values.length; i++) { + returnedValues.push(values[i]); + } + return returnedValues; + }; + return new BasicParallelEnumerable_1.BasicParallelEnumerable({ + generator, + type: 0 /* PromiseToArray */, + }); +} +exports.skipWhileAsync = skipWhileAsync; + + +/***/ }), + +/***/ 20429: +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.sum = void 0; +function sum(source, selector) { + if (selector) { + return sum2(source, selector); + } + else { + return sum1(source); + } +} +exports.sum = sum; +const sum1 = async (source) => { + let totalSum = 0; + for (const value of await source.toArray()) { + totalSum += value; + } + return totalSum; +}; +const sum2 = async (source, selector) => { + let total = 0; + for (const value of await source.toArray()) { + total += selector(value); + } + return total; +}; + + +/***/ }), + +/***/ 50021: +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.sumAsync = void 0; +/** + * Computes the sum of the sequence of numeric values that are obtained by invoking a transform function + * on each element of the input sequence. + * @param source A sequence of values that are used to calculate a sum. + * @param selector A transform function to apply to each element. + * @returns Sum of the sequence + */ +async function sumAsync(source, selector) { + let total = 0; + for (const value of await source.toArray()) { + total += await selector(value); + } + return total; +} +exports.sumAsync = sumAsync; + + +/***/ }), + +/***/ 27609: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.take = void 0; +const BasicParallelEnumerable_1 = __nccwpck_require__(76716); +/** + * Returns a specified number of contiguous elements from the start of a sequence. + * @param source The sequence to return elements from. + * @param amount The number of elements to return. + * @returns An IParallelEnumerable that contains the specified number of elements + * from the start of the input sequence. + */ +function take(source, amount) { + const amountLeft = amount > 0 ? amount : 0; + const dataFunc = source.dataFunc; + switch (dataFunc.type) { + case 1 /* ArrayOfPromises */: + const generator1 = () => dataFunc.generator().splice(0, amountLeft); + return new BasicParallelEnumerable_1.BasicParallelEnumerable({ + generator: generator1, + type: 1 /* ArrayOfPromises */, + }); + case 2 /* PromiseOfPromises */: + const generator2 = () => dataFunc.generator().then((x) => x.splice(0, amountLeft)); + return new BasicParallelEnumerable_1.BasicParallelEnumerable({ + generator: generator2, + type: 2 /* PromiseOfPromises */, + }); + case 0 /* PromiseToArray */: + default: + const generator3 = () => dataFunc.generator().then((x) => x.splice(0, amountLeft)); + return new BasicParallelEnumerable_1.BasicParallelEnumerable({ + generator: generator3, + type: 0 /* PromiseToArray */, + }); + } +} +exports.take = take; + + +/***/ }), + +/***/ 95009: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.takeWhile = void 0; +const BasicParallelEnumerable_1 = __nccwpck_require__(76716); +/** + * Returns elements from a sequence as long as a specified condition is true. + * The element's index is used in the logic of the predicate function. + * @param source The sequence to return elements from. + * @param predicate A function to test each source element for a condition; + * the second parameter of the function represents the index of the source element. + * @returns An IAsyncEnumerable that contains elements from the input sequence + * that occur before the element at which the test no longer passes. + */ +function takeWhile(source, predicate) { + const generator = async () => { + const values = await source.toArray(); + const results = new Array(); + if (predicate.length === 1) { + for (const value of values) { + if (predicate(value) === true) { + results.push(value); + } + else { + break; + } + } + } + else { + for (let i = 0; i < values.length; i++) { + const value = values[i]; + if (predicate(value, i) === true) { + results.push(value); + } + else { + break; + } + } + } + return results; + }; + return new BasicParallelEnumerable_1.BasicParallelEnumerable({ + generator, + type: 0 /* PromiseToArray */, + }); +} +exports.takeWhile = takeWhile; + + +/***/ }), + +/***/ 78842: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.takeWhileAsync = void 0; +const BasicParallelEnumerable_1 = __nccwpck_require__(76716); +/** + * Returns elements from a sequence as long as a specified condition is true. + * The element's index is used in the logic of the predicate function. + * @param source The sequence to return elements from. + * @param predicate An async function to test each source element for a condition; + * the second parameter of the function represents the index of the source element. + * @returns An IParallelEnumerable that contains elements + * from the input sequence that occur before the element at which the test no longer passes. + */ +function takeWhileAsync(source, predicate) { + const generator = async () => { + const values = await source.toArray(); + const results = new Array(); + if (predicate.length === 1) { + const sPredicate = predicate; + for (const value of values) { + if (await sPredicate(value) === true) { + results.push(value); + } + else { + break; + } + } + } + else { + for (let i = 0; i < values.length; i++) { + const value = values[i]; + if (await predicate(value, i) === true) { + results.push(value); + } + else { + break; + } + } + } + return results; + }; + return new BasicParallelEnumerable_1.BasicParallelEnumerable({ + generator, + type: 0 /* PromiseToArray */, + }); +} +exports.takeWhileAsync = takeWhileAsync; + + +/***/ }), + +/***/ 72537: +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.toArray = void 0; +/** + * Creates an array from a IParallelEnumerable. + * @param source An IParallelEnumerable to create an array from. + * @returns An array of elements + */ +function toArray(source) { + const dataFunc = source.dataFunc; + switch (dataFunc.type) { + case 0 /* PromiseToArray */: + return dataFunc.generator(); + case 1 /* ArrayOfPromises */: + return Promise.all(dataFunc.generator()); + case 2 /* PromiseOfPromises */: + return (async () => { + const data = await dataFunc.generator(); + return Promise.all(data); + })(); + default: + throw new Error("Not Implemented"); + } +} +exports.toArray = toArray; + + +/***/ }), + +/***/ 2031: +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.toMap = void 0; +/** + * Converts an AsyncIterable to a Map. + * @param source An Iterable to convert. + * @param selector A function to serve as a key selector. + * @returns A promise for Map + */ +async function toMap(source, selector) { + const map = new Map(); + for await (const value of source) { + const key = selector(value); + const array = map.get(key); + if (array === undefined) { + map.set(key, [value]); + } + else { + array.push(value); + } + } + return map; +} +exports.toMap = toMap; + + +/***/ }), + +/***/ 33037: +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.toMapAsync = void 0; +/** + * Converts an AsyncIterable to a Map. + * @param source An Iterable to convert. + * @param selector An async function to serve as a key selector. + * @returns A promise for Map + */ +async function toMapAsync(source, selector) { + const map = new Map(); + for await (const value of source) { + const key = await selector(value); + const array = map.get(key); + if (array === undefined) { + map.set(key, [value]); + } + else { + array.push(value); + } + } + return map; +} +exports.toMapAsync = toMapAsync; + + +/***/ }), + +/***/ 59632: +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.toSet = void 0; +/** + * Converts the Async Itertion to a Set + * @param source Iteration + * @returns Set containing the iteration values + */ +async function toSet(source) { + const set = new Set(); + for await (const item of source) { + set.add(item); + } + return set; +} +exports.toSet = toSet; + + +/***/ }), + +/***/ 33615: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.union = void 0; +const BasicParallelEnumerable_1 = __nccwpck_require__(76716); +/** + * Produces the set union of two sequences by using scrict equality comparison or a specified IEqualityComparer. + * @param first An IAsyncParallel whose distinct elements form the first set for the union. + * @param second An IAsyncParallel whose distinct elements form the second set for the union. + * @param comparer The IEqualityComparer to compare values. Optional. + * @returns An IParallelEnumerable that contains the elements from both input sequences, excluding duplicates. + */ +function union(first, second, comparer) { + if (comparer) { + return union2(first, second, comparer); + } + else { + return union1(first, second); + } +} +exports.union = union; +const union1 = (first, second) => { + async function generator() { + const set = new Set(); + const secondPromise = second.toArray(); + for await (const item of first) { + if (set.has(item) === false) { + set.add(item); + } + } + const secondValues = await secondPromise; + for (const item of secondValues) { + if (set.has(item) === false) { + set.add(item); + } + } + return [...set.keys()]; + } + return new BasicParallelEnumerable_1.BasicParallelEnumerable({ + generator, + type: 0 /* PromiseToArray */, + }); +}; +const union2 = ( +// eslint-disable-next-line no-shadow +first, second, comparer) => { + const generator = async () => { + const result = []; + const values = await Promise.all([first.toArray(), second.toArray()]); + for (const source of values) { + for (const value of source) { + let exists = false; + for (const resultValue of result) { + if (comparer(value, resultValue) === true) { + exists = true; + break; + } + } + if (exists === false) { + result.push(value); + } + } + } + return result; + }; + return new BasicParallelEnumerable_1.BasicParallelEnumerable({ + generator, + type: 0 /* PromiseToArray */, + }); +}; + + +/***/ }), + +/***/ 65945: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.unionAsync = void 0; +const BasicParallelEnumerable_1 = __nccwpck_require__(76716); +/** + * Produces the set union of two sequences by using a specified IAsyncEqualityComparer. + * @param first An AsyncIterable whose distinct elements form the first set for the union. + * @param second An AsyncIterable whose distinct elements form the second set for the union. + * @param comparer The IAsyncEqualityComparer to compare values. + * @returns An IAsyncEnumerable that contains the elements from both input sequences, excluding duplicates. + */ +function unionAsync( +// eslint-disable-next-line no-shadow +first, second, comparer) { + const generator = async () => { + const result = []; + const values = await Promise.all([first.toArray(), second.toArray()]); + for (const source of values) { + for (const value of source) { + let exists = false; + for (const resultValue of result) { + if (await comparer(value, resultValue) === true) { + exists = true; + break; + } + } + if (exists === false) { + result.push(value); + } + } + } + return result; + }; + return new BasicParallelEnumerable_1.BasicParallelEnumerable({ + generator, + type: 0 /* PromiseToArray */, + }); +} +exports.unionAsync = unionAsync; + + +/***/ }), + +/***/ 50719: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.where = void 0; +const BasicParallelEnumerable_1 = __nccwpck_require__(76716); +/** + * Filters a sequence of values based on a predicate. + * Each element's index is used in the logic of the predicate function. + * @param source An IAsyncParallel to filter. + * @param predicate A function to test each source element for a condition; + * the second parameter of the function represents the index of the source element. + * @returns An IParallelEnumerable that contains elements from the input sequence that satisfy the condition. + */ +function where(source, predicate) { + const generator = async () => { + const values = await source.toArray(); + return values.filter(predicate); + }; + return new BasicParallelEnumerable_1.BasicParallelEnumerable({ + generator, + type: 0 /* PromiseToArray */, + }); +} +exports.where = where; + + +/***/ }), + +/***/ 76742: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.whereAsync = void 0; +const BasicParallelEnumerable_1 = __nccwpck_require__(76716); +/** + * Filters a sequence of values based on a predicate. + * Each element's index is used in the logic of the predicate function. + * @param source An IAsyncParallel to filter. + * @param predicate A async function to test each source element for a condition; + * the second parameter of the function represents the index of the source element. + * @returns An IParallelEnumerable that contains elements from the input sequence that satisfy the condition. + */ +function whereAsync(source, predicate) { + const generator = async () => { + const values = await source.toArray(); + const valuesAsync = values.map(async (x, i) => { + const keep = await predicate(x, i); + return { + keep, + x, + }; + }); + const filteredValues = []; + for (const value of await Promise.all(valuesAsync)) { + if (value.keep) { + filteredValues.push(value.x); + } + } + return filteredValues; + }; + return new BasicParallelEnumerable_1.BasicParallelEnumerable({ + generator, + type: 0 /* PromiseToArray */, + }); +} +exports.whereAsync = whereAsync; + + +/***/ }), + +/***/ 48763: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.zip = void 0; +const BasicParallelEnumerable_1 = __nccwpck_require__(76716); +function zip(first, second, resultSelector) { + if (resultSelector) { + return zip2(first, second, resultSelector); + } + else { + return zip1(first, second); + } +} +exports.zip = zip; +const zip1 = (source, second) => { + async function generator() { + const [left, right] = await Promise.all([source.toArray(), second.toArray()]); + const maxLength = left.length > right.length ? left.length : right.length; + const results = new Array(maxLength); + for (let i = 0; i < maxLength; i++) { + const a = left[i]; + const b = right[i]; + results[i] = [a, b]; + } + return results; + } + return new BasicParallelEnumerable_1.BasicParallelEnumerable({ + generator, + type: 0 /* PromiseToArray */, + }); +}; +const zip2 = (source, second, resultSelector) => { + async function generator() { + const [left, right] = await Promise.all([source.toArray(), second.toArray()]); + const maxLength = left.length > right.length ? left.length : right.length; + const results = new Array(maxLength); + for (let i = 0; i < maxLength; i++) { + const a = left[i]; + const b = right[i]; + results[i] = resultSelector(a, b); + } + return results; + } + return new BasicParallelEnumerable_1.BasicParallelEnumerable({ + generator, + type: 0 /* PromiseToArray */, + }); +}; + + +/***/ }), + +/***/ 80669: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.zipAsync = void 0; +const BasicParallelEnumerable_1 = __nccwpck_require__(76716); +/** + * Applies a specified async function to the corresponding elements of two sequences, + * producing a sequence of the results. + * @param first The first sequence to merge. + * @param second The second sequence to merge. + * @param resultSelector An async function that specifies how to merge the elements from the two sequences. + * @returns An IAsyncEnumerable that contains merged elements of two input sequences. + */ +function zipAsync(first, second, resultSelector) { + async function generator() { + const [left, right] = await Promise.all([first.toArray(), second.toArray()]); + const maxLength = left.length > right.length ? left.length : right.length; + const resultPromises = new Array(maxLength); + for (let i = 0; i < maxLength; i++) { + const a = left[i]; + const b = right[i]; + resultPromises[i] = resultSelector(a, b); + } + return Promise.all(resultPromises); + } + return new BasicParallelEnumerable_1.BasicParallelEnumerable({ + generator, + type: 0 /* PromiseToArray */, + }); +} +exports.zipAsync = zipAsync; + + +/***/ }), + +/***/ 19475: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.isParallelEnumerable = void 0; +const BasicParallelEnumerable_1 = __nccwpck_require__(76716); +/* eslint-disable @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-assignment */ +/** + * Determine if the source is IParallelEnumerable + * @param source Any value + * @returns Whether or not this type is a Parallel Enumerable + */ +exports.isParallelEnumerable = (source) => { + if (!source) { + return false; + } + if (source instanceof BasicParallelEnumerable_1.BasicParallelEnumerable) { + return true; + } + if (typeof source[Symbol.asyncIterator] !== "function") { + return false; + } + const propertyNames = Object.getOwnPropertyNames(BasicParallelEnumerable_1.BasicParallelEnumerable.prototype) + .filter((v) => v !== "constructor"); + const methods = source.prototype || source; + for (const prop of propertyNames) { + if (typeof methods[prop] !== "function") { + return false; + } + } + return true; +}; + + +/***/ }), + +/***/ 21942: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.emptyParallel = void 0; +const BasicParallelEnumerable_1 = __nccwpck_require__(76716); +/** + * Returns an empty IParallelEnumerable that has the specified type argument. + * @returns An empty IParallelEnumerable whose type argument is TResult. + */ +exports.emptyParallel = () => { + const dataFunc = { + generator: async () => [], + type: 0 /* PromiseToArray */, + }; + return new BasicParallelEnumerable_1.BasicParallelEnumerable(dataFunc); +}; + + +/***/ }), + +/***/ 7457: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.flattenParallel = void 0; +const BasicParallelEnumerable_1 = __nccwpck_require__(76716); +function flattenParallel(source, shallow) { + async function* iterator(sourceInner) { + for await (const item of sourceInner) { + // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access + if (item[Symbol.asyncIterator] !== undefined) { + // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment + const items = shallow ? item : iterator(item); + for await (const inner of items) { + yield inner; + } + } + else { + yield item; + } + } + } + const generator = async () => { + const results = []; + for await (const x of iterator(source)) { + results.push(x); + } + return results; + }; + return new BasicParallelEnumerable_1.BasicParallelEnumerable({ + generator, + type: 0 /* PromiseToArray */, + }); +} +exports.flattenParallel = flattenParallel; + + +/***/ }), + +/***/ 83709: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.fromParallel = void 0; +const BasicParallelEnumerable_1 = __nccwpck_require__(76716); +function fromParallel(type, generator) { + return new BasicParallelEnumerable_1.BasicParallelEnumerable({ + generator, + // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment + type, + }); +} +exports.fromParallel = fromParallel; + + +/***/ }), + +/***/ 78485: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +var emptyParallel_1 = __nccwpck_require__(21942); +Object.defineProperty(exports, "emptyParallel", ({ enumerable: true, get: function () { return emptyParallel_1.emptyParallel; } })); +var flattenParallel_1 = __nccwpck_require__(7457); +Object.defineProperty(exports, "flattenParallel", ({ enumerable: true, get: function () { return flattenParallel_1.flattenParallel; } })); +var fromParallel_1 = __nccwpck_require__(83709); +Object.defineProperty(exports, "fromParallel", ({ enumerable: true, get: function () { return fromParallel_1.fromParallel; } })); +var partitionParallel_1 = __nccwpck_require__(81808); +Object.defineProperty(exports, "partitionParallel", ({ enumerable: true, get: function () { return partitionParallel_1.partitionParallel; } })); +var rangeParallel_1 = __nccwpck_require__(23012); +Object.defineProperty(exports, "rangeParallel", ({ enumerable: true, get: function () { return rangeParallel_1.rangeParallel; } })); +var repeatParallel_1 = __nccwpck_require__(15539); +Object.defineProperty(exports, "repeatParallel", ({ enumerable: true, get: function () { return repeatParallel_1.repeatParallel; } })); + + +/***/ }), + +/***/ 81808: +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.partitionParallel = void 0; +/** + * Paritions the Iterable into a tuple of failing and passing arrays + * based on the predicate. + * @param source Elements to Partition + * @param predicate Pass / Fail condition + * @returns [pass, fail] + */ +exports.partitionParallel = async (source, predicate) => { + const fail = []; + const pass = []; + for await (const value of source) { + if (predicate(value) === true) { + pass.push(value); + } + else { + fail.push(value); + } + } + return [pass, fail]; +}; + + +/***/ }), + +/***/ 23012: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.rangeParallel = void 0; +const shared_1 = __nccwpck_require__(25897); +const BasicParallelEnumerable_1 = __nccwpck_require__(76716); +/** + * Generates a sequence of integral numbers within a specified range. + * @param start The value of the first integer in the sequence. + * @param count The number of sequential integers to generate. + * @throws {ArgumentOutOfRangeException} Start is Less than 0 + * OR start + count -1 is larger than MAX_SAFE_INTEGER. + * @returns An IParallelEnumerable that contains a range of sequential integral numbers. + */ +function rangeParallel(start, count) { + if (start < 0 || (start + count - 1) > Number.MAX_SAFE_INTEGER) { + throw new shared_1.ArgumentOutOfRangeException(`start`); + } + function generator() { + const items = []; + const maxI = start + count; + for (let i = start; i < maxI; i++) { + items.push(Promise.resolve(i)); + } + return items; + } + return new BasicParallelEnumerable_1.BasicParallelEnumerable({ + generator, + type: 1 /* ArrayOfPromises */, + }); +} +exports.rangeParallel = rangeParallel; + + +/***/ }), + +/***/ 15539: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.repeatParallel = void 0; +const shared_1 = __nccwpck_require__(25897); +const BasicParallelEnumerable_1 = __nccwpck_require__(76716); +/** + * Generates a sequence that contains one repeated value. + * @param element The value to be repeated. + * @param count The number of times to repeat the value in the generated sequence. + * @param delay Miliseconds for Timeout + * @returns An IParallelEnumerable that contains a repeated value. + */ +function repeatParallel( +// eslint-disable-next-line no-shadow +element, count, delay) { + if (count < 0) { + throw new shared_1.ArgumentOutOfRangeException(`count`); + } + if (delay) { + return repeat2(element, count, delay); + } + else { + return repeat1(element, count); + } +} +exports.repeatParallel = repeatParallel; +const repeat1 = (element, count) => { + const generator = async () => { + const values = new Array(count); + for (let i = 0; i < count; i++) { + values[i] = element; + } + return values; + }; + return new BasicParallelEnumerable_1.BasicParallelEnumerable({ + generator, + type: 0 /* PromiseToArray */, + }); +}; +const repeat2 = (element, count, delay) => { + const generator = async () => { + const values = new Array(count); + for (let i = 0; i < count; i++) { + values[i] = new Promise((resolve) => setTimeout(() => resolve(element), delay)); + } + return values; + }; + return new BasicParallelEnumerable_1.BasicParallelEnumerable({ + generator, + type: 2 /* PromiseOfPromises */, + }); +}; + + +/***/ }), + +/***/ 15713: +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.ArgumentOutOfRangeException = void 0; +/** + * Exception thrown when the passed in argument + * is out of range. + */ +class ArgumentOutOfRangeException extends RangeError { + constructor(paramName) { + super(`${paramName} was out of range.` + + ` Must be non-negative and less than the size of the collection.`); + this.paramName = paramName; + this.name = `ArgumentOutOfRangeException`; + this.stack = this.stack || (new Error()).stack; + } +} +exports.ArgumentOutOfRangeException = ArgumentOutOfRangeException; + + +/***/ }), + +/***/ 23408: +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.EqualityComparer = void 0; +/** + * Does weak (==) comparison between two values. + * Good for comparing numbers and strings. + * @param x left value + * @param y right value + * @returns x == y + */ +exports.EqualityComparer = (x, y) => +// eslint-disable-next-line eqeqeq +x == y; + + +/***/ }), + +/***/ 3206: +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.ErrorString = void 0; +/** + * @private + */ +exports.ErrorString = Object.freeze({ + MoreThanOneElement: `Sequence contains more than one element`, + MoreThanOneMatchingElement: `Sequence contains more than one matching element`, + NoElements: `Sequence contains no elements`, + NoMatch: `Sequence contains no matching element`, +}); + + +/***/ }), + +/***/ 29980: +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.InvalidOperationException = void 0; +/** + * Invalid Operation Exception + */ +class InvalidOperationException extends Error { + constructor(message) { + super(message); + this.name = `InvalidOperationException`; + this.stack = this.stack || (new Error()).stack; + } +} +exports.InvalidOperationException = InvalidOperationException; + + +/***/ }), + +/***/ 77362: +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.NumberComparer = void 0; +/** + * Compares two numeric values. + * @param x left value + * @param y right value + * @returns x - y + */ +exports.NumberComparer = (x, y) => x - y; + + +/***/ }), + +/***/ 70951: +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.StrictEqualityComparer = void 0; +/** + * Does strict (===) comparison between two values. + * @param x left value + * @param y right value + * @returns Whether or not the two values are strictly equal + */ +exports.StrictEqualityComparer = (x, y) => x === y; + + +/***/ }), + +/***/ 87786: +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.StringifyComparer = void 0; +/** + * Compares two values by converting them to json + * and then comparing the two json strings. + * @param x left value + * @param y right value + * @returns Whether or not the two values produce equal JSON + */ +exports.StringifyComparer = (x, y) => JSON.stringify(x) === JSON.stringify(y); + + +/***/ }), + +/***/ 25897: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +var ArgumentOutOfRangeException_1 = __nccwpck_require__(15713); +Object.defineProperty(exports, "ArgumentOutOfRangeException", ({ enumerable: true, get: function () { return ArgumentOutOfRangeException_1.ArgumentOutOfRangeException; } })); +var EqualityComparer_1 = __nccwpck_require__(23408); +Object.defineProperty(exports, "EqualityComparer", ({ enumerable: true, get: function () { return EqualityComparer_1.EqualityComparer; } })); +var ErrorString_1 = __nccwpck_require__(3206); +Object.defineProperty(exports, "ErrorString", ({ enumerable: true, get: function () { return ErrorString_1.ErrorString; } })); +var InvalidOperationException_1 = __nccwpck_require__(29980); +Object.defineProperty(exports, "InvalidOperationException", ({ enumerable: true, get: function () { return InvalidOperationException_1.InvalidOperationException; } })); +var NumberComparer_1 = __nccwpck_require__(77362); +Object.defineProperty(exports, "NumberComparer", ({ enumerable: true, get: function () { return NumberComparer_1.NumberComparer; } })); +var StrictEqualityComparer_1 = __nccwpck_require__(70951); +Object.defineProperty(exports, "StrictEqualityComparer", ({ enumerable: true, get: function () { return StrictEqualityComparer_1.StrictEqualityComparer; } })); +var StringifyComparer_1 = __nccwpck_require__(87786); +Object.defineProperty(exports, "StringifyComparer", ({ enumerable: true, get: function () { return StringifyComparer_1.StringifyComparer; } })); + + +/***/ }), + +/***/ 18640: +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.ArrayEnumerable = void 0; +/* eslint-disable @typescript-eslint/naming-convention */ +/** + * Array backed Enumerable + */ +class ArrayEnumerable extends Array { +} +exports.ArrayEnumerable = ArrayEnumerable; + + +/***/ }), + +/***/ 93706: +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.BasicEnumerable = void 0; +/* eslint-disable @typescript-eslint/no-empty-interface */ +/** + * Basic Enumerable. Usually returned from the Enumerable class. + * @private + */ +class BasicEnumerable { + constructor(iterator) { + this.iterator = iterator; + // + } + [Symbol.iterator]() { + return this.iterator(); + } +} +exports.BasicEnumerable = BasicEnumerable; + + +/***/ }), + +/***/ 20891: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.Grouping = void 0; +const ArrayEnumerable_1 = __nccwpck_require__(18640); +/** + * Key to Values Enumeration + * @private + */ +class Grouping extends ArrayEnumerable_1.ArrayEnumerable { + constructor(key, startingItem) { + super(1); + this.key = key; + this[0] = startingItem; + } +} +exports.Grouping = Grouping; + + +/***/ }), + +/***/ 48249: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.OrderedEnumerable = void 0; +const OrderedAsyncEnumerable_1 = __nccwpck_require__(42485); +const asSortedKeyValues_1 = __nccwpck_require__(74153); +const asSortedKeyValuesAsync_1 = __nccwpck_require__(68767); +const BasicEnumerable_1 = __nccwpck_require__(93706); +/** + * Represents Ordered Enumeration + * @private + */ +class OrderedEnumerable extends BasicEnumerable_1.BasicEnumerable { + constructor(orderedPairs) { + super(function* () { + for (const orderedPair of orderedPairs()) { + yield* orderedPair; + } + }); + this.orderedPairs = orderedPairs; + } + // #region Sync + static generate(source, keySelector, ascending, comparer) { + let orderedPairs; + if (source instanceof OrderedEnumerable) { + orderedPairs = function* () { + for (const pair of source.orderedPairs()) { + yield* asSortedKeyValues_1.asSortedKeyValues(pair, keySelector, ascending, comparer); + } + }; + } + else { + orderedPairs = () => asSortedKeyValues_1.asSortedKeyValues(source, keySelector, ascending, comparer); + } + return new OrderedEnumerable(orderedPairs); + } + // #endregion + // #region Async + static generateAsync(source, keySelector, ascending, comparer) { + let orderedPairs; + if (source instanceof OrderedEnumerable) { + orderedPairs = async function* () { + for (const pair of source.orderedPairs()) { + yield* asSortedKeyValuesAsync_1.asSortedKeyValuesAsync(pair, keySelector, ascending, comparer); + } + }; + } + else { + orderedPairs = () => asSortedKeyValuesAsync_1.asSortedKeyValuesAsync(source, keySelector, ascending, comparer); + } + return new OrderedAsyncEnumerable_1.OrderedAsyncEnumerable(orderedPairs); + } + // #endregion + thenBy(keySelector, comparer) { + return OrderedEnumerable.generate(this, keySelector, true, comparer); + } + thenByAsync(keySelector, comparer) { + return OrderedEnumerable.generateAsync(this, keySelector, true, comparer); + } + thenByDescending(keySelector, comparer) { + return OrderedEnumerable.generate(this, keySelector, false, comparer); + } + thenByDescendingAsync(keySelector, comparer) { + return OrderedEnumerable.generateAsync(this, keySelector, false, comparer); + } +} +exports.OrderedEnumerable = OrderedEnumerable; + + +/***/ }), + +/***/ 43492: +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.asKeyMap = void 0; +/** + * Converts values to a key values map. + * @param source Iterable + * @param keySelector Key Selector for Map + * @returns Map for Key to Values + */ +exports.asKeyMap = (source, keySelector) => { + const map = new Map(); + for (const item of source) { + const key = keySelector(item); + const currentMapping = map.get(key); + if (currentMapping) { + currentMapping.push(item); + } + else { + map.set(key, [item]); + } + } + return map; +}; + + +/***/ }), + +/***/ 37252: +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.asKeyMapAsync = void 0; +/** + * Converts values to a key values map. + * @param source Iterable + * @param keySelector Async Key Selector for Map + * @returns Map for Key to Values + */ +exports.asKeyMapAsync = async (source, keySelector) => { + const map = new Map(); + for (const item of source) { + const key = await keySelector(item); + const currentMapping = map.get(key); + if (currentMapping) { + currentMapping.push(item); + } + else { + map.set(key, [item]); + } + } + return map; +}; + + +/***/ }), + +/***/ 74153: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.asSortedKeyValues = void 0; +const asKeyMap_1 = __nccwpck_require__(43492); +/** + * Sorts values in an Iterable based on key and a key comparer. + * @param source Iterable + * @param keySelector Key Selector + * @param ascending Ascending or Descending Sort + * @param comparer Key Comparer for Sorting. Optional. + */ +function* asSortedKeyValues(source, keySelector, ascending, comparer) { + const map = asKeyMap_1.asKeyMap(source, keySelector); + const sortedKeys = [...map.keys()].sort(comparer ? comparer : undefined); + if (ascending) { + for (let i = 0; i < sortedKeys.length; i++) { + yield map.get(sortedKeys[i]); + } + } + else { + for (let i = sortedKeys.length - 1; i >= 0; i--) { + yield map.get(sortedKeys[i]); + } + } +} +exports.asSortedKeyValues = asSortedKeyValues; + + +/***/ }), + +/***/ 68767: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.asSortedKeyValuesAsync = void 0; +const asKeyMapAsync_1 = __nccwpck_require__(37252); +/** + * Sorts values in an Iterable based on key and a key comparer. + * @param source Iterable + * @param keySelector Async Key Selector + * @param ascending Ascending or Descending Sort + * @param comparer Key Comparer for Sorting. Optional. + * @returns Async Iterable Iterator + */ +async function* asSortedKeyValuesAsync(source, keySelector, ascending, comparer) { + const map = await asKeyMapAsync_1.asKeyMapAsync(source, keySelector); + const sortedKeys = [...map.keys()].sort(comparer ? comparer : undefined); + if (ascending) { + for (let i = 0; i < sortedKeys.length; i++) { + yield map.get(sortedKeys[i]); + } + } + else { + for (let i = sortedKeys.length - 1; i >= 0; i--) { + yield map.get(sortedKeys[i]); + } + } +} +exports.asSortedKeyValuesAsync = asSortedKeyValuesAsync; + + +/***/ }), + +/***/ 33880: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.aggregate = void 0; +const shared_1 = __nccwpck_require__(25897); +function aggregate(source, seedOrFunc, func, resultSelector) { + if (resultSelector) { + if (!func) { + throw new ReferenceError(`TAccumulate function is undefined`); + } + return aggregate3(source, seedOrFunc, func, resultSelector); + } + else if (func) { + return aggregate2(source, seedOrFunc, func); + } + else { + return aggregate1(source, seedOrFunc); + } +} +exports.aggregate = aggregate; +const aggregate1 = (source, func) => { + let aggregateValue; + for (const value of source) { + if (aggregateValue) { + aggregateValue = func(aggregateValue, value); + } + else { + aggregateValue = value; + } + } + if (aggregateValue === undefined) { + throw new shared_1.InvalidOperationException(shared_1.ErrorString.NoElements); + } + return aggregateValue; +}; +const aggregate2 = (source, seed, func) => { + let aggregateValue = seed; + for (const value of source) { + aggregateValue = func(aggregateValue, value); + } + return aggregateValue; +}; +const aggregate3 = (source, seed, func, resultSelector) => { + let aggregateValue = seed; + for (const value of source) { + aggregateValue = func(aggregateValue, value); + } + return resultSelector(aggregateValue); +}; + + +/***/ }), + +/***/ 86504: +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.all = void 0; +/** + * Determines whether all elements of a sequence satisfy a condition. + * @param source An Iterable that contains the elements to apply the predicate to. + * @param predicate A function to test each element for a condition. + * @returns ``true`` if every element of the source sequence passes the test in the specified predicate, + * or if the sequence is empty; otherwise, ``false``. + */ +exports.all = (source, predicate) => { + for (const item of source) { + if (predicate(item) === false) { + return false; + } + } + return true; +}; + + +/***/ }), + +/***/ 57664: +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.allAsync = void 0; +/** + * Determines whether all elements of a sequence satisfy a condition. + * @param source An Iterable that contains the elements to apply the predicate to. + * @param predicate A function to test each element for a condition. + * @returns ``true`` if every element of the source sequence passes the test in the specified predicate, + * or if the sequence is empty; otherwise, ``false``. + */ +exports.allAsync = async (source, predicate) => { + for (const item of source) { + if (await predicate(item) === false) { + return false; + } + } + return true; +}; + + +/***/ }), + +/***/ 26666: +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.any = void 0; +/** + * Determines whether a sequence contains any elements. + * If predicate is specified, determines whether any element of a sequence satisfies a condition. + * @param source The Iterable to check for emptiness or apply the predicate to. + * @param predicate A function to test each element for a condition. + * @returns true if the source sequence contains any elements or passes the test specified; otherwise, false. + */ +exports.any = (source, predicate) => { + if (predicate) { + return any2(source, predicate); + } + else { + return any1(source); + } +}; +const any1 = (source) => { + // eslint-disable-next-line @typescript-eslint/no-unused-vars + for (const _ of source) { + return true; + } + return false; +}; +const any2 = (source, predicate) => { + for (const item of source) { + if (predicate(item) === true) { + return true; + } + } + return false; +}; + + +/***/ }), + +/***/ 47462: +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.anyAsync = void 0; +/** + * Determines whether any element of a sequence satisfies a condition. + * @param source An IEnumerable whose elements to apply the predicate to. + * @param predicate A function to test each element for a condition. + * @returns true if the source sequence contains any elements or passes the test specified; otherwise, false. + */ +exports.anyAsync = async (source, predicate) => { + for (const item of source) { + if (await predicate(item) === true) { + return true; + } + } + return false; +}; + + +/***/ }), + +/***/ 7662: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.asAsync = void 0; +const fromAsync_1 = __nccwpck_require__(55641); +/** + * Converts the iterable to an @see {IAsyncEnumerable} + * @param source The Iterable to convert + * @returns An IAsyncEnumerable + */ +exports.asAsync = (source) => { + async function* generator() { + for (const value of source) { + yield value; + } + } + return fromAsync_1.fromAsync(generator); +}; + + +/***/ }), + +/***/ 92035: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.asParallel = void 0; +const fromParallel_1 = __nccwpck_require__(83709); +/** + * Converts an iterable to @see {IParallelEnumerable} + * @param source Sequence to convert + * @returns An IParallelEnumerable + */ +exports.asParallel = (source) => { + const generator = async () => { + const array = []; + for (const value of source) { + array.push(value); + } + return array; + }; + return fromParallel_1.fromParallel(0 /* PromiseToArray */, generator); +}; + + +/***/ }), + +/***/ 80758: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.average = void 0; +const shared_1 = __nccwpck_require__(25897); +function average(source, selector) { + if (selector) { + return average2(source, selector); + } + else { + return average1(source); + } +} +exports.average = average; +const average1 = (source) => { + let value; + let count; + for (const item of source) { + value = (value || 0) + item; + count = (count || 0) + 1; + } + if (value === undefined) { + throw new shared_1.InvalidOperationException(shared_1.ErrorString.NoElements); + } + return value / count; +}; +const average2 = (source, func) => { + let value; + let count; + for (const item of source) { + value = (value || 0) + func(item); + count = (count || 0) + 1; + } + if (value === undefined) { + throw new shared_1.InvalidOperationException(shared_1.ErrorString.NoElements); + } + return value / count; +}; + + +/***/ }), + +/***/ 99013: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.averageAsync = void 0; +const shared_1 = __nccwpck_require__(25897); +/** + * Computes the average of a sequence of values + * that are obtained by invoking a transform function on each element of the input sequence. + * @param source A sequence of values to calculate the average of. + * @param selector A transform function to apply to each element. + * @throws {InvalidOperationException} source contains no elements. + * @returns Avarage of the sequence of values + */ +exports.averageAsync = async (source, selector) => { + let value; + let count; + for (const item of source) { + value = (value || 0) + await selector(item); + count = (count || 0) + 1; + } + if (value === undefined) { + throw new shared_1.InvalidOperationException(shared_1.ErrorString.NoElements); + } + return value / count; +}; + + +/***/ }), + +/***/ 10323: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.concatenate = void 0; +const BasicEnumerable_1 = __nccwpck_require__(93706); +/** + * Concatenates two sequences. + * @param first The first sequence to concatenate. + * @param second The sequence to concatenate to the first sequence. + * @returns An IEnumerable that contains the concatenated elements of the two input sequences. + */ +exports.concatenate = (first, second) => { + function* iterator() { + yield* first; + yield* second; + } + return new BasicEnumerable_1.BasicEnumerable(iterator); +}; + + +/***/ }), + +/***/ 6805: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.contains = void 0; +const shared_1 = __nccwpck_require__(25897); +/** + * Determines whether a sequence contains a specified element by using the specified or default IEqualityComparer. + * @param source A sequence in which to locate a value. + * @param value The value to locate in the sequence. + * @param comparer An equality comparer to compare values. Optional. + * @returns true if the source sequence contains an element that has the specified value; otherwise, false. + */ +exports.contains = (source, value, comparer = shared_1.StrictEqualityComparer) => { + for (const item of source) { + if (comparer(value, item)) { + return true; + } + } + return false; +}; + + +/***/ }), + +/***/ 38261: +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.containsAsync = void 0; +/** + * Determines whether a sequence contains a specified element by using the specified or default IEqualityComparer. + * @param source A sequence in which to locate a value. + * @param value The value to locate in the sequence. + * @param comparer An equality comparer to compare values. Optional. + * @returns true if the source sequence contains an element that has the specified value; otherwise, false. + */ +exports.containsAsync = async (source, value, comparer) => { + for (const item of source) { + if (await comparer(value, item)) { + return true; + } + } + return false; +}; + + +/***/ }), + +/***/ 46333: +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.count = void 0; +/** + * Returns the number of elements in a sequence + * or represents how many elements in the specified sequence satisfy a condition + * if the predicate is specified. + * @param source A sequence that contains elements to be counted. + * @param predicate A function to test each element for a condition. Optional. + * @returns The number of elements in the input sequence. + */ +exports.count = (source, predicate) => { + if (predicate) { + return count2(source, predicate); + } + else { + return count1(source); + } +}; +const count1 = (source) => { + // eslint-disable-next-line no-shadow + let count = 0; + // eslint-disable-next-line @typescript-eslint/no-unused-vars + for (const _ of source) { + count++; + } + return count; +}; +const count2 = (source, predicate) => { + // eslint-disable-next-line no-shadow + let count = 0; + for (const value of source) { + if (predicate(value) === true) { + count++; + } + } + return count; +}; + + +/***/ }), + +/***/ 87872: +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.countAsync = void 0; +/** + * Returns the number of elements in a sequence + * or represents how many elements in the specified sequence satisfy a condition + * if the predicate is specified. + * @param source A sequence that contains elements to be counted. + * @param predicate A function to test each element for a condition. + * @returns The number of elements in the input sequence. + */ +exports.countAsync = async (source, predicate) => { + let count = 0; + for (const value of source) { + if (await predicate(value) === true) { + count++; + } + } + return count; +}; + + +/***/ }), + +/***/ 65605: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.distinct = void 0; +const shared_1 = __nccwpck_require__(25897); +const BasicEnumerable_1 = __nccwpck_require__(93706); +/** + * Returns distinct elements from a sequence by using the default or specified equality comparer to compare values. + * @param source The sequence to remove duplicate elements from. + * @param comparer An IEqualityComparer to compare values. Optional. Defaults to Strict Equality Comparison. + * @returns An IEnumerable that contains distinct elements from the source sequence. + */ +exports.distinct = (source, comparer = shared_1.StrictEqualityComparer) => { + function* iterator() { + const distinctElements = []; + for (const item of source) { + const foundItem = distinctElements.find((x) => comparer(x, item)); + if (!foundItem) { + distinctElements.push(item); + yield item; + } + } + } + return new BasicEnumerable_1.BasicEnumerable(iterator); +}; + + +/***/ }), + +/***/ 54770: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.distinctAsync = void 0; +const fromAsync_1 = __nccwpck_require__(55641); +/** + * Returns distinct elements from a sequence by using the specified equality comparer to compare values. + * @param source The sequence to remove duplicate elements from. + * @param comparer An IAsyncEqualityComparer to compare values. + * @returns An IAsyncEnumerable that contains distinct elements from the source sequence. + */ +exports.distinctAsync = (source, comparer) => { + async function* iterator() { + const distinctElements = []; + outerLoop: for (const item of source) { + for (const distinctElement of distinctElements) { + const found = await comparer(distinctElement, item); + if (found) { + continue outerLoop; + } + } + distinctElements.push(item); + yield item; + } + } + return fromAsync_1.fromAsync(iterator); +}; + + +/***/ }), + +/***/ 70679: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.each = void 0; +const BasicEnumerable_1 = __nccwpck_require__(93706); +/** + * Performs a specified action on each element of the Iterable + * @param source The source to iterate + * @param action The action to take an each element + * @returns A new IEnumerable that executes the action lazily as you iterate. + */ +exports.each = (source, action) => { + function* generator() { + for (const value of source) { + action(value); + yield value; + } + } + return new BasicEnumerable_1.BasicEnumerable(generator); +}; + + +/***/ }), + +/***/ 46256: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.eachAsync = void 0; +const fromAsync_1 = __nccwpck_require__(55641); +/** + * Performs a specified action on each element of the Iterable + * @param source The source to iterate + * @param action The action to take an each element + * @returns A new IAsyncEnumerable that executes the action lazily as you iterate. + */ +exports.eachAsync = (source, action) => { + async function* generator() { + for (const value of source) { + await action(value); + yield value; + } + } + return fromAsync_1.fromAsync(generator); +}; + + +/***/ }), + +/***/ 93281: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.elementAt = void 0; +const shared_1 = __nccwpck_require__(25897); +/** + * Returns the element at a specified index in a sequence. + * @param source An IEnumerable to return an element from. + * @param index The zero-based index of the element to retrieve. + * @throws {ArgumentOutOfRangeException} + * index is less than 0 or greater than or equal to the number of elements in source. + * @returns The element at the specified position in the source sequence. + */ +exports.elementAt = (source, index) => { + if (index < 0) { + throw new shared_1.ArgumentOutOfRangeException("index"); + } + let i = 0; + for (const item of source) { + if (index === i++) { + return item; + } + } + throw new shared_1.ArgumentOutOfRangeException("index"); +}; + + +/***/ }), + +/***/ 86643: +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.elementAtOrDefault = void 0; +/** + * Returns the element at a specified index in a sequence or a default value if the index is out of range. + * @param source An IEnumerable to return an element from. + * @param index The zero-based index of the element to retrieve. + * @returns + * null if the index is outside the bounds of the source sequence; + * otherwise, the element at the specified position in the source sequence. + */ +exports.elementAtOrDefault = (source, index) => { + let i = 0; + for (const item of source) { + if (index === i++) { + return item; + } + } + return null; +}; + + +/***/ }), + +/***/ 3281: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.except = void 0; +const shared_1 = __nccwpck_require__(25897); +const BasicEnumerable_1 = __nccwpck_require__(93706); +/** + * Produces the set difference of two sequences by using the comparer provided + * or EqualityComparer to compare values. + * @param first An IEnumerable whose elements that are not also in second will be returned. + * @param second An IEnumerable whose elements that also occur in the first sequence + * will cause those elements to be removed from the returned sequence. + * @param comparer An IEqualityComparer to compare values. Optional. + * @returns A sequence that contains the set difference of the elements of two sequences. + */ +exports.except = (first, second, comparer = shared_1.StrictEqualityComparer) => { + function* iterator() { + const secondArray = [...second]; + for (const firstItem of first) { + let exists = false; + for (let j = 0; j < secondArray.length; j++) { + const secondItem = secondArray[j]; + if (comparer(firstItem, secondItem) === true) { + exists = true; + break; + } + } + if (exists === false) { + yield firstItem; + } + } + } + return new BasicEnumerable_1.BasicEnumerable(iterator); +}; + + +/***/ }), + +/***/ 30202: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.exceptAsync = void 0; +const fromAsync_1 = __nccwpck_require__(55641); +/** + * Produces the set difference of two sequences by using the comparer provided to compare values. + * @param first An IEnumerable whose elements that are not also in second will be returned. + * @param second An IEnumerable whose elements that also occur in the first sequence + * will cause those elements to be removed from the returned sequence. + * @param comparer An IAsyncEqualityComparer to compare values. + * @returns A sequence that contains the set difference of the elements of two sequences. + */ +exports.exceptAsync = (first, second, comparer) => { + async function* iterator() { + const secondArray = [...second]; + for (const firstItem of first) { + let exists = false; + for (let j = 0; j < secondArray.length; j++) { + const secondItem = secondArray[j]; + if (await comparer(firstItem, secondItem) === true) { + exists = true; + break; + } + } + if (exists === false) { + yield firstItem; + } + } + } + return fromAsync_1.fromAsync(iterator); +}; + + +/***/ }), + +/***/ 13633: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.first = void 0; +const shared_1 = __nccwpck_require__(25897); +/** + * Returns first element in sequence that satisfies predicate otherwise + * returns the first element in the sequence. + * @param source An Iterable to return an element from. + * @param predicate A function to test each element for a condition. Optional. + * @throws {InvalidOperationException} No elements in Iteration matching predicate + * @returns The first element in the sequence + * or the first element that passes the test in the specified predicate function. + */ +exports.first = (source, predicate) => { + if (predicate) { + return first2(source, predicate); + } + else { + return first1(source); + } +}; +const first1 = (source) => { + // eslint-disable-next-line no-shadow + const first = source[Symbol.iterator]().next(); + if (first.done === true) { + throw new shared_1.InvalidOperationException(shared_1.ErrorString.NoElements); + } + return first.value; +}; +const first2 = (source, predicate) => { + for (const value of source) { + if (predicate(value) === true) { + return value; + } + } + throw new shared_1.InvalidOperationException(shared_1.ErrorString.NoMatch); +}; + + +/***/ }), + +/***/ 86717: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.firstAsync = void 0; +const shared_1 = __nccwpck_require__(25897); +/** + * Returns the first element in a sequence that satisfies a specified condition. + * @param source An Iterable to return an element from. + * @param predicate A function to test each element for a condition. + * @throws {InvalidOperationException} No elements in Iteration matching predicate + * @returns The first element in the sequence that passes the test in the specified predicate function. + */ +exports.firstAsync = async (source, predicate) => { + for (const value of source) { + if (await predicate(value) === true) { + return value; + } + } + throw new shared_1.InvalidOperationException(shared_1.ErrorString.NoMatch); +}; + + +/***/ }), + +/***/ 51250: +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.firstOrDefault = void 0; +/** + * Returns first element in sequence that satisfies predicate otherwise + * returns the first element in the sequence. Returns null if no value found. + * @param source An Iterable to return an element from. + * @param predicate A function to test each element for a condition. Optional. + * @returns The first element in the sequence + * or the first element that passes the test in the specified predicate function. + * Returns null if no value found. + */ +exports.firstOrDefault = (source, predicate) => { + if (predicate) { + return firstOrDefault2(source, predicate); + } + else { + return firstOrDefault1(source); + } +}; +const firstOrDefault1 = (source) => { + const first = source[Symbol.iterator]().next(); + // eslint-disable-next-line @typescript-eslint/no-unsafe-return + return first.value || null; +}; +const firstOrDefault2 = (source, predicate) => { + for (const value of source) { + if (predicate(value) === true) { + return value; + } + } + return null; +}; + + +/***/ }), + +/***/ 75559: +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.firstOrDefaultAsync = void 0; +/** + * Returns the first element of the sequence that satisfies a condition or a default value if no such element is found. + * @param source An Iterable to return an element from. + * @param predicate An async function to test each element for a condition. + * @returns null if source is empty or if no element passes the test specified by predicate; + * otherwise, the first element in source that passes the test specified by predicate. + */ +async function firstOrDefaultAsync(source, predicate) { + for (const value of source) { + if (await predicate(value) === true) { + return value; + } + } + return null; +} +exports.firstOrDefaultAsync = firstOrDefaultAsync; + + +/***/ }), + +/***/ 17267: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.groupBy = void 0; +const BasicEnumerable_1 = __nccwpck_require__(93706); +const groupByShared_1 = __nccwpck_require__(58382); +function groupBy(source, keySelector, comparer) { + let iterable; + if (comparer) { + iterable = groupByShared_1.groupBy_0(source, keySelector, comparer); + } + else { + iterable = groupByShared_1.groupBy_0_Simple(source, keySelector); + } + return new BasicEnumerable_1.BasicEnumerable(iterable); +} +exports.groupBy = groupBy; + + +/***/ }), + +/***/ 72697: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.groupByAsync = void 0; +const fromAsync_1 = __nccwpck_require__(55641); +const Grouping_1 = __nccwpck_require__(20891); +function groupByAsync(source, keySelector, comparer) { + if (comparer) { + return groupByAsync_0(source, keySelector, comparer); + } + else { + // eslint-disable-next-line @typescript-eslint/no-unsafe-return + return groupByAsync_0_Simple(source, keySelector); + } +} +exports.groupByAsync = groupByAsync; +function groupByAsync_0_Simple(source, keySelector) { + async function* iterator() { + const keyMap = {}; + for (const value of source) { + const key = await keySelector(value); + const grouping = keyMap[key]; + if (grouping) { + grouping.push(value); + } + else { + keyMap[key] = new Grouping_1.Grouping(key, value); + } + } + // eslint-disable-next-line guard-for-in + for (const value in keyMap) { + yield keyMap[value]; + } + } + return fromAsync_1.fromAsync(iterator); +} +function groupByAsync_0(source, keySelector, comparer) { + async function* generate() { + const keyMap = new Array(); + for (const value of source) { + const key = await keySelector(value); + let found = false; + for (let i = 0; i < keyMap.length; i++) { + const group = keyMap[i]; + if (await comparer(group.key, key) === true) { + group.push(value); + found = true; + break; + } + } + if (found === false) { + keyMap.push(new Grouping_1.Grouping(key, value)); + } + } + for (const keyValue of keyMap) { + yield keyValue; + } + } + return fromAsync_1.fromAsync(generate); +} + + +/***/ }), + +/***/ 58382: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.groupBy_1 = exports.groupBy_1_Simple = exports.groupBy_0_Simple = exports.groupBy_0 = void 0; +const BasicEnumerable_1 = __nccwpck_require__(93706); +const Grouping_1 = __nccwpck_require__(20891); +/* eslint-disable jsdoc/require-returns */ +/* eslint-disable @typescript-eslint/naming-convention,no-underscore-dangle,id-blacklist,id-match */ +/** + * Group and Iterable Based on a Generic Key and an equality comparer + * @param source Iteration + * @param keySelector Key Selector + * @param comparer Key Comparer + * @private + */ +exports.groupBy_0 = (source, keySelector, comparer) => { + return function* generate() { + const keyMap = new Array(); + for (const value of source) { + const key = keySelector(value); + let found = false; + for (let i = 0; i < keyMap.length; i++) { + const group = keyMap[i]; + if (comparer(group.key, key)) { + group.push(value); + found = true; + break; + } + } + if (found === false) { + keyMap.push(new Grouping_1.Grouping(key, value)); + } + } + for (const keyValue of keyMap) { + yield keyValue; + } + }; +}; +/** + * @private + */ +exports.groupBy_0_Simple = (source, keySelector) => { + return function* iterator() { + const keyMap = {}; + for (const value of source) { + const key = keySelector(value); + const grouping = keyMap[key]; + if (grouping) { + grouping.push(value); + } + else { + keyMap[key] = new Grouping_1.Grouping(key, value); + } + } + // eslint-disable-next-line guard-for-in + for (const value in keyMap) { + yield keyMap[value]; + } + }; +}; +/** + * @private + */ +function groupBy_1_Simple(source, keySelector, elementSelector) { + function* generate() { + const keyMap = {}; + for (const value of source) { + const key = keySelector(value); + const grouping = keyMap[key]; + const element = elementSelector(value); + if (grouping) { + grouping.push(element); + } + else { + keyMap[key] = new Grouping_1.Grouping(key, element); + } + } + /* eslint-disable guard-for-in */ + for (const value in keyMap) { + yield keyMap[value]; + } + /* eslint-enable guard-for-in */ + } + return new BasicEnumerable_1.BasicEnumerable(generate); +} +exports.groupBy_1_Simple = groupBy_1_Simple; +/** + * @private + */ +function groupBy_1(source, keySelector, elementSelector, comparer) { + function* generate() { + const keyMap = new Array(); + for (const value of source) { + const key = keySelector(value); + let found = false; + for (let i = 0; i < keyMap.length; i++) { + const group = keyMap[i]; + if (comparer(group.key, key)) { + group.push(elementSelector(value)); + found = true; + break; + } + } + if (found === false) { + const element = elementSelector(value); + keyMap.push(new Grouping_1.Grouping(key, element)); + } + } + for (const keyValue of keyMap) { + yield keyValue; + } + } + return new BasicEnumerable_1.BasicEnumerable(generate); +} +exports.groupBy_1 = groupBy_1; + + +/***/ }), + +/***/ 31647: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.groupByWithSel = void 0; +const groupByShared_1 = __nccwpck_require__(58382); +function groupByWithSel(source, keySelector, elementSelector, comparer) { + if (comparer) { + return groupByShared_1.groupBy_1(source, keySelector, elementSelector, comparer); + } + else { + return groupByShared_1.groupBy_1_Simple(source, keySelector, elementSelector); + } +} +exports.groupByWithSel = groupByWithSel; + + +/***/ }), + +/***/ 71400: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.intersect = void 0; +const shared_1 = __nccwpck_require__(25897); +const BasicEnumerable_1 = __nccwpck_require__(93706); +/** + * Produces the set intersection of two sequences by using the specified IEqualityComparer to compare values. + * If no comparer is selected, uses the StrictEqualityComparer. + * @param first An IEnumerable whose distinct elements that also appear in second will be returned. + * @param second An Iterable whose distinct elements that also appear in the first sequence will be returned. + * @param comparer An IEqualityComparer to compare values. Optional. + * @returns A sequence that contains the elements that form the set intersection of two sequences. + */ +exports.intersect = (first, second, comparer = shared_1.StrictEqualityComparer) => { + function* iterator() { + const firstResults = [...first.distinct(comparer)]; + if (firstResults.length === 0) { + return; + } + const secondResults = [...second]; + for (let i = 0; i < firstResults.length; i++) { + const firstValue = firstResults[i]; + for (let j = 0; j < secondResults.length; j++) { + const secondValue = secondResults[j]; + if (comparer(firstValue, secondValue) === true) { + yield firstValue; + break; + } + } + } + } + return new BasicEnumerable_1.BasicEnumerable(iterator); +}; + + +/***/ }), + +/***/ 96380: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.intersectAsync = void 0; +const fromAsync_1 = __nccwpck_require__(55641); +/** + * Produces the set intersection of two sequences by using the specified IAsyncEqualityComparer to compare values. + * @param first An IEnumerable whose distinct elements that also appear in second will be returned. + * @param second An Iterable whose distinct elements that also appear in the first sequence will be returned. + * @param comparer An IAsyncEqualityComparer to compare values. + * @returns A sequence that contains the elements that form the set intersection of two sequences. + */ +exports.intersectAsync = (first, second, comparer) => { + async function* iterator() { + const firstResults = []; + for await (const item of first.distinctAsync(comparer)) { + firstResults.push(item); + } + if (firstResults.length === 0) { + return; + } + const secondResults = [...second]; + for (let i = 0; i < firstResults.length; i++) { + const firstValue = firstResults[i]; + for (let j = 0; j < secondResults.length; j++) { + const secondValue = secondResults[j]; + if (await comparer(firstValue, secondValue) === true) { + yield firstValue; + break; + } + } + } + } + return fromAsync_1.fromAsync(iterator); +}; + + +/***/ }), + +/***/ 25095: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.join = void 0; +const shared_1 = __nccwpck_require__(25897); +const BasicEnumerable_1 = __nccwpck_require__(93706); +// TODO: join Async +/** + * Correlates the elements of two sequences based on matching keys. + * A specified IEqualityComparer is used to compare keys or the strict equality comparer. + * @param outer The first sequence to join. + * @param inner The sequence to join to the first sequence. + * @param outerKeySelector A function to extract the join key from each element of the first sequence. + * @param innerKeySelector A function to extract the join key from each element of the second sequence. + * @param resultSelector A function to create a result element from two matching elements. + * @param comparer An IEqualityComparer to hash and compare keys. Optional. + * @returns An IEnumerable that has elements of type TResult that + * are obtained by performing an inner join on two sequences. + */ +exports.join = (outer, inner, outerKeySelector, innerKeySelector, resultSelector, comparer = shared_1.StrictEqualityComparer) => { + function* iterator() { + const innerArray = [...inner]; + for (const o of outer) { + const outerKey = outerKeySelector(o); + for (const i of innerArray) { + const innerKey = innerKeySelector(i); + if (comparer(outerKey, innerKey) === true) { + yield resultSelector(o, i); + } + } + } + } + return new BasicEnumerable_1.BasicEnumerable(iterator); +}; + + +/***/ }), + +/***/ 97768: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.last = void 0; +const shared_1 = __nccwpck_require__(25897); +/** + * Returns the last element of a sequence. + * If predicate is specified, the last element of a sequence that satisfies a specified condition. + * @param source An Iterable to return the last element of. + * @param predicate A function to test each element for a condition. Optional. + * @throws {InvalidOperationException} The source sequence is empty. + * @returns The value at the last position in the source sequence + * or the last element in the sequence that passes the test in the specified predicate function. + */ +exports.last = (source, predicate) => { + if (predicate) { + return last2(source, predicate); + } + else { + return last1(source); + } +}; +const last1 = (source) => { + let lastItem; + for (const value of source) { + lastItem = value; + } + if (!lastItem) { + throw new shared_1.InvalidOperationException(shared_1.ErrorString.NoElements); + } + return lastItem; +}; +const last2 = (source, predicate) => { + let lastItem; + for (const value of source) { + if (predicate(value) === true) { + lastItem = value; + } + } + if (!lastItem) { + throw new shared_1.InvalidOperationException(shared_1.ErrorString.NoMatch); + } + return lastItem; +}; + + +/***/ }), + +/***/ 37040: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.lastAsync = void 0; +const shared_1 = __nccwpck_require__(25897); +/** + * Returns the last element of a sequence that satisfies a specified condition. + * @param source An Iterable to return the last element of. + * @param predicate A function to test each element for a condition. + * @throws {InvalidOperationException} The source sequence is empty. + * @returns The last element in the sequence that passes the test in the specified predicate function. + */ +exports.lastAsync = async (source, predicate) => { + let last; + for (const value of source) { + if (await predicate(value) === true) { + last = value; + } + } + if (!last) { + throw new shared_1.InvalidOperationException(shared_1.ErrorString.NoMatch); + } + return last; +}; + + +/***/ }), + +/***/ 89490: +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.lastOrDefault = void 0; +/** + * Returns the last element of a sequence. + * If predicate is specified, the last element of a sequence that satisfies a specified condition. + * @param source An Iterable to return the last element of. + * @param predicate A function to test each element for a condition. Optional. + * @returns The value at the last position in the source sequence + * or the last element in the sequence that passes the test in the specified predicate function. + */ +function lastOrDefault(source, predicate) { + if (predicate) { + return lastOrDefault2(source, predicate); + } + else { + return lastOrDefault1(source); + } +} +exports.lastOrDefault = lastOrDefault; +const lastOrDefault1 = (source) => { + let last = null; + for (const value of source) { + last = value; + } + return last; +}; +const lastOrDefault2 = (source, predicate) => { + let last = null; + for (const value of source) { + if (predicate(value) === true) { + last = value; + } + } + return last; +}; + + +/***/ }), + +/***/ 84899: +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.lastOrDefaultAsync = void 0; +/** + * Returns the last element of a sequence that satisfies a specified condition. + * @param source An Iterable to return the last element of. + * @param predicate A function to test each element for a condition. + * @returns The last element in the sequence that passes the test in the specified predicate function. + * Null if no elements. + */ +exports.lastOrDefaultAsync = async (source, predicate) => { + let last = null; + for (const value of source) { + if (await predicate(value) === true) { + last = value; + } + } + return last; +}; + + +/***/ }), + +/***/ 16526: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.max = void 0; +const shared_1 = __nccwpck_require__(25897); +function max(source, selector) { + if (selector) { + return max2(source, selector); + } + else { + return max1(source); + } +} +exports.max = max; +const max1 = (source) => { + let maxItem = null; + for (const item of source) { + maxItem = Math.max(maxItem || Number.NEGATIVE_INFINITY, item); + } + if (maxItem === null) { + throw new shared_1.InvalidOperationException(shared_1.ErrorString.NoElements); + } + else { + return maxItem; + } +}; +const max2 = (source, selector) => { + let maxItem = null; + for (const item of source) { + maxItem = Math.max(maxItem || Number.NEGATIVE_INFINITY, selector(item)); + } + if (maxItem === null) { + throw new shared_1.InvalidOperationException(shared_1.ErrorString.NoElements); + } + else { + return maxItem; + } +}; + + +/***/ }), + +/***/ 50485: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.maxAsync = void 0; +const shared_1 = __nccwpck_require__(25897); +/** + * Invokes an async transform function on each element of a sequence and returns the maximum value. + * @param source A sequence of values to determine the maximum value of. + * @param selector A transform function to apply to each element. + * @throws {InvalidOperationException} source contains no elements. + * @returns The maximum value in the sequence. + */ +exports.maxAsync = async (source, selector) => { + let max = null; + for (const item of source) { + max = Math.max(max || Number.NEGATIVE_INFINITY, await selector(item)); + } + if (max === null) { + throw new shared_1.InvalidOperationException(shared_1.ErrorString.NoElements); + } + else { + return max; + } +}; + + +/***/ }), + +/***/ 80031: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.min = void 0; +const shared_1 = __nccwpck_require__(25897); +function min(source, selector) { + if (selector) { + return min2(source, selector); + } + else { + return min1(source); + } +} +exports.min = min; +const min1 = (source) => { + let minItem = null; + for (const item of source) { + minItem = Math.min(minItem || Number.POSITIVE_INFINITY, item); + } + if (minItem === null) { + throw new shared_1.InvalidOperationException(shared_1.ErrorString.NoElements); + } + else { + return minItem; + } +}; +const min2 = (source, selector) => { + let minItem = null; + for (const item of source) { + minItem = Math.min(minItem || Number.POSITIVE_INFINITY, selector(item)); + } + if (minItem === null) { + throw new shared_1.InvalidOperationException(shared_1.ErrorString.NoElements); + } + else { + return minItem; + } +}; + + +/***/ }), + +/***/ 35475: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.minAsync = void 0; +const shared_1 = __nccwpck_require__(25897); +/** + * Invokes a transform function on each element of a sequence and returns the minimum value. + * @param source A sequence of values to determine the minimum value of. + * @param selector A transform function to apply to each element. + * @throws {InvalidOperationException} source contains no elements. + * @returns The minimum value in the sequence. + */ +exports.minAsync = async (source, selector) => { + let min = null; + for (const item of source) { + min = Math.min(min || Number.POSITIVE_INFINITY, await selector(item)); + } + if (min === null) { + throw new shared_1.InvalidOperationException(shared_1.ErrorString.NoElements); + } + else { + return min; + } +}; + + +/***/ }), + +/***/ 41334: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.ofType = void 0; +const BasicEnumerable_1 = __nccwpck_require__(93706); +/** + * Applies a type filter to a source iteration + * @param source Iteration to Filtery by Type + * @param type Either value for typeof or a consturctor function + * @returns Values that match the type string or are instance of type + */ +exports.ofType = (source, type) => { + const typeCheck = typeof type === "string" ? + ((x) => typeof x === type) : + ((x) => x instanceof type); + function* iterator() { + for (const item of source) { + if (typeCheck(item)) { + yield item; + } + } + } + return new BasicEnumerable_1.BasicEnumerable(iterator); +}; + + +/***/ }), + +/***/ 123: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.orderBy = void 0; +const OrderedEnumerable_1 = __nccwpck_require__(48249); +/** + * Sorts the elements of a sequence in ascending order by using a specified or default comparer. + * @param source A sequence of values to order. + * @param keySelector A function to extract a key from an element. + * @param comparer An IComparer to compare keys. Optional. + * @returns An IOrderedEnumerable whose elements are sorted according to a key. + */ +function orderBy(source, keySelector, comparer) { + return OrderedEnumerable_1.OrderedEnumerable.generate(source, keySelector, true, comparer); +} +exports.orderBy = orderBy; + + +/***/ }), + +/***/ 95293: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.orderByAsync = void 0; +const OrderedEnumerable_1 = __nccwpck_require__(48249); +/** + * Sorts the elements of a sequence in ascending order by using a specified comparer. + * @param source A sequence of values to order. + * @param keySelector An async function to extract a key from an element. + * @param comparer An IComparer to compare keys. + * @returns An IOrderedAsyncEnumerable whose elements are sorted according to a key. + */ +function orderByAsync(source, keySelector, comparer) { + return OrderedEnumerable_1.OrderedEnumerable.generateAsync(source, keySelector, true, comparer); +} +exports.orderByAsync = orderByAsync; + + +/***/ }), + +/***/ 41098: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.orderByDescending = void 0; +const OrderedEnumerable_1 = __nccwpck_require__(48249); +/** + * Sorts the elements of a sequence in descending order by using a specified or default comparer. + * @param source A sequence of values to order. + * @param keySelector A function to extract a key from an element. + * @param comparer An IComparer to compare keys. Optional. + * @returns An IOrderedEnumerable whose elements are sorted in descending order according to a key. + */ +function orderByDescending(source, keySelector, comparer) { + return OrderedEnumerable_1.OrderedEnumerable.generate(source, keySelector, false, comparer); +} +exports.orderByDescending = orderByDescending; + + +/***/ }), + +/***/ 89594: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.orderByDescendingAsync = void 0; +const OrderedEnumerable_1 = __nccwpck_require__(48249); +/** + * Sorts the elements of a sequence in descending order by using a specified comparer. + * @param source A sequence of values to order. + * @param keySelector An async function to extract a key from an element. + * @param comparer An IComparer to compare keys. + * @returns An IOrderedAsyncEnumerable whose elements are sorted in descending order according to a key. + */ +function orderByDescendingAsync(source, keySelector, comparer) { + return OrderedEnumerable_1.OrderedEnumerable.generateAsync(source, keySelector, false, comparer); +} +exports.orderByDescendingAsync = orderByDescendingAsync; + + +/***/ }), + +/***/ 85631: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.reverse = void 0; +const BasicEnumerable_1 = __nccwpck_require__(93706); +/** + * Inverts the order of the elements in a sequence. + * @param source A sequence of values to reverse. + * @returns A sequence whose elements correspond to those of the input sequence in reverse order. + */ +exports.reverse = (source) => { + function* iterator() { + for (const x of [...source].reverse()) { + yield x; + } + } + return new BasicEnumerable_1.BasicEnumerable(iterator); +}; + + +/***/ }), + +/***/ 92998: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.select = void 0; +const BasicEnumerable_1 = __nccwpck_require__(93706); +/** + * Projects each element of a sequence into a new form. + * @param source A sequence of values to invoke a transform function on. + * @param selector A key of TSource. + * @returns + * An IEnumerable whose elements are the result of getting the value from the key on each element of source. + */ +function select(source, selector) { + if (typeof selector === "function") { + const { length } = selector; + if (length === 1) { + return select1(source, selector); + } + else { + return select2(source, selector); + } + } + else { + return select3(source, selector); + } +} +exports.select = select; +const select1 = (source, selector) => { + function* iterator() { + for (const value of source) { + yield selector(value); + } + } + return new BasicEnumerable_1.BasicEnumerable(iterator); +}; +const select2 = (source, selector) => { + function* iterator() { + let index = 0; + for (const value of source) { + yield selector(value, index); + index++; + } + } + return new BasicEnumerable_1.BasicEnumerable(iterator); +}; +const select3 = (source, key) => { + function* iterator() { + for (const value of source) { + yield value[key]; + } + } + return new BasicEnumerable_1.BasicEnumerable(iterator); +}; + + +/***/ }), + +/***/ 89362: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.selectAsync = void 0; +const fromAsync_1 = __nccwpck_require__(55641); +function selectAsync(source, selector) { + if (typeof selector === "function") { + if (selector.length === 1) { + return selectAsync1(source, selector); + } + else { + return selectAsync2(source, selector); + } + } + else { + // eslint-disable-next-line @typescript-eslint/no-unsafe-return + return selectAsync3(source, selector); + } +} +exports.selectAsync = selectAsync; +const selectAsync1 = (source, selector) => { + async function* iterator() { + for (const value of source) { + yield selector(value); + } + } + return fromAsync_1.fromAsync(iterator); +}; +const selectAsync2 = (source, selector) => { + async function* iterator() { + let index = 0; + for (const value of source) { + yield selector(value, index); + index++; + } + } + return fromAsync_1.fromAsync(iterator); +}; +const selectAsync3 = (source, key) => { + async function* iterator() { + for (const value of source) { + yield value[key]; + } + } + return fromAsync_1.fromAsync(iterator); +}; + + +/***/ }), + +/***/ 49430: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.selectMany = void 0; +const BasicEnumerable_1 = __nccwpck_require__(93706); +function selectMany(source, selector) { + if (typeof selector === "function") { + if (selector.length === 1) { + return selectMany1(source, selector); + } + else { + return selectMany2(source, selector); + } + } + else { + return selectMany3(source, selector); + } +} +exports.selectMany = selectMany; +const selectMany1 = (source, selector) => { + function* iterator() { + for (const value of source) { + for (const selectorValue of selector(value)) { + yield selectorValue; + } + } + } + return new BasicEnumerable_1.BasicEnumerable(iterator); +}; +const selectMany2 = (source, selector) => { + function* iterator() { + let index = 0; + for (const value of source) { + for (const selectorValue of selector(value, index)) { + yield selectorValue; + } + index++; + } + } + return new BasicEnumerable_1.BasicEnumerable(iterator); +}; +const selectMany3 = (source, selector) => { + function* iterator() { + for (const value of source) { + for (const selectorValue of value[selector]) { + yield selectorValue; + } + } + } + return new BasicEnumerable_1.BasicEnumerable(iterator); +}; + + +/***/ }), + +/***/ 3796: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.selectManyAsync = void 0; +const fromAsync_1 = __nccwpck_require__(55641); +/** + * Projects each element of a sequence to an IAsyncEnumerable and flattens the resulting sequences into one sequence. + * @param source A sequence of values to project. + * @param selector A transform function to apply to each element. + * @returns An IAsyncEnumerable whose elements are the result of invoking the + * one-to-many transform function on each element of the input sequence. + */ +function selectManyAsync(source, selector) { + if (selector.length === 1) { + return selectManyAsync1(source, selector); + } + else { + return selectManyAsync2(source, selector); + } +} +exports.selectManyAsync = selectManyAsync; +const selectManyAsync1 = (source, selector) => { + async function* generator() { + for (const value of source) { + const innerValues = await selector(value); + for (const innerValue of innerValues) { + yield innerValue; + } + } + } + return fromAsync_1.fromAsync(generator); +}; +const selectManyAsync2 = (source, selector) => { + async function* generator() { + let index = 0; + for (const value of source) { + const innerValues = await selector(value, index); + for (const innerValue of innerValues) { + yield innerValue; + } + index++; + } + } + return fromAsync_1.fromAsync(generator); +}; + + +/***/ }), + +/***/ 41748: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.sequenceEquals = void 0; +const shared_1 = __nccwpck_require__(25897); +/** + * Determines whether or not two sequences are equal + * @param first first iterable + * @param second second iterable + * @param comparer Compare function to use, by default is @see {StrictEqualityComparer} + * @returns Whether or not the two iterables are equal + */ +function sequenceEquals(first, second, comparer = shared_1.StrictEqualityComparer) { + const firstIterator = first[Symbol.iterator](); + const secondIterator = second[Symbol.iterator](); + let firstResult = firstIterator.next(); + let secondResult = secondIterator.next(); + while (!firstResult.done && !secondResult.done) { + if (!comparer(firstResult.value, secondResult.value)) { + return false; + } + firstResult = firstIterator.next(); + secondResult = secondIterator.next(); + } + return firstResult.done === true && secondResult.done === true; +} +exports.sequenceEquals = sequenceEquals; + + +/***/ }), + +/***/ 66249: +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.sequenceEqualsAsync = void 0; +/** + * Compares two sequences to see if they are equal using a async comparer function. + * @param first First Sequence + * @param second Second Sequence + * @param comparer Async Comparer + * @returns Whether or not the two iterations are equal + */ +async function sequenceEqualsAsync(first, second, comparer) { + const firstIterator = first[Symbol.iterator](); + const secondIterator = second[Symbol.iterator](); + let firstResult = firstIterator.next(); + let secondResult = secondIterator.next(); + while (!firstResult.done && !secondResult.done) { + if (await comparer(firstResult.value, secondResult.value) === false) { + return false; + } + firstResult = firstIterator.next(); + secondResult = secondIterator.next(); + } + return firstResult.done === true && secondResult.done === true; +} +exports.sequenceEqualsAsync = sequenceEqualsAsync; + + +/***/ }), + +/***/ 44579: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.single = void 0; +const shared_1 = __nccwpck_require__(25897); +/** + * Returns the only element of a sequence that satisfies a specified condition (if specified), + * and throws an exception if more than one such element exists. + * @param source An Iterable to return a single element from. + * @param predicate A function to test an element for a condition. (Optional) + * @throws {InvalidOperationException} No element satisfies the condition in predicate. OR + * More than one element satisfies the condition in predicate. OR + * The source sequence is empty. + * @returns The single element of the input sequence that satisfies a condition. + */ +exports.single = (source, predicate) => { + if (predicate) { + return single2(source, predicate); + } + else { + return single1(source); + } +}; +const single1 = (source) => { + let hasValue = false; + let singleValue = null; + for (const value of source) { + if (hasValue === true) { + throw new shared_1.InvalidOperationException(shared_1.ErrorString.MoreThanOneElement); + } + else { + hasValue = true; + singleValue = value; + } + } + if (hasValue === false) { + throw new shared_1.InvalidOperationException(shared_1.ErrorString.NoElements); + } + return singleValue; +}; +const single2 = (source, predicate) => { + let hasValue = false; + let singleValue = null; + for (const value of source) { + if (predicate(value)) { + if (hasValue === true) { + throw new shared_1.InvalidOperationException(shared_1.ErrorString.MoreThanOneMatchingElement); + } + else { + hasValue = true; + singleValue = value; + } + } + } + if (hasValue === false) { + throw new shared_1.InvalidOperationException(shared_1.ErrorString.NoMatch); + } + return singleValue; +}; + + +/***/ }), + +/***/ 91488: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.singleAsync = void 0; +const shared_1 = __nccwpck_require__(25897); +/** + * Returns the only element of a sequence that satisfies a specified condition, + * and throws an exception if more than one such element exists. + * @param source An Iterable to return a single element from. + * @param predicate A function to test an element for a condition. + * @throws {InvalidOperationException} + * No element satisfies the condition in predicate. OR + * More than one element satisfies the condition in predicate. OR + * The source sequence is empty. + * @returns The single element of the input sequence that satisfies a condition. + */ +exports.singleAsync = async (source, predicate) => { + let hasValue = false; + let singleValue = null; + for (const value of source) { + if (await predicate(value)) { + if (hasValue === true) { + throw new shared_1.InvalidOperationException(shared_1.ErrorString.MoreThanOneMatchingElement); + } + else { + hasValue = true; + singleValue = value; + } + } + } + if (hasValue === false) { + throw new shared_1.InvalidOperationException(shared_1.ErrorString.NoMatch); + } + return singleValue; +}; + + +/***/ }), + +/***/ 44811: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.singleOrDefault = void 0; +const shared_1 = __nccwpck_require__(25897); +/** + * If predicate is specified returns the only element of a sequence that satisfies a specified condition, + * ootherwise returns the only element of a sequence. Returns a default value if no such element exists. + * @param source An Iterable to return a single element from. + * @param predicate A function to test an element for a condition. Optional. + * @throws {InvalidOperationException} + * If predicate is specified more than one element satisfies the condition in predicate, + * otherwise the input sequence contains more than one element. + * @returns The single element of the input sequence that satisfies the condition, + * or null if no such element is found. + */ +exports.singleOrDefault = (source, predicate) => { + if (predicate) { + return singleOrDefault2(source, predicate); + } + else { + return singleOrDefault1(source); + } +}; +const singleOrDefault1 = (source) => { + let hasValue = false; + let singleValue = null; + for (const value of source) { + if (hasValue === true) { + throw new shared_1.InvalidOperationException(shared_1.ErrorString.MoreThanOneElement); + } + else { + hasValue = true; + singleValue = value; + } + } + return singleValue; +}; +const singleOrDefault2 = (source, predicate) => { + let hasValue = false; + let singleValue = null; + for (const value of source) { + if (predicate(value)) { + if (hasValue === true) { + throw new shared_1.InvalidOperationException(shared_1.ErrorString.MoreThanOneMatchingElement); + } + else { + hasValue = true; + singleValue = value; + } + } + } + return singleValue; +}; + + +/***/ }), + +/***/ 56250: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.singleOrDefaultAsync = void 0; +const shared_1 = __nccwpck_require__(25897); +/** + * Returns the only element of a sequence that satisfies a specified condition. + * Returns a default value if no such element exists. + * @param source An Iterable to return a single element from. + * @param predicate A function to test an element for a condition. Optional. + * @throws {InvalidOperationException} + * If predicate is specified more than one element satisfies the condition in predicate, + * otherwise the input sequence contains more than one element. + * @returns The single element of the input sequence that satisfies the condition, + * or null if no such element is found. + */ +exports.singleOrDefaultAsync = async (source, predicate) => { + let hasValue = false; + let singleValue = null; + for (const value of source) { + if (await predicate(value)) { + if (hasValue === true) { + throw new shared_1.InvalidOperationException(shared_1.ErrorString.MoreThanOneElement); + } + else { + hasValue = true; + singleValue = value; + } + } + } + return singleValue; +}; + + +/***/ }), + +/***/ 71504: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.skip = void 0; +const BasicEnumerable_1 = __nccwpck_require__(93706); +/** + * Bypasses a specified number of elements in a sequence and then returns the remaining elements. + * @param source An Iterable to return elements from. + * @param count The number of elements to skip before returning the remaining elements. + * @returns An IEnumerable that contains the elements that occur after the specified index in the input sequence. + */ +exports.skip = (source, count) => { + function* iterator() { + let i = 0; + for (const item of source) { + if (i++ >= count) { + yield item; + } + } + } + return new BasicEnumerable_1.BasicEnumerable(iterator); +}; + + +/***/ }), + +/***/ 39517: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.skipWhile = void 0; +const BasicEnumerable_1 = __nccwpck_require__(93706); +/** + * Bypasses elements in a sequence as long as a specified condition is true and then returns the remaining elements. + * The element's index is used in the logic of the predicate function. + * @param source An Iterable to return elements from. + * @param predicate A function to test each source element for a condition; + * the second parameter of the function represents the index of the source element. + * @returns An IEnumerable that contains the elements from the input sequence starting at the first element + * in the linear series that does not pass the test specified by predicate. + */ +exports.skipWhile = (source, predicate) => { + if (predicate.length === 1) { + return skipWhile1(source, predicate); + } + else { + return skipWhile2(source, predicate); + } +}; +const skipWhile1 = (source, predicate) => { + function* iterator() { + let skip = true; + for (const item of source) { + if (skip === false) { + yield item; + } + else if (predicate(item) === false) { + skip = false; + yield item; + } + } + } + return new BasicEnumerable_1.BasicEnumerable(iterator); +}; +const skipWhile2 = (source, predicate) => { + function* iterator() { + let index = 0; + let skip = true; + for (const item of source) { + if (skip === false) { + yield item; + } + else if (predicate(item, index) === false) { + skip = false; + yield item; + } + index++; + } + } + return new BasicEnumerable_1.BasicEnumerable(iterator); +}; + + +/***/ }), + +/***/ 27112: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.skipWhileAsync = void 0; +const fromAsync_1 = __nccwpck_require__(55641); +/** + * Bypasses elements in a sequence as long as a specified condition is true and then returns the remaining elements. + * The element's index is used in the logic of the predicate function. + * @param source An Iterable to return elements from. + * @param predicate A function to test each source element for a condition; + * the second parameter of the function represents the index of the source element. + * @returns An IAsyncEnumerable that contains the elements from the input sequence starting + * at the first element in the linear series that does not pass the test specified by predicate. + */ +exports.skipWhileAsync = (source, predicate) => { + if (predicate.length === 1) { + return skipWhileAsync1(source, predicate); + } + else { + return skipWhileAsync2(source, predicate); + } +}; +const skipWhileAsync1 = (source, predicate) => { + async function* iterator() { + let skip = true; + for (const item of source) { + if (skip === false) { + yield item; + } + else if (await predicate(item) === false) { + skip = false; + yield item; + } + } + } + return fromAsync_1.fromAsync(iterator); +}; +const skipWhileAsync2 = (source, predicate) => { + async function* iterator() { + let index = 0; + let skip = true; + for (const item of source) { + if (skip === false) { + yield item; + } + else if (await predicate(item, index) === false) { + skip = false; + yield item; + } + index++; + } + } + return fromAsync_1.fromAsync(iterator); +}; + + +/***/ }), + +/***/ 4747: +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.sum = void 0; +function sum(source, selector) { + if (selector) { + return sum2(source, selector); + } + else { + return sum1(source); + } +} +exports.sum = sum; +const sum1 = (source) => { + let total = 0; + for (const value of source) { + total += value; + } + return total; +}; +const sum2 = (source, selector) => { + let total = 0; + for (const value of source) { + total += selector(value); + } + return total; +}; + + +/***/ }), + +/***/ 85914: +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.sumAsync = void 0; +/** + * Computes the sum of the sequence of numeric values that are obtained by invoking a transform function + * on each element of the input sequence. + * @param source A sequence of values that are used to calculate a sum. + * @param selector A transform function to apply to each element. + * @returns The sum of the projected values. + */ +exports.sumAsync = async (source, selector) => { + let sum = 0; + for (const value of source) { + sum += await selector(value); + } + return sum; +}; + + +/***/ }), + +/***/ 37429: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.take = void 0; +const BasicEnumerable_1 = __nccwpck_require__(93706); +/** + * Returns a specified number of contiguous elements from the start of a sequence. + * @param source The sequence to return elements from. + * @param amount The number of elements to return. + * @returns An IEnumerable that contains the specified number of elements from the start of the input sequence. + */ +exports.take = (source, amount) => { + function* iterator() { + // negative amounts should yield empty + let amountLeft = amount > 0 ? amount : 0; + for (const item of source) { + if (amountLeft-- === 0) { + break; + } + else { + yield item; + } + } + } + return new BasicEnumerable_1.BasicEnumerable(iterator); +}; + + +/***/ }), + +/***/ 33875: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.takeWhile = void 0; +const BasicEnumerable_1 = __nccwpck_require__(93706); +/** + * Returns elements from a sequence as long as a specified condition is true. + * The element's index is used in the logic of the predicate function. + * @param source The sequence to return elements from. + * @param predicate A function to test each source element for a condition; + * the second parameter of the function represents the index of the source element. + * @returns An IEnumerable that contains elements from the input sequence + * that occur before the element at which the test no longer passes. + */ +exports.takeWhile = (source, predicate) => { + if (predicate.length === 1) { + return takeWhile1(source, predicate); + } + else { + return takeWhile2(source, predicate); + } +}; +const takeWhile1 = (source, predicate) => { + /** + * @internal + */ + function* iterator() { + for (const item of source) { + if (predicate(item)) { + yield item; + } + else { + break; + } + } + } + return new BasicEnumerable_1.BasicEnumerable(iterator); +}; +const takeWhile2 = (source, predicate) => { + function* iterator() { + let index = 0; + for (const item of source) { + if (predicate(item, index++)) { + yield item; + } + else { + break; + } + } + } + return new BasicEnumerable_1.BasicEnumerable(iterator); +}; + + +/***/ }), + +/***/ 74277: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.takeWhileAsync = void 0; +const fromAsync_1 = __nccwpck_require__(55641); +/** + * Returns elements from a sequence as long as a specified condition is true. + * The element's index is used in the logic of the predicate function. + * @param source The sequence to return elements from. + * @param predicate A async function to test each source element for a condition; + * the second parameter of the function represents the index of the source element. + * @returns An IAsyncEnumerable that contains elements from the input sequence + * that occur before the element at which the test no longer passes. + */ +function takeWhileAsync(source, predicate) { + if (predicate.length === 1) { + return takeWhileAsync1(source, predicate); + } + else { + return takeWhileAsync2(source, predicate); + } +} +exports.takeWhileAsync = takeWhileAsync; +const takeWhileAsync1 = (source, predicate) => { + async function* iterator() { + for (const item of source) { + if (await predicate(item)) { + yield item; + } + else { + break; + } + } + } + return fromAsync_1.fromAsync(iterator); +}; +const takeWhileAsync2 = (source, predicate) => { + async function* iterator() { + let index = 0; + for (const item of source) { + if (await predicate(item, index++)) { + yield item; + } + else { + break; + } + } + } + return fromAsync_1.fromAsync(iterator); +}; + + +/***/ }), + +/***/ 37708: +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.toArray = void 0; +/** + * Creates an array from a Iterable. + * @param source An Iterable to create an array from. + * @returns An array of elements + */ +exports.toArray = (source) => { + return [...source]; +}; + + +/***/ }), + +/***/ 35036: +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.toMap = void 0; +/** + * Converts an Iterable to a Map. + * @param source An Iterable to convert. + * @param selector A function to serve as a key selector. + * @returns Map + */ +exports.toMap = (source, selector) => { + const map = new Map(); + for (const value of source) { + const key = selector(value); + const array = map.get(key); + if (array === undefined) { + map.set(key, [value]); + } + else { + array.push(value); + } + } + return map; +}; + + +/***/ }), + +/***/ 42124: +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.toMapAsync = void 0; +/** + * Converts an Iterable to a Map. + * @param source An Iterable to convert. + * @param selector An async function to serve as a key selector. + * @returns A promise for Map + */ +async function toMapAsync(source, selector) { + const map = new Map(); + for (const value of source) { + const key = await selector(value); + const array = map.get(key); + if (array === undefined) { + map.set(key, [value]); + } + else { + array.push(value); + } + } + return map; +} +exports.toMapAsync = toMapAsync; + + +/***/ }), + +/***/ 4469: +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.toSet = void 0; +/** + * Converts the Itertion to a Set + * @param source Iteration + * @returns Set containing the iteration values + */ +exports.toSet = (source) => { + return new Set(source); +}; + + +/***/ }), + +/***/ 93396: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.union = void 0; +const BasicEnumerable_1 = __nccwpck_require__(93706); +/** + * Produces the set union of two sequences by using scrict equality comparison or a specified IEqualityComparer. + * @param first An Iterable whose distinct elements form the first set for the union. + * @param second An Iterable whose distinct elements form the second set for the union. + * @param comparer The IEqualityComparer to compare values. Optional. + * @returns An IEnumerable that contains the elements from both input sequences, excluding duplicates. + */ +exports.union = (first, second, comparer) => { + if (comparer) { + return union2(first, second, comparer); + } + else { + return union1(first, second); + } +}; +const union1 = (first, second) => { + function* iterator() { + const set = new Set(); + for (const item of first) { + if (set.has(item) === false) { + yield item; + set.add(item); + } + } + for (const item of second) { + if (set.has(item) === false) { + yield item; + set.add(item); + } + } + } + return new BasicEnumerable_1.BasicEnumerable(iterator); +}; +const union2 = (first, second, comparer) => { + function* iterator() { + const result = []; + for (const source of [first, second]) { + for (const value of source) { + let exists = false; + for (const resultValue of result) { + if (comparer(value, resultValue) === true) { + exists = true; + break; + } + } + if (exists === false) { + yield value; + result.push(value); + } + } + } + } + return new BasicEnumerable_1.BasicEnumerable(iterator); +}; + + +/***/ }), + +/***/ 45489: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.unionAsync = void 0; +const fromAsync_1 = __nccwpck_require__(55641); +/** + * Produces the set union of two sequences by using a specified IAsyncEqualityComparer. + * @param first An Iterable whose distinct elements form the first set for the union. + * @param second An Iterable whose distinct elements form the second set for the union. + * @param comparer The IAsyncEqualityComparer to compare values. + * @returns An IAsyncEnumerable that contains the elements from both input sequences, excluding duplicates. + */ +exports.unionAsync = (first, second, comparer) => { + async function* iterator() { + const result = []; + for (const source of [first, second]) { + for (const value of source) { + let exists = false; + for (const resultValue of result) { + if (await comparer(value, resultValue) === true) { + exists = true; + break; + } + } + if (exists === false) { + yield value; + result.push(value); + } + } + } + } + return fromAsync_1.fromAsync(iterator); +}; + + +/***/ }), + +/***/ 92745: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.where = void 0; +const BasicEnumerable_1 = __nccwpck_require__(93706); +/** + * Filters a sequence of values based on a predicate. + * Each element's index is used in the logic of the predicate function. + * @param source An Iterable to filter. + * @param predicate A function to test each source element for a condition; + * the second parameter of the function represents the index of the source element. + * @returns An IEnumerable that contains elements from the input sequence that satisfy the condition. + */ +exports.where = (source, predicate) => { + if (predicate.length === 1) { + return where1(source, predicate); + } + else { + return where2(source, predicate); + } +}; +const where1 = (source, predicate) => { + function* iterator() { + for (const item of source) { + if (predicate(item) === true) { + yield item; + } + } + } + return new BasicEnumerable_1.BasicEnumerable(iterator); +}; +const where2 = (source, predicate) => { + function* iterator() { + let i = 0; + for (const item of source) { + if (predicate(item, i++) === true) { + yield item; + } + } + } + return new BasicEnumerable_1.BasicEnumerable(iterator); +}; + + +/***/ }), + +/***/ 52971: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.whereAsync = void 0; +const fromAsync_1 = __nccwpck_require__(55641); +/** + * Filters a sequence of values based on a predicate. + * Each element's index is used in the logic of the predicate function. + * @param source An Iterable to filter. + * @param predicate A async function to test each source element for a condition; + * the second parameter of the function represents the index of the source element. + * @returns An IAsyncEnumerable that contains elements from the input sequence that satisfy the condition. + */ +exports.whereAsync = (source, predicate) => { + if (predicate.length === 1) { + return whereAsync1(source, predicate); + } + else { + return whereAsync2(source, predicate); + } +}; +const whereAsync1 = (source, predicate) => { + async function* generator() { + for (const item of source) { + if (await predicate(item) === true) { + yield item; + } + } + } + return fromAsync_1.fromAsync(generator); +}; +const whereAsync2 = (source, predicate) => { + async function* generator() { + let i = 0; + for (const item of source) { + if (await predicate(item, i++) === true) { + yield item; + } + } + } + return fromAsync_1.fromAsync(generator); +}; + + +/***/ }), + +/***/ 44172: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.zip = void 0; +const BasicEnumerable_1 = __nccwpck_require__(93706); +function zip(source, second, resultSelector) { + if (resultSelector) { + return zip2(source, second, resultSelector); + } + else { + return zip1(source, second); + } +} +exports.zip = zip; +const zip1 = (source, second) => { + function* iterator() { + const firstIterator = source[Symbol.iterator](); + const secondIterator = second[Symbol.iterator](); + while (true) { + const a = firstIterator.next(); + const b = secondIterator.next(); + if (a.done && b.done) { + break; + } + else { + yield [a.value, b.value]; + } + } + } + return new BasicEnumerable_1.BasicEnumerable(iterator); +}; +const zip2 = (source, second, resultSelector) => { + function* iterator() { + const firstIterator = source[Symbol.iterator](); + const secondIterator = second[Symbol.iterator](); + while (true) { + const a = firstIterator.next(); + const b = secondIterator.next(); + if (a.done && b.done) { + break; + } + else { + yield resultSelector(a.value, b.value); + } + } + } + return new BasicEnumerable_1.BasicEnumerable(iterator); +}; + + +/***/ }), + +/***/ 23202: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.zipAsync = void 0; +const fromAsync_1 = __nccwpck_require__(55641); +/** + * Applies a specified async function to the corresponding elements of two sequences, + * producing a sequence of the results. + * @param first The first sequence to merge. + * @param second The second sequence to merge. + * @param resultSelector An async function that specifies how to merge the elements from the two sequences. + * @returns An IAsyncEnumerable that contains merged elements of two input sequences. + */ +exports.zipAsync = (first, second, resultSelector) => { + async function* generator() { + const firstIterator = first[Symbol.iterator](); + const secondIterator = second[Symbol.iterator](); + while (true) { + const a = firstIterator.next(); + const b = secondIterator.next(); + if (a.done && b.done) { + break; + } + else { + yield resultSelector(a.value, b.value); + } + } + } + return fromAsync_1.fromAsync(generator); +}; + + +/***/ }), + +/***/ 98120: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.isEnumerable = void 0; +const ArrayEnumerable_1 = __nccwpck_require__(18640); +const BasicEnumerable_1 = __nccwpck_require__(93706); +/* eslint-disable @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-member-access */ +/** + * Determine if a source is a IEnumerable + * @param source Any Value + * @returns Whether or not this is an Enumerable type + */ +exports.isEnumerable = (source) => { + if (!source) { + return false; + } + if (source instanceof BasicEnumerable_1.BasicEnumerable) { + return true; + } + if (source instanceof ArrayEnumerable_1.ArrayEnumerable) { + return true; + } + if (typeof source[Symbol.iterator] !== "function") { + return false; + } + const propertyNames = Object.getOwnPropertyNames(BasicEnumerable_1.BasicEnumerable.prototype) + .filter((v) => v !== "constructor"); + const methods = source.prototype || source; + for (const prop of propertyNames) { + if (typeof methods[prop] !== "function") { + return false; + } + } + return true; +}; + + +/***/ }), + +/***/ 24663: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.empty = void 0; +const BasicEnumerable_1 = __nccwpck_require__(93706); +/** + * Returns an empty IEnumerable that has the specified type argument. + * @returns An empty IEnumerable whose type argument is TResult. + */ +exports.empty = () => { + const iterator = function* () { + for (const x of []) { + yield x; + } + }; + return new BasicEnumerable_1.BasicEnumerable(iterator); +}; + + +/***/ }), + +/***/ 46696: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.enumerateObject = void 0; +const BasicEnumerable_1 = __nccwpck_require__(93706); +/** + * Iterates through the object + * @param source Source Object + * @returns IEnumerabe<[TKey, TValue]> of Key Value pairs + */ +exports.enumerateObject = (source) => { + function* iterable() { + // eslint-disable-next-line guard-for-in + for (const key in source) { + yield [key, source[key]]; + } + } + return new BasicEnumerable_1.BasicEnumerable(iterable); +}; + + +/***/ }), + +/***/ 84656: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.flatten = void 0; +const BasicEnumerable_1 = __nccwpck_require__(93706); +function flatten(source, shallow) { + // eslint-disable-next-line no-shadow + function* iterator(source) { + for (const item of source) { + // JS string is an Iterable. + // We exclude it from being flattened + // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access + if (item[Symbol.iterator] !== undefined && typeof item !== "string") { + yield* shallow ? item : iterator(item); + } + else { + yield item; + } + } + } + return new BasicEnumerable_1.BasicEnumerable(() => iterator(source)); +} +exports.flatten = flatten; + + +/***/ }), + +/***/ 57268: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.from = void 0; +const BasicEnumerable_1 = __nccwpck_require__(93706); +function from(source) { + const isArrayLike = (x) => { + return Array.isArray(x) || (typeof x === "object" && typeof x.length === "number" && (x.length === 0 || 0 in x)); + }; + const isIterableType = (x) => typeof x === "function"; + if (isArrayLike(source)) { + const generator = function* () { + for (let i = 0; i < source.length; i++) { + yield source[i]; + } + }; + return new BasicEnumerable_1.BasicEnumerable(generator); + } + if (isIterableType(source)) { + return new BasicEnumerable_1.BasicEnumerable(source); + } + return new BasicEnumerable_1.BasicEnumerable(function* () { + for (const val of source) { + yield val; + } + }); +} +exports.from = from; + + +/***/ }), + +/***/ 2374: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +var empty_1 = __nccwpck_require__(24663); +Object.defineProperty(exports, "empty", ({ enumerable: true, get: function () { return empty_1.empty; } })); +var enumerateObject_1 = __nccwpck_require__(46696); +Object.defineProperty(exports, "enumerateObject", ({ enumerable: true, get: function () { return enumerateObject_1.enumerateObject; } })); +var flatten_1 = __nccwpck_require__(84656); +Object.defineProperty(exports, "flatten", ({ enumerable: true, get: function () { return flatten_1.flatten; } })); +var from_1 = __nccwpck_require__(57268); +Object.defineProperty(exports, "from", ({ enumerable: true, get: function () { return from_1.from; } })); +var partition_1 = __nccwpck_require__(43571); +Object.defineProperty(exports, "partition", ({ enumerable: true, get: function () { return partition_1.partition; } })); +var range_1 = __nccwpck_require__(1858); +Object.defineProperty(exports, "range", ({ enumerable: true, get: function () { return range_1.range; } })); +var repeat_1 = __nccwpck_require__(48886); +Object.defineProperty(exports, "repeat", ({ enumerable: true, get: function () { return repeat_1.repeat; } })); + + +/***/ }), + +/***/ 43571: +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.partition = void 0; +/** + * Paritions the Iterable into a tuple of failing and passing arrays + * based on the predicate. + * @param source Elements to Partition + * @param predicate Pass / Fail condition + * @returns [pass, fail] + */ +exports.partition = (source, predicate) => { + const fail = []; + const pass = []; + for (const value of source) { + if (predicate(value) === true) { + pass.push(value); + } + else { + fail.push(value); + } + } + return [pass, fail]; +}; + + +/***/ }), + +/***/ 1858: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.range = void 0; +const shared_1 = __nccwpck_require__(25897); +const BasicEnumerable_1 = __nccwpck_require__(93706); +/** + * Generates a sequence of integral numbers within a specified range. + * @param start The value of the first integer in the sequence. + * @param count The number of sequential integers to generate. + * @throws {ArgumentOutOfRangeException} Start is Less than 0 + * OR start + count -1 is larger than MAX_SAFE_INTEGER. + * @returns An IEnumerable that contains a range of sequential integral numbers. + */ +exports.range = (start, count) => { + if (start < 0 || (start + count - 1) > Number.MAX_SAFE_INTEGER) { + throw new shared_1.ArgumentOutOfRangeException(`start`); + } + function* iterator() { + const max = start + count; + for (let i = start; i < max; i++) { + yield i; + } + } + return new BasicEnumerable_1.BasicEnumerable(iterator); +}; + + +/***/ }), + +/***/ 48886: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.repeat = void 0; +const shared_1 = __nccwpck_require__(25897); +const BasicEnumerable_1 = __nccwpck_require__(93706); +/** + * Generates a sequence that contains one repeated value. + * @param element The value to be repeated. + * @param count The number of times to repeat the value in the generated sequence. + * @returns An IEnumerable that contains a repeated value. + */ +exports.repeat = (element, count) => { + if (count < 0) { + throw new shared_1.ArgumentOutOfRangeException(`count`); + } + function* iterator() { + for (let i = 0; i < count; i++) { + yield element; + } + } + return new BasicEnumerable_1.BasicEnumerable(iterator); +}; + + +/***/ }), + +/***/ 29581: +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); + + +/***/ }), + +/***/ 7129: +/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { + +"use strict"; + + +// A linked list to keep track of recently-used-ness +const Yallist = __nccwpck_require__(40665) + +const MAX = Symbol('max') +const LENGTH = Symbol('length') +const LENGTH_CALCULATOR = Symbol('lengthCalculator') +const ALLOW_STALE = Symbol('allowStale') +const MAX_AGE = Symbol('maxAge') +const DISPOSE = Symbol('dispose') +const NO_DISPOSE_ON_SET = Symbol('noDisposeOnSet') +const LRU_LIST = Symbol('lruList') +const CACHE = Symbol('cache') +const UPDATE_AGE_ON_GET = Symbol('updateAgeOnGet') + +const naiveLength = () => 1 + +// lruList is a yallist where the head is the youngest +// item, and the tail is the oldest. the list contains the Hit +// objects as the entries. +// Each Hit object has a reference to its Yallist.Node. This +// never changes. +// +// cache is a Map (or PseudoMap) that matches the keys to +// the Yallist.Node object. +class LRUCache { + constructor (options) { + if (typeof options === 'number') + options = { max: options } + + if (!options) + options = {} + + if (options.max && (typeof options.max !== 'number' || options.max < 0)) + throw new TypeError('max must be a non-negative number') + // Kind of weird to have a default max of Infinity, but oh well. + const max = this[MAX] = options.max || Infinity + + const lc = options.length || naiveLength + this[LENGTH_CALCULATOR] = (typeof lc !== 'function') ? naiveLength : lc + this[ALLOW_STALE] = options.stale || false + if (options.maxAge && typeof options.maxAge !== 'number') + throw new TypeError('maxAge must be a number') + this[MAX_AGE] = options.maxAge || 0 + this[DISPOSE] = options.dispose + this[NO_DISPOSE_ON_SET] = options.noDisposeOnSet || false + this[UPDATE_AGE_ON_GET] = options.updateAgeOnGet || false + this.reset() + } + + // resize the cache when the max changes. + set max (mL) { + if (typeof mL !== 'number' || mL < 0) + throw new TypeError('max must be a non-negative number') + + this[MAX] = mL || Infinity + trim(this) + } + get max () { + return this[MAX] + } + + set allowStale (allowStale) { + this[ALLOW_STALE] = !!allowStale + } + get allowStale () { + return this[ALLOW_STALE] + } + + set maxAge (mA) { + if (typeof mA !== 'number') + throw new TypeError('maxAge must be a non-negative number') + + this[MAX_AGE] = mA + trim(this) + } + get maxAge () { + return this[MAX_AGE] + } + + // resize the cache when the lengthCalculator changes. + set lengthCalculator (lC) { + if (typeof lC !== 'function') + lC = naiveLength + + if (lC !== this[LENGTH_CALCULATOR]) { + this[LENGTH_CALCULATOR] = lC + this[LENGTH] = 0 + this[LRU_LIST].forEach(hit => { + hit.length = this[LENGTH_CALCULATOR](hit.value, hit.key) + this[LENGTH] += hit.length + }) + } + trim(this) + } + get lengthCalculator () { return this[LENGTH_CALCULATOR] } + + get length () { return this[LENGTH] } + get itemCount () { return this[LRU_LIST].length } + + rforEach (fn, thisp) { + thisp = thisp || this + for (let walker = this[LRU_LIST].tail; walker !== null;) { + const prev = walker.prev + forEachStep(this, fn, walker, thisp) + walker = prev + } + } + + forEach (fn, thisp) { + thisp = thisp || this + for (let walker = this[LRU_LIST].head; walker !== null;) { + const next = walker.next + forEachStep(this, fn, walker, thisp) + walker = next + } + } + + keys () { + return this[LRU_LIST].toArray().map(k => k.key) + } + + values () { + return this[LRU_LIST].toArray().map(k => k.value) + } + + reset () { + if (this[DISPOSE] && + this[LRU_LIST] && + this[LRU_LIST].length) { + this[LRU_LIST].forEach(hit => this[DISPOSE](hit.key, hit.value)) + } + + this[CACHE] = new Map() // hash of items by key + this[LRU_LIST] = new Yallist() // list of items in order of use recency + this[LENGTH] = 0 // length of items in the list + } + + dump () { + return this[LRU_LIST].map(hit => + isStale(this, hit) ? false : { + k: hit.key, + v: hit.value, + e: hit.now + (hit.maxAge || 0) + }).toArray().filter(h => h) + } + + dumpLru () { + return this[LRU_LIST] + } + + set (key, value, maxAge) { + maxAge = maxAge || this[MAX_AGE] + + if (maxAge && typeof maxAge !== 'number') + throw new TypeError('maxAge must be a number') + + const now = maxAge ? Date.now() : 0 + const len = this[LENGTH_CALCULATOR](value, key) + + if (this[CACHE].has(key)) { + if (len > this[MAX]) { + del(this, this[CACHE].get(key)) + return false + } + + const node = this[CACHE].get(key) + const item = node.value + + // dispose of the old one before overwriting + // split out into 2 ifs for better coverage tracking + if (this[DISPOSE]) { + if (!this[NO_DISPOSE_ON_SET]) + this[DISPOSE](key, item.value) + } + + item.now = now + item.maxAge = maxAge + item.value = value + this[LENGTH] += len - item.length + item.length = len + this.get(key) + trim(this) + return true + } + + const hit = new Entry(key, value, len, now, maxAge) + + // oversized objects fall out of cache automatically. + if (hit.length > this[MAX]) { + if (this[DISPOSE]) + this[DISPOSE](key, value) + + return false + } + + this[LENGTH] += hit.length + this[LRU_LIST].unshift(hit) + this[CACHE].set(key, this[LRU_LIST].head) + trim(this) + return true + } + + has (key) { + if (!this[CACHE].has(key)) return false + const hit = this[CACHE].get(key).value + return !isStale(this, hit) + } + + get (key) { + return get(this, key, true) + } + + peek (key) { + return get(this, key, false) + } + + pop () { + const node = this[LRU_LIST].tail + if (!node) + return null + + del(this, node) + return node.value + } + + del (key) { + del(this, this[CACHE].get(key)) + } + + load (arr) { + // reset the cache + this.reset() + + const now = Date.now() + // A previous serialized cache has the most recent items first + for (let l = arr.length - 1; l >= 0; l--) { + const hit = arr[l] + const expiresAt = hit.e || 0 + if (expiresAt === 0) + // the item was created without expiration in a non aged cache + this.set(hit.k, hit.v) + else { + const maxAge = expiresAt - now + // dont add already expired items + if (maxAge > 0) { + this.set(hit.k, hit.v, maxAge) + } + } + } + } + + prune () { + this[CACHE].forEach((value, key) => get(this, key, false)) + } +} + +const get = (self, key, doUse) => { + const node = self[CACHE].get(key) + if (node) { + const hit = node.value + if (isStale(self, hit)) { + del(self, node) + if (!self[ALLOW_STALE]) + return undefined + } else { + if (doUse) { + if (self[UPDATE_AGE_ON_GET]) + node.value.now = Date.now() + self[LRU_LIST].unshiftNode(node) + } + } + return hit.value + } +} + +const isStale = (self, hit) => { + if (!hit || (!hit.maxAge && !self[MAX_AGE])) + return false + + const diff = Date.now() - hit.now + return hit.maxAge ? diff > hit.maxAge + : self[MAX_AGE] && (diff > self[MAX_AGE]) +} + +const trim = self => { + if (self[LENGTH] > self[MAX]) { + for (let walker = self[LRU_LIST].tail; + self[LENGTH] > self[MAX] && walker !== null;) { + // We know that we're about to delete this one, and also + // what the next least recently used key will be, so just + // go ahead and set it now. + const prev = walker.prev + del(self, walker) + walker = prev + } + } +} + +const del = (self, node) => { + if (node) { + const hit = node.value + if (self[DISPOSE]) + self[DISPOSE](hit.key, hit.value) + + self[LENGTH] -= hit.length + self[CACHE].delete(hit.key) + self[LRU_LIST].removeNode(node) + } +} + +class Entry { + constructor (key, value, length, now, maxAge) { + this.key = key + this.value = value + this.length = length + this.now = now + this.maxAge = maxAge || 0 + } +} + +const forEachStep = (self, fn, node, thisp) => { + let hit = node.value + if (isStale(self, hit)) { + del(self, node) + if (!self[ALLOW_STALE]) + hit = undefined + } + if (hit) + fn.call(thisp, hit.value, hit.key, self) +} + +module.exports = LRUCache + + +/***/ }), + +/***/ 80900: +/***/ ((module) => { + +/** + * Helpers. + */ + +var s = 1000; +var m = s * 60; +var h = m * 60; +var d = h * 24; +var w = d * 7; +var y = d * 365.25; + +/** + * Parse or format the given `val`. + * + * Options: + * + * - `long` verbose formatting [false] + * + * @param {String|Number} val + * @param {Object} [options] + * @throws {Error} throw an error if val is not a non-empty string or a number + * @return {String|Number} + * @api public + */ + +module.exports = function(val, options) { + options = options || {}; + var type = typeof val; + if (type === 'string' && val.length > 0) { + return parse(val); + } else if (type === 'number' && isFinite(val)) { + return options.long ? fmtLong(val) : fmtShort(val); + } + throw new Error( + 'val is not a non-empty string or a valid number. val=' + + JSON.stringify(val) + ); +}; + +/** + * Parse the given `str` and return milliseconds. + * + * @param {String} str + * @return {Number} + * @api private + */ + +function parse(str) { + str = String(str); + if (str.length > 100) { + return; + } + var match = /^(-?(?:\d+)?\.?\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|weeks?|w|years?|yrs?|y)?$/i.exec( + str + ); + if (!match) { + return; + } + var n = parseFloat(match[1]); + var type = (match[2] || 'ms').toLowerCase(); + switch (type) { + case 'years': + case 'year': + case 'yrs': + case 'yr': + case 'y': + return n * y; + case 'weeks': + case 'week': + case 'w': + return n * w; + case 'days': + case 'day': + case 'd': + return n * d; + case 'hours': + case 'hour': + case 'hrs': + case 'hr': + case 'h': + return n * h; + case 'minutes': + case 'minute': + case 'mins': + case 'min': + case 'm': + return n * m; + case 'seconds': + case 'second': + case 'secs': + case 'sec': + case 's': + return n * s; + case 'milliseconds': + case 'millisecond': + case 'msecs': + case 'msec': + case 'ms': + return n; + default: + return undefined; + } +} + +/** + * Short format for `ms`. + * + * @param {Number} ms + * @return {String} + * @api private + */ + +function fmtShort(ms) { + var msAbs = Math.abs(ms); + if (msAbs >= d) { + return Math.round(ms / d) + 'd'; + } + if (msAbs >= h) { + return Math.round(ms / h) + 'h'; + } + if (msAbs >= m) { + return Math.round(ms / m) + 'm'; + } + if (msAbs >= s) { + return Math.round(ms / s) + 's'; + } + return ms + 'ms'; +} + +/** + * Long format for `ms`. + * + * @param {Number} ms + * @return {String} + * @api private + */ + +function fmtLong(ms) { + var msAbs = Math.abs(ms); + if (msAbs >= d) { + return plural(ms, msAbs, d, 'day'); + } + if (msAbs >= h) { + return plural(ms, msAbs, h, 'hour'); + } + if (msAbs >= m) { + return plural(ms, msAbs, m, 'minute'); + } + if (msAbs >= s) { + return plural(ms, msAbs, s, 'second'); + } + return ms + ' ms'; +} + +/** + * Pluralization helper. + */ + +function plural(ms, msAbs, n, name) { + var isPlural = msAbs >= n * 1.5; + return Math.round(ms / n) + ' ' + name + (isPlural ? 's' : ''); +} + + +/***/ }), + +/***/ 80467: +/***/ ((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__(92413)); +var http = _interopDefault(__nccwpck_require__(98605)); +var Url = _interopDefault(__nccwpck_require__(78835)); +var https = _interopDefault(__nccwpck_require__(57211)); +var zlib = _interopDefault(__nccwpck_require__(78761)); + +// 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__(22877).convert; +} catch (e) {} + +const INTERNALS = Symbol('Body internals'); + +// fix an issue where "PassThrough" isn't a named export for node <10 +const PassThrough = Stream.PassThrough; + +/** + * Body mixin + * + * Ref: https://fetch.spec.whatwg.org/#body + * + * @param Stream body Readable stream + * @param Object opts Response options + * @return Void + */ +function Body(body) { + var _this = this; + + var _ref = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}, + _ref$size = _ref.size; + + let size = _ref$size === undefined ? 0 : _ref$size; + var _ref$timeout = _ref.timeout; + let timeout = _ref$timeout === undefined ? 0 : _ref$timeout; + + if (body == null) { + // body is undefined or null + body = null; + } else if (isURLSearchParams(body)) { + // body is a URLSearchParams + body = Buffer.from(body.toString()); + } else if (isBlob(body)) ; else if (Buffer.isBuffer(body)) ; else if (Object.prototype.toString.call(body) === '[object ArrayBuffer]') { + // body is ArrayBuffer + body = Buffer.from(body); + } else if (ArrayBuffer.isView(body)) { + // body is ArrayBufferView + body = Buffer.from(body.buffer, body.byteOffset, body.byteLength); + } else if (body instanceof Stream) ; else { + // none of the above + // coerce to string then buffer + body = Buffer.from(String(body)); + } + this[INTERNALS] = { + body, + disturbed: false, + error: null + }; + this.size = size; + this.timeout = timeout; + + if (body instanceof Stream) { + body.on('error', function (err) { + const error = err.name === 'AbortError' ? err : new FetchError(`Invalid response body while trying to fetch ${_this.url}: ${err.message}`, 'system', err); + _this[INTERNALS].error = error; + }); + } +} + +Body.prototype = { + get body() { + return this[INTERNALS].body; + }, + + get bodyUsed() { + return this[INTERNALS].disturbed; + }, + + /** + * Decode response as ArrayBuffer + * + * @return Promise + */ + arrayBuffer() { + return consumeBody.call(this).then(function (buf) { + return buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.byteLength); + }); + }, + + /** + * Return raw response as Blob + * + * @return Promise + */ + blob() { + let ct = this.headers && this.headers.get('content-type') || ''; + return consumeBody.call(this).then(function (buf) { + return Object.assign( + // Prevent copying + new Blob([], { + type: ct.toLowerCase() + }), { + [BUFFER]: buf + }); + }); + }, + + /** + * Decode response as json + * + * @return Promise + */ + json() { + var _this2 = this; + + return consumeBody.call(this).then(function (buffer) { + try { + return JSON.parse(buffer.toString()); + } catch (err) { + return Body.Promise.reject(new FetchError(`invalid json response body at ${_this2.url} reason: ${err.message}`, 'invalid-json')); + } + }); + }, + + /** + * Decode response as text + * + * @return Promise + */ + text() { + return consumeBody.call(this).then(function (buffer) { + return buffer.toString(); + }); + }, + + /** + * Decode response as buffer (non-spec api) + * + * @return Promise + */ + buffer() { + return consumeBody.call(this); + }, + + /** + * Decode response as text, while automatically detecting the encoding and + * trying to decode to UTF-8 (non-spec api) + * + * @return Promise + */ + textConverted() { + var _this3 = this; + + return consumeBody.call(this).then(function (buffer) { + return convertBody(buffer, _this3.headers); + }); + } +}; + +// In browsers, all properties are enumerable. +Object.defineProperties(Body.prototype, { + body: { enumerable: true }, + bodyUsed: { enumerable: true }, + arrayBuffer: { enumerable: true }, + blob: { enumerable: true }, + json: { enumerable: true }, + text: { enumerable: true } +}); + +Body.mixIn = function (proto) { + for (const name of Object.getOwnPropertyNames(Body.prototype)) { + // istanbul ignore else: future proof + if (!(name in proto)) { + const desc = Object.getOwnPropertyDescriptor(Body.prototype, name); + Object.defineProperty(proto, name, desc); + } + } +}; + +/** + * Consume and convert an entire Body to a Buffer. + * + * Ref: https://fetch.spec.whatwg.org/#concept-body-consume-body + * + * @return Promise + */ +function consumeBody() { + var _this4 = this; + + if (this[INTERNALS].disturbed) { + return Body.Promise.reject(new TypeError(`body used already for: ${this.url}`)); + } + + this[INTERNALS].disturbed = true; + + if (this[INTERNALS].error) { + return Body.Promise.reject(this[INTERNALS].error); + } + + let body = this.body; + + // body is null + if (body === null) { + return Body.Promise.resolve(Buffer.alloc(0)); + } + + // body is blob + if (isBlob(body)) { + body = body.stream(); + } + + // body is buffer + if (Buffer.isBuffer(body)) { + return Body.Promise.resolve(body); + } + + // istanbul ignore if: should never happen + if (!(body instanceof Stream)) { + return Body.Promise.resolve(Buffer.alloc(0)); + } + + // body is stream + // get ready to actually consume the body + let accum = []; + let accumBytes = 0; + let abort = false; + + return new Body.Promise(function (resolve, reject) { + let resTimeout; + + // allow timeout on slow response body + if (_this4.timeout) { + resTimeout = setTimeout(function () { + abort = true; + reject(new FetchError(`Response timeout while trying to fetch ${_this4.url} (over ${_this4.timeout}ms)`, 'body-timeout')); + }, _this4.timeout); + } + + // handle stream errors + body.on('error', function (err) { + if (err.name === 'AbortError') { + // if the request was aborted, reject with this Error + abort = true; + reject(err); + } else { + // other errors, such as incorrect content-encoding + reject(new FetchError(`Invalid response body while trying to fetch ${_this4.url}: ${err.message}`, 'system', err)); + } + }); + + body.on('data', function (chunk) { + if (abort || chunk === null) { + return; + } + + if (_this4.size && accumBytes + chunk.length > _this4.size) { + abort = true; + reject(new FetchError(`content size at ${_this4.url} over limit: ${_this4.size}`, 'max-size')); + return; + } + + accumBytes += chunk.length; + accum.push(chunk); + }); + + body.on('end', function () { + if (abort) { + return; + } + + clearTimeout(resTimeout); + + try { + resolve(Buffer.concat(accum, accumBytes)); + } catch (err) { + // handle streams that have accumulated too much data (issue #414) + reject(new FetchError(`Could not create Buffer from response body for ${_this4.url}: ${err.message}`, 'system', err)); + } + }); + }); +} + +/** + * Detect buffer encoding and convert to target encoding + * ref: http://www.w3.org/TR/2011/WD-html5-20110113/parsing.html#determining-the-character-encoding + * + * @param Buffer buffer Incoming buffer + * @param String encoding Target encoding + * @return String + */ +function convertBody(buffer, headers) { + if (typeof convert !== 'function') { + throw new Error('The package `encoding` must be installed to use the textConverted() function'); + } + + const ct = headers.get('content-type'); + let charset = 'utf-8'; + let res, str; + + // header + if (ct) { + res = /charset=([^;]*)/i.exec(ct); + } + + // no charset in content type, peek at response body for at most 1024 bytes + str = buffer.slice(0, 1024).toString(); + + // html5 + if (!res && str) { + res = / 0 && arguments[0] !== undefined ? arguments[0] : undefined; + + this[MAP] = Object.create(null); + + if (init instanceof Headers) { + const rawHeaders = init.raw(); + const headerNames = Object.keys(rawHeaders); + + for (const headerName of headerNames) { + for (const value of rawHeaders[headerName]) { + this.append(headerName, value); + } + } + + return; + } + + // We don't worry about converting prop to ByteString here as append() + // will handle it. + if (init == null) ; else if (typeof init === 'object') { + const method = init[Symbol.iterator]; + if (method != null) { + if (typeof method !== 'function') { + throw new TypeError('Header pairs must be iterable'); + } + + // sequence> + // Note: per spec we have to first exhaust the lists then process them + const pairs = []; + for (const pair of init) { + if (typeof pair !== 'object' || typeof pair[Symbol.iterator] !== 'function') { + throw new TypeError('Each header pair must be iterable'); + } + pairs.push(Array.from(pair)); + } + + for (const pair of pairs) { + if (pair.length !== 2) { + throw new TypeError('Each header pair must be a name/value tuple'); + } + this.append(pair[0], pair[1]); + } + } else { + // record + for (const key of Object.keys(init)) { + const value = init[key]; + this.append(key, value); + } + } + } else { + throw new TypeError('Provided initializer must be an object'); + } + } + + /** + * Return combined header value given name + * + * @param String name Header name + * @return Mixed + */ + get(name) { + name = `${name}`; + validateName(name); + const key = find(this[MAP], name); + if (key === undefined) { + return null; + } + + return this[MAP][key].join(', '); + } + + /** + * Iterate over all headers + * + * @param Function callback Executed for each item with parameters (value, name, thisArg) + * @param Boolean thisArg `this` context for callback function + * @return Void + */ + forEach(callback) { + let thisArg = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : undefined; + + let pairs = getHeaders(this); + let i = 0; + while (i < pairs.length) { + var _pairs$i = pairs[i]; + const name = _pairs$i[0], + value = _pairs$i[1]; + + callback.call(thisArg, value, name, this); + pairs = getHeaders(this); + i++; + } + } + + /** + * Overwrite header values given name + * + * @param String name Header name + * @param String value Header value + * @return Void + */ + set(name, value) { + name = `${name}`; + value = `${value}`; + validateName(name); + validateValue(value); + const key = find(this[MAP], name); + this[MAP][key !== undefined ? key : name] = [value]; + } + + /** + * Append a value onto existing header + * + * @param String name Header name + * @param String value Header value + * @return Void + */ + append(name, value) { + name = `${name}`; + value = `${value}`; + validateName(name); + validateValue(value); + const key = find(this[MAP], name); + if (key !== undefined) { + this[MAP][key].push(value); + } else { + this[MAP][name] = [value]; + } + } + + /** + * Check for header name existence + * + * @param String name Header name + * @return Boolean + */ + has(name) { + name = `${name}`; + validateName(name); + return find(this[MAP], name) !== undefined; + } + + /** + * Delete all header values given name + * + * @param String name Header name + * @return Void + */ + delete(name) { + name = `${name}`; + validateName(name); + const key = find(this[MAP], name); + if (key !== undefined) { + delete this[MAP][key]; + } + } + + /** + * Return raw headers (non-spec api) + * + * @return Object + */ + raw() { + return this[MAP]; + } + + /** + * Get an iterator on keys. + * + * @return Iterator + */ + keys() { + return createHeadersIterator(this, 'key'); + } + + /** + * Get an iterator on values. + * + * @return Iterator + */ + values() { + return createHeadersIterator(this, 'value'); + } + + /** + * Get an iterator on entries. + * + * This is the default iterator of the Headers object. + * + * @return Iterator + */ + [Symbol.iterator]() { + return createHeadersIterator(this, 'key+value'); + } +} +Headers.prototype.entries = Headers.prototype[Symbol.iterator]; + +Object.defineProperty(Headers.prototype, Symbol.toStringTag, { + value: 'Headers', + writable: false, + enumerable: false, + configurable: true +}); + +Object.defineProperties(Headers.prototype, { + get: { enumerable: true }, + forEach: { enumerable: true }, + set: { enumerable: true }, + append: { enumerable: true }, + has: { enumerable: true }, + delete: { enumerable: true }, + keys: { enumerable: true }, + values: { enumerable: true }, + entries: { enumerable: true } +}); + +function getHeaders(headers) { + let kind = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'key+value'; + + const keys = Object.keys(headers[MAP]).sort(); + return keys.map(kind === 'key' ? function (k) { + return k.toLowerCase(); + } : kind === 'value' ? function (k) { + return headers[MAP][k].join(', '); + } : function (k) { + return [k.toLowerCase(), headers[MAP][k].join(', ')]; + }); +} + +const INTERNAL = Symbol('internal'); + +function createHeadersIterator(target, kind) { + const iterator = Object.create(HeadersIteratorPrototype); + iterator[INTERNAL] = { + target, + kind, + index: 0 + }; + return iterator; +} + +const HeadersIteratorPrototype = Object.setPrototypeOf({ + next() { + // istanbul ignore if + if (!this || Object.getPrototypeOf(this) !== HeadersIteratorPrototype) { + throw new TypeError('Value of `this` is not a HeadersIterator'); + } + + var _INTERNAL = this[INTERNAL]; + const target = _INTERNAL.target, + kind = _INTERNAL.kind, + index = _INTERNAL.index; + + const values = getHeaders(target, kind); + const len = values.length; + if (index >= len) { + return { + value: undefined, + done: true + }; + } + + this[INTERNAL].index = index + 1; + + return { + value: values[index], + done: false + }; + } +}, Object.getPrototypeOf(Object.getPrototypeOf([][Symbol.iterator]()))); + +Object.defineProperty(HeadersIteratorPrototype, Symbol.toStringTag, { + value: 'HeadersIterator', + writable: false, + enumerable: false, + configurable: true +}); + +/** + * Export the Headers object in a form that Node.js can consume. + * + * @param Headers headers + * @return Object + */ +function exportNodeCompatibleHeaders(headers) { + const obj = Object.assign({ __proto__: null }, headers[MAP]); + + // http.request() only supports string as Host header. This hack makes + // specifying custom Host header possible. + const hostHeaderKey = find(headers[MAP], 'Host'); + if (hostHeaderKey !== undefined) { + obj[hostHeaderKey] = obj[hostHeaderKey][0]; + } + + return obj; +} + +/** + * Create a Headers object from an object of headers, ignoring those that do + * not conform to HTTP grammar productions. + * + * @param Object obj Object of headers + * @return Headers + */ +function createHeadersLenient(obj) { + const headers = new Headers(); + for (const name of Object.keys(obj)) { + if (invalidTokenRegex.test(name)) { + continue; + } + if (Array.isArray(obj[name])) { + for (const val of obj[name]) { + if (invalidHeaderCharRegex.test(val)) { + continue; + } + if (headers[MAP][name] === undefined) { + headers[MAP][name] = [val]; + } else { + headers[MAP][name].push(val); + } + } + } else if (!invalidHeaderCharRegex.test(obj[name])) { + headers[MAP][name] = [obj[name]]; + } + } + return headers; +} + +const INTERNALS$1 = Symbol('Response internals'); + +// fix an issue where "STATUS_CODES" aren't a named export for node <10 +const STATUS_CODES = http.STATUS_CODES; + +/** + * Response class + * + * @param Stream body Readable stream + * @param Object opts Response options + * @return Void + */ +class Response { + constructor() { + let body = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null; + let opts = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; + + Body.call(this, body, opts); + + const status = opts.status || 200; + const headers = new Headers(opts.headers); + + if (body != null && !headers.has('Content-Type')) { + const contentType = extractContentType(body); + if (contentType) { + headers.append('Content-Type', contentType); + } + } + + this[INTERNALS$1] = { + url: opts.url, + status, + statusText: opts.statusText || STATUS_CODES[status], + headers, + counter: opts.counter + }; + } + + get url() { + return this[INTERNALS$1].url || ''; + } + + get status() { + return this[INTERNALS$1].status; + } + + /** + * Convenience property representing if the request ended normally + */ + get ok() { + return this[INTERNALS$1].status >= 200 && this[INTERNALS$1].status < 300; + } + + get redirected() { + return this[INTERNALS$1].counter > 0; + } + + get statusText() { + return this[INTERNALS$1].statusText; + } + + get headers() { + return this[INTERNALS$1].headers; + } + + /** + * Clone this response + * + * @return Response + */ + clone() { + return new Response(clone(this), { + url: this.url, + status: this.status, + statusText: this.statusText, + headers: this.headers, + ok: this.ok, + redirected: this.redirected + }); + } +} + +Body.mixIn(Response.prototype); + +Object.defineProperties(Response.prototype, { + url: { enumerable: true }, + status: { enumerable: true }, + ok: { enumerable: true }, + redirected: { enumerable: true }, + statusText: { enumerable: true }, + headers: { enumerable: true }, + clone: { enumerable: true } +}); + +Object.defineProperty(Response.prototype, Symbol.toStringTag, { + value: 'Response', + writable: false, + enumerable: false, + configurable: true +}); + +const INTERNALS$2 = Symbol('Request internals'); + +// fix an issue where "format", "parse" aren't a named export for node <10 +const parse_url = Url.parse; +const format_url = Url.format; + +const streamDestructionSupported = 'destroy' in Stream.Readable.prototype; + +/** + * Check if a value is an instance of Request. + * + * @param Mixed input + * @return Boolean + */ +function isRequest(input) { + return typeof input === 'object' && typeof input[INTERNALS$2] === 'object'; +} + +function isAbortSignal(signal) { + const proto = signal && typeof signal === 'object' && Object.getPrototypeOf(signal); + return !!(proto && proto.constructor.name === 'AbortSignal'); +} + +/** + * Request class + * + * @param Mixed input Url or Request instance + * @param Object init Custom options + * @return Void + */ +class Request { + constructor(input) { + let init = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; + + let parsedURL; + + // normalize input + if (!isRequest(input)) { + if (input && input.href) { + // in order to support Node.js' Url objects; though WHATWG's URL objects + // will fall into this branch also (since their `toString()` will return + // `href` property anyway) + parsedURL = parse_url(input.href); + } else { + // coerce input to a string before attempting to parse + parsedURL = parse_url(`${input}`); + } + input = {}; + } else { + parsedURL = parse_url(input.url); + } + + let method = init.method || input.method || 'GET'; + method = method.toUpperCase(); + + if ((init.body != null || isRequest(input) && input.body !== null) && (method === 'GET' || method === 'HEAD')) { + throw new TypeError('Request with GET/HEAD method cannot have body'); + } + + let inputBody = init.body != null ? init.body : isRequest(input) && input.body !== null ? clone(input) : null; + + Body.call(this, inputBody, { + timeout: init.timeout || input.timeout || 0, + size: init.size || input.size || 0 + }); + + const headers = new Headers(init.headers || input.headers || {}); + + if (inputBody != null && !headers.has('Content-Type')) { + const contentType = extractContentType(inputBody); + if (contentType) { + headers.append('Content-Type', contentType); + } + } + + let signal = isRequest(input) ? input.signal : null; + if ('signal' in init) signal = init.signal; + + if (signal != null && !isAbortSignal(signal)) { + throw new TypeError('Expected signal to be an instanceof AbortSignal'); + } + + this[INTERNALS$2] = { + method, + redirect: init.redirect || input.redirect || 'follow', + headers, + parsedURL, + signal + }; + + // node-fetch-only options + this.follow = init.follow !== undefined ? init.follow : input.follow !== undefined ? input.follow : 20; + this.compress = init.compress !== undefined ? init.compress : input.compress !== undefined ? input.compress : true; + this.counter = init.counter || input.counter || 0; + this.agent = init.agent || input.agent; + } + + get method() { + return this[INTERNALS$2].method; + } + + get url() { + return format_url(this[INTERNALS$2].parsedURL); + } + + get headers() { + return this[INTERNALS$2].headers; + } + + get redirect() { + return this[INTERNALS$2].redirect; + } + + get signal() { + return this[INTERNALS$2].signal; + } + + /** + * Clone this request + * + * @return Request + */ + clone() { + return new Request(this); + } +} + +Body.mixIn(Request.prototype); + +Object.defineProperty(Request.prototype, Symbol.toStringTag, { + value: 'Request', + writable: false, + enumerable: false, + configurable: true +}); + +Object.defineProperties(Request.prototype, { + method: { enumerable: true }, + url: { enumerable: true }, + headers: { enumerable: true }, + redirect: { enumerable: true }, + clone: { enumerable: true }, + signal: { enumerable: true } +}); + +/** + * Convert a Request to Node.js http request options. + * + * @param Request A Request instance + * @return Object The options object to be passed to http.request + */ +function getNodeRequestOptions(request) { + const parsedURL = request[INTERNALS$2].parsedURL; + const headers = new Headers(request[INTERNALS$2].headers); + + // fetch step 1.3 + if (!headers.has('Accept')) { + headers.set('Accept', '*/*'); + } + + // Basic fetch + if (!parsedURL.protocol || !parsedURL.hostname) { + throw new TypeError('Only absolute URLs are supported'); + } + + if (!/^https?:$/.test(parsedURL.protocol)) { + throw new TypeError('Only HTTP(S) protocols are supported'); + } + + if (request.signal && request.body instanceof Stream.Readable && !streamDestructionSupported) { + throw new Error('Cancellation of streamed requests with AbortSignal is not supported in node < 8'); + } + + // HTTP-network-or-cache fetch steps 2.4-2.7 + let contentLengthValue = null; + if (request.body == null && /^(POST|PUT)$/i.test(request.method)) { + contentLengthValue = '0'; + } + if (request.body != null) { + const totalBytes = getTotalBytes(request); + if (typeof totalBytes === 'number') { + contentLengthValue = String(totalBytes); + } + } + if (contentLengthValue) { + headers.set('Content-Length', contentLengthValue); + } + + // HTTP-network-or-cache fetch step 2.11 + if (!headers.has('User-Agent')) { + headers.set('User-Agent', 'node-fetch/1.0 (+https://github.com/bitinn/node-fetch)'); + } + + // HTTP-network-or-cache fetch step 2.15 + if (request.compress && !headers.has('Accept-Encoding')) { + headers.set('Accept-Encoding', 'gzip,deflate'); + } + + let agent = request.agent; + if (typeof agent === 'function') { + agent = agent(parsedURL); + } + + if (!headers.has('Connection') && !agent) { + headers.set('Connection', 'close'); + } + + // HTTP-network fetch step 4.2 + // chunked encoding is handled by Node.js + + return Object.assign({}, parsedURL, { + method: request.method, + headers: exportNodeCompatibleHeaders(headers), + agent + }); +} + +/** + * abort-error.js + * + * AbortError interface for cancelled requests + */ + +/** + * Create AbortError instance + * + * @param String message Error message for human + * @return AbortError + */ +function AbortError(message) { + Error.call(this, message); + + this.type = 'aborted'; + this.message = message; + + // hide custom error implementation details from end-users + Error.captureStackTrace(this, this.constructor); +} + +AbortError.prototype = Object.create(Error.prototype); +AbortError.prototype.constructor = AbortError; +AbortError.prototype.name = 'AbortError'; + +// fix an issue where "PassThrough", "resolve" aren't a named export for node <10 +const PassThrough$1 = Stream.PassThrough; +const resolve_url = Url.resolve; + +/** + * Fetch function + * + * @param Mixed url Absolute url or Request instance + * @param Object opts Fetch options + * @return Promise + */ +function fetch(url, opts) { + + // allow custom promise + if (!fetch.Promise) { + throw new Error('native promise missing, set fetch.Promise to your favorite alternative'); + } + + Body.Promise = fetch.Promise; + + // wrap http.request into fetch + return new fetch.Promise(function (resolve, reject) { + // build request object + const request = new Request(url, opts); + const options = getNodeRequestOptions(request); + + const send = (options.protocol === 'https:' ? https : http).request; + const signal = request.signal; + + let response = null; + + const abort = function abort() { + let error = new AbortError('The user aborted a request.'); + reject(error); + if (request.body && request.body instanceof Stream.Readable) { + request.body.destroy(error); + } + if (!response || !response.body) return; + response.body.emit('error', error); + }; + + if (signal && signal.aborted) { + abort(); + return; + } + + const abortAndFinalize = function abortAndFinalize() { + abort(); + finalize(); + }; + + // send request + const req = send(options); + let reqTimeout; + + if (signal) { + signal.addEventListener('abort', abortAndFinalize); + } + + function finalize() { + req.abort(); + if (signal) signal.removeEventListener('abort', abortAndFinalize); + clearTimeout(reqTimeout); + } + + if (request.timeout) { + req.once('socket', function (socket) { + reqTimeout = setTimeout(function () { + reject(new FetchError(`network timeout at: ${request.url}`, 'request-timeout')); + finalize(); + }, request.timeout); + }); + } + + req.on('error', function (err) { + reject(new FetchError(`request to ${request.url} failed, reason: ${err.message}`, 'system', err)); + finalize(); + }); + + req.on('response', function (res) { + clearTimeout(reqTimeout); + + const headers = createHeadersLenient(res.headers); + + // HTTP fetch step 5 + if (fetch.isRedirect(res.statusCode)) { + // HTTP fetch step 5.2 + const location = headers.get('Location'); + + // HTTP fetch step 5.3 + const locationURL = location === null ? null : resolve_url(request.url, location); + + // HTTP fetch step 5.5 + switch (request.redirect) { + case 'error': + reject(new FetchError(`uri requested responds with a redirect, redirect mode is set to error: ${request.url}`, 'no-redirect')); + finalize(); + return; + case 'manual': + // node-fetch-specific step: make manual redirect a bit easier to use by setting the Location header value to the resolved URL. + if (locationURL !== null) { + // handle corrupted header + try { + headers.set('Location', locationURL); + } catch (err) { + // istanbul ignore next: nodejs server prevent invalid response headers, we can't test this through normal request + reject(err); + } + } + break; + case 'follow': + // HTTP-redirect fetch step 2 + if (locationURL === null) { + break; + } + + // HTTP-redirect fetch step 5 + if (request.counter >= request.follow) { + reject(new FetchError(`maximum redirect reached at: ${request.url}`, 'max-redirect')); + finalize(); + return; + } + + // HTTP-redirect fetch step 6 (counter increment) + // Create a new Request object. + const requestOpts = { + headers: new Headers(request.headers), + follow: request.follow, + counter: request.counter + 1, + agent: request.agent, + compress: request.compress, + method: request.method, + body: request.body, + signal: request.signal, + timeout: request.timeout, + size: request.size + }; + + // HTTP-redirect fetch step 9 + if (res.statusCode !== 303 && request.body && getTotalBytes(request) === null) { + reject(new FetchError('Cannot follow redirect with body being a readable stream', 'unsupported-redirect')); + finalize(); + return; + } + + // HTTP-redirect fetch step 11 + if (res.statusCode === 303 || (res.statusCode === 301 || res.statusCode === 302) && request.method === 'POST') { + requestOpts.method = 'GET'; + requestOpts.body = undefined; + requestOpts.headers.delete('content-length'); + } + + // HTTP-redirect fetch step 15 + resolve(fetch(new Request(locationURL, requestOpts))); + finalize(); + return; + } + } + + // prepare response + res.once('end', function () { + if (signal) signal.removeEventListener('abort', abortAndFinalize); + }); + let body = res.pipe(new PassThrough$1()); + + const response_options = { + url: request.url, + status: res.statusCode, + statusText: res.statusMessage, + headers: headers, + size: request.size, + timeout: request.timeout, + counter: request.counter + }; + + // HTTP-network fetch step 12.1.1.3 + const codings = headers.get('Content-Encoding'); + + // HTTP-network fetch step 12.1.1.4: handle content codings + + // in following scenarios we ignore compression support + // 1. compression support is disabled + // 2. HEAD request + // 3. no Content-Encoding header + // 4. no content response (204) + // 5. content not modified response (304) + if (!request.compress || request.method === 'HEAD' || codings === null || res.statusCode === 204 || res.statusCode === 304) { + response = new Response(body, response_options); + resolve(response); + return; + } + + // For Node v6+ + // Be less strict when decoding compressed responses, since sometimes + // servers send slightly invalid responses that are still accepted + // by common browsers. + // Always using Z_SYNC_FLUSH is what cURL does. + const zlibOptions = { + flush: zlib.Z_SYNC_FLUSH, + finishFlush: zlib.Z_SYNC_FLUSH + }; + + // for gzip + if (codings == 'gzip' || codings == 'x-gzip') { + body = body.pipe(zlib.createGunzip(zlibOptions)); + response = new Response(body, response_options); + resolve(response); + return; + } + + // for deflate + if (codings == 'deflate' || codings == 'x-deflate') { + // handle the infamous raw deflate response from old servers + // a hack for old IIS and Apache servers + const raw = res.pipe(new PassThrough$1()); + raw.once('data', function (chunk) { + // see http://stackoverflow.com/questions/37519828 + if ((chunk[0] & 0x0F) === 0x08) { + body = body.pipe(zlib.createInflate()); + } else { + body = body.pipe(zlib.createInflateRaw()); + } + response = new Response(body, response_options); + resolve(response); + }); + return; + } + + // for br + if (codings == 'br' && typeof zlib.createBrotliDecompress === 'function') { + body = body.pipe(zlib.createBrotliDecompress()); + response = new Response(body, response_options); + resolve(response); + return; + } + + // otherwise, use response as-is + response = new Response(body, response_options); + resolve(response); + }); + + writeToStream(req, request); + }); +} +/** + * Redirect code matching + * + * @param Number code Status code + * @return Boolean + */ +fetch.isRedirect = function (code) { + return code === 301 || code === 302 || code === 303 || code === 307 || code === 308; +}; + +// expose Promise +fetch.Promise = global.Promise; + +module.exports = exports = fetch; +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.default = exports; +exports.Headers = Headers; +exports.Request = Request; +exports.Response = Response; +exports.FetchError = FetchError; + + +/***/ }), + +/***/ 1223: +/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { + +var wrappy = __nccwpck_require__(62940) +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 +} + + +/***/ }), + +/***/ 72043: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +;(function (sax) { // wrapper for non-node envs + sax.parser = function (strict, opt) { return new SAXParser(strict, opt) } + sax.SAXParser = SAXParser + sax.SAXStream = SAXStream + sax.createStream = createStream + + // When we pass the MAX_BUFFER_LENGTH position, start checking for buffer overruns. + // When we check, schedule the next check for MAX_BUFFER_LENGTH - (max(buffer lengths)), + // since that's the earliest that a buffer overrun could occur. This way, checks are + // as rare as required, but as often as necessary to ensure never crossing this bound. + // Furthermore, buffers are only tested at most once per write(), so passing a very + // large string into write() might have undesirable effects, but this is manageable by + // the caller, so it is assumed to be safe. Thus, a call to write() may, in the extreme + // edge case, result in creating at most one complete copy of the string passed in. + // Set to Infinity to have unlimited buffers. + sax.MAX_BUFFER_LENGTH = 64 * 1024 + + var buffers = [ + 'comment', 'sgmlDecl', 'textNode', 'tagName', 'doctype', + 'procInstName', 'procInstBody', 'entity', 'attribName', + 'attribValue', 'cdata', 'script' + ] + + sax.EVENTS = [ + 'text', + 'processinginstruction', + 'sgmldeclaration', + 'doctype', + 'comment', + 'opentagstart', + 'attribute', + 'opentag', + 'closetag', + 'opencdata', + 'cdata', + 'closecdata', + 'error', + 'end', + 'ready', + 'script', + 'opennamespace', + 'closenamespace' + ] + + function SAXParser (strict, opt) { + if (!(this instanceof SAXParser)) { + return new SAXParser(strict, opt) + } + + var parser = this + clearBuffers(parser) + parser.q = parser.c = '' + parser.bufferCheckPosition = sax.MAX_BUFFER_LENGTH + parser.opt = opt || {} + parser.opt.lowercase = parser.opt.lowercase || parser.opt.lowercasetags + parser.looseCase = parser.opt.lowercase ? 'toLowerCase' : 'toUpperCase' + parser.tags = [] + parser.closed = parser.closedRoot = parser.sawRoot = false + parser.tag = parser.error = null + parser.strict = !!strict + parser.noscript = !!(strict || parser.opt.noscript) + parser.state = S.BEGIN + parser.strictEntities = parser.opt.strictEntities + parser.ENTITIES = parser.strictEntities ? Object.create(sax.XML_ENTITIES) : Object.create(sax.ENTITIES) + parser.attribList = [] + + // namespaces form a prototype chain. + // it always points at the current tag, + // which protos to its parent tag. + if (parser.opt.xmlns) { + parser.ns = Object.create(rootNS) + } + + // mostly just for error reporting + parser.trackPosition = parser.opt.position !== false + if (parser.trackPosition) { + parser.position = parser.line = parser.column = 0 + } + emit(parser, 'onready') + } + + if (!Object.create) { + Object.create = function (o) { + function F () {} + F.prototype = o + var newf = new F() + return newf + } + } + + if (!Object.keys) { + Object.keys = function (o) { + var a = [] + for (var i in o) if (o.hasOwnProperty(i)) a.push(i) + return a + } + } + + function checkBufferLength (parser) { + var maxAllowed = Math.max(sax.MAX_BUFFER_LENGTH, 10) + var maxActual = 0 + for (var i = 0, l = buffers.length; i < l; i++) { + var len = parser[buffers[i]].length + if (len > maxAllowed) { + // Text/cdata nodes can get big, and since they're buffered, + // we can get here under normal conditions. + // Avoid issues by emitting the text node now, + // so at least it won't get any bigger. + switch (buffers[i]) { + case 'textNode': + closeText(parser) + break + + case 'cdata': + emitNode(parser, 'oncdata', parser.cdata) + parser.cdata = '' + break + + case 'script': + emitNode(parser, 'onscript', parser.script) + parser.script = '' + break + + default: + error(parser, 'Max buffer length exceeded: ' + buffers[i]) + } + } + maxActual = Math.max(maxActual, len) + } + // schedule the next check for the earliest possible buffer overrun. + var m = sax.MAX_BUFFER_LENGTH - maxActual + parser.bufferCheckPosition = m + parser.position + } + + function clearBuffers (parser) { + for (var i = 0, l = buffers.length; i < l; i++) { + parser[buffers[i]] = '' + } + } + + function flushBuffers (parser) { + closeText(parser) + if (parser.cdata !== '') { + emitNode(parser, 'oncdata', parser.cdata) + parser.cdata = '' + } + if (parser.script !== '') { + emitNode(parser, 'onscript', parser.script) + parser.script = '' + } + } + + SAXParser.prototype = { + end: function () { end(this) }, + write: write, + resume: function () { this.error = null; return this }, + close: function () { return this.write(null) }, + flush: function () { flushBuffers(this) } + } + + var Stream + try { + Stream = __nccwpck_require__(92413).Stream + } catch (ex) { + Stream = function () {} + } + + var streamWraps = sax.EVENTS.filter(function (ev) { + return ev !== 'error' && ev !== 'end' + }) + + function createStream (strict, opt) { + return new SAXStream(strict, opt) + } + + function SAXStream (strict, opt) { + if (!(this instanceof SAXStream)) { + return new SAXStream(strict, opt) + } + + Stream.apply(this) + + this._parser = new SAXParser(strict, opt) + this.writable = true + this.readable = true + + var me = this + + this._parser.onend = function () { + me.emit('end') + } + + this._parser.onerror = function (er) { + me.emit('error', er) + + // if didn't throw, then means error was handled. + // go ahead and clear error, so we can write again. + me._parser.error = null + } + + this._decoder = null + + streamWraps.forEach(function (ev) { + Object.defineProperty(me, 'on' + ev, { + get: function () { + return me._parser['on' + ev] + }, + set: function (h) { + if (!h) { + me.removeAllListeners(ev) + me._parser['on' + ev] = h + return h + } + me.on(ev, h) + }, + enumerable: true, + configurable: false + }) + }) + } + + SAXStream.prototype = Object.create(Stream.prototype, { + constructor: { + value: SAXStream + } + }) + + SAXStream.prototype.write = function (data) { + if (typeof Buffer === 'function' && + typeof Buffer.isBuffer === 'function' && + Buffer.isBuffer(data)) { + if (!this._decoder) { + var SD = __nccwpck_require__(24304).StringDecoder + this._decoder = new SD('utf8') + } + data = this._decoder.write(data) + } + + this._parser.write(data.toString()) + this.emit('data', data) + return true + } + + SAXStream.prototype.end = function (chunk) { + if (chunk && chunk.length) { + this.write(chunk) + } + this._parser.end() + return true + } + + SAXStream.prototype.on = function (ev, handler) { + var me = this + if (!me._parser['on' + ev] && streamWraps.indexOf(ev) !== -1) { + me._parser['on' + ev] = function () { + var args = arguments.length === 1 ? [arguments[0]] : Array.apply(null, arguments) + args.splice(0, 0, ev) + me.emit.apply(me, args) + } + } + + return Stream.prototype.on.call(me, ev, handler) + } + + // this really needs to be replaced with character classes. + // XML allows all manner of ridiculous numbers and digits. + var CDATA = '[CDATA[' + var DOCTYPE = 'DOCTYPE' + var XML_NAMESPACE = 'http://www.w3.org/XML/1998/namespace' + var XMLNS_NAMESPACE = 'http://www.w3.org/2000/xmlns/' + var rootNS = { xml: XML_NAMESPACE, xmlns: XMLNS_NAMESPACE } + + // http://www.w3.org/TR/REC-xml/#NT-NameStartChar + // This implementation works on strings, a single character at a time + // as such, it cannot ever support astral-plane characters (10000-EFFFF) + // without a significant breaking change to either this parser, or the + // JavaScript language. Implementation of an emoji-capable xml parser + // is left as an exercise for the reader. + var nameStart = /[:_A-Za-z\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD]/ + + var nameBody = /[:_A-Za-z\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD\u00B7\u0300-\u036F\u203F-\u2040.\d-]/ + + var entityStart = /[#:_A-Za-z\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD]/ + var entityBody = /[#:_A-Za-z\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD\u00B7\u0300-\u036F\u203F-\u2040.\d-]/ + + function isWhitespace (c) { + return c === ' ' || c === '\n' || c === '\r' || c === '\t' + } + + function isQuote (c) { + return c === '"' || c === '\'' + } + + function isAttribEnd (c) { + return c === '>' || isWhitespace(c) + } + + function isMatch (regex, c) { + return regex.test(c) + } + + function notMatch (regex, c) { + return !isMatch(regex, c) + } + + var S = 0 + sax.STATE = { + BEGIN: S++, // leading byte order mark or whitespace + BEGIN_WHITESPACE: S++, // leading whitespace + TEXT: S++, // general stuff + TEXT_ENTITY: S++, // & and such. + OPEN_WAKA: S++, // < + SGML_DECL: S++, // + SCRIPT: S++, //